当前位置： 首页 > article >正文

Dubbo SPI源码

article 2024/11/13 14:09:23

文章目录

    • Dubbo SPI
    • 使用方式
    • AOP功能
    • 源码剖析
      • @SPI注解
      • 1.获取加载器
      • 2.获取拓展实例对象
      • 3.创建拓展类的实例对象

Dubbo SPI

Dubbo 的 SPI（Service Provider Interface）机制是一种强大的扩展机制，它允许开发者在运行时动态地替换或增加框架的功能。Dubbo 的 SPI 机制与 Java 原生的 SPI 机制有所不同，它提供了更多的灵活性和功能。

在这里插入图片描述SPI机制的核心组件包括：

  • 服务接口：接口定义了服务提供者需要实现的方法，应用程序将使用这个接口与具体的服务实现进行交互。

  • 服务实现：这是实现了服务接口的具体类，第三方可以为服务接口提供多个实现。

  • 服务提供者配置文件：这是一个位于META-INF/dubbo目录下的文件，文件名与服务接口的全限定名相同，该文件包含了服务实现类的全限定名，每行一个接口的具体实现类，在运行时就可以加载这些实现类。

  • ServiceLoader：用于加载服务实现，应用程序可以使用ServiceLoader来获取服务接口的所有具体实现类。

SPI的工作流程如下：

  • 定义服务接口。
  • 实现服务接口，创建具体的服务实现类。
  • 在META-INF/dubbo目录下创建服务提供者配置文件，列出所有服务实现类的全限定名。
  • 使用ServiceLoader加载服务具体实现类，并根据需要使用它们。

总结就是说SPI机制使得应用程序可以在运行时动态地选择和加载服务实现，从而提高了应用程序的可扩展性和灵活性。

使用方式

使用方式和 java的SPI类似，首先通过@SPI注解定义服务接口

@SPI
public interface Greeting {
    public void sayHello();
}

再定义服务实现类实现接口并重写接口中的方法

public class ChineseGreeting implements Greeting {
    @Override
    public void sayHello() {
        System.out.println("你好，世界!");
    }
}

public class EnglishGreeting implements Greeting {
    @Override
    public void sayHello() {
        System.out.println("Hello World!");
    }
}

在META-INF/dubbo目录下创建一个名为com.xydp.dubbo.Greeting的文件，用于存储自定义键名（这里与java的 SPI 不同，需要自定义key的名称，键名随意，主要是为了实现后面按需加载）与具体实现类的全限定名。文件内容如下：
在这里插入图片描述
文件内容

english=com.xydp.dubbo.EnglishGreeting
chinese=com.xydp.dubbo.ChineseGreeting

编写测试类

public class SpiDemo {
    public static void main(String[] args) {
        ExtensionLoader<Greeting> extensionLoader = ExtensionLoader.getExtensionLoader(Greeting.class);
         Greeting englishGreeting = extensionLoader.getExtension("english");
        englishGreeting.sayHello();
        System.out.println(englishGreeting.getClass());
    }
}

输出结果
在这里插入图片描述
Dubbo的 SPI 通过自定义键名的方式按需加载，可以在O(1)的时间复杂度获取具体的服务实现类，而java SPI 需要通过迭代器的方式全局遍历获取某个具体实现类，达到线性时间复杂度O(n)。

Dubbo SPI与Java SPI区别

  • 设计理念：Java SPI 主要关注于服务实现的加载，而 Dubbo SPI 更注重于框架的可扩展性和灵活性。

  • 功能丰富度：Dubbo SPI 提供了更多的功能，如自适应扩展、激活扩展和依赖注入等，而 Java SPI 功能相对有限。

  • 加载方式：Java SPI 采用全局加载的方式，加载特定的实现类时间复杂度达到O(n)，性能差，而 Dubbo SPI 采用按需加载的方式，时间复杂度只需O(1),提高了性能。

  • 配置方式：Dubbo SPI 支持通过注解和 URL 参数进行动态配置，使得框架更加灵活；Java SPI 主要通过配置文件进行静态配置。

总之，Java SPI 和 Dubbo SPI 都是用于实现服务发现和实现加载的机制，但 Dubbo SPI 在设计理念、功能和用法上更加灵活和强大，Dubbo SPI 更适合用于构建复杂的分布式系统，而 Java SPI 更适合用于简单的服务加载场景。

AOP功能

在 Dubbo 中，实现 AOP 功能的方式是通过自定义 Wrapper 类实现的，Dubbo 要求实现 AOP 功能的类以 Wrapper 结尾，这是一种约定，以便于识别这些类是用于包装服务实现的，Wrapper 类是 Dubbo 框架的一部分，用于在运行时动态地为服务实现类添加额外的功能，原理和Spring AOP类似，将通知织入所要执行的目标方法前后。

public class GreetingWrapper1 implements  Greeting{
    private Greeting greeting;
    public GreetingWrapper1(Greeting greeting){
        this.greeting = greeting;
    }


    @Override
    public void sayHello() {
        System.out.println("before do someting");
        this.greeting.sayHello();
        System.out.println("after do something");
    }
}

同时需要在配置文件中添加包装类的全限定名
在这里插入图片描述

测试类保持不变

public class SpiDemo {
    public static void main(String[] args) {
        ExtensionLoader<Greeting> extensionLoader = ExtensionLoader.getExtensionLoader(Greeting.class);
         Greeting englishGreeting = extensionLoader.getExtension("english");
        englishGreeting.sayHello();
        System.out.println(englishGreeting.getClass());
    }
}

输出结果
在这里插入图片描述
在这里插入图片描述

从结果可以看出最终执行的是GreetingWrapper1中greeting的sayHello()方法，GreetingWrapper1在这里充当EnglishGreeting的代理对象。

源码剖析

@SPI注解

在 Dubbo 的 SPI 机制中，@SPI 注解用于标记一个接口为可扩展的扩展点，@SPI 注解有两个可选参数：value 和 scope。

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface SPI {
    String value() default "";

    ExtensionScope scope() default ExtensionScope.APPLICATION;
}

value 参数用于指定扩展点的默认实现类，当没有其他扩展实现类被明确指定时，Dubbo 会使用 value 参数指定的key，表示从配置文件中查找对应的实现类。
scope 参数指定扩展实现类的作用域，有以下四种作用域

  • Constants.FRAMEWORK（框架作用域）：在Dubbo框架内，实现类只会生成唯一实例，并在整个应用程序内共享。

  • Constants.APPLICATION（应用程序作用域）：在应用程序上下文中，实现类仅会被实例化一次，并在整个应用程序中共享，是默认的作用域。

  • Constants.MODULE（模块作用域）：在模块上下文中，该实现类将仅创建一个实例，并在该模块内共享。

  • Constants.SELF（自定义作用域）：用户可定义实现类的作用范围，涵盖任意范围。

1.获取加载器

当执行获取拓展加载器这行代码时

 ExtensionLoader<Greeting> extensionLoader = ExtensionLoader.getExtensionLoader(Greeting.class);

源码如下

public <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
        //检查拓展目录是否被删除
        this.checkDestroyed();
        //校验类型是否为null
        if (type == null) {
            throw new IllegalArgumentException("Extension type == null");
        } else if (!type.isInterface()) {
            throw new IllegalArgumentException("Extension type (" + type + ") is not an interface!");
        } else if (!withExtensionAnnotation(type)) {
            throw new IllegalArgumentException("Extension type (" + type + ") is not an extension, because it is NOT annotated with @" + SPI.class.getSimpleName() + "!");
        } else {
        //如果类型不为null,尝试从缓存中获取加载器loader以及作用域
            ExtensionLoader<T> loader = (ExtensionLoader)this.extensionLoadersMap.get(type);
            ExtensionScope scope = (ExtensionScope)this.extensionScopeMap.get(type);
            //如果缓存中不存在scope,就从SPI注解获取scope,再放入缓存
            if (scope == null) {
                SPI annotation = (SPI)type.getAnnotation(SPI.class);
                scope = annotation.scope();
                this.extensionScopeMap.put(type, scope);
            }
						//如果加载器为null且作用域是SELF,就直接创建loader
            if (loader == null && scope == ExtensionScope.SELF) {
                loader = this.createExtensionLoader0(type);
            }
					//若lader为空，作用域不是SELF且父类加载器不为空，那么尝试从父类加载器去获取loader
            if (loader == null && this.parent != null) {
                loader = this.parent.getExtensionLoader(type);
            }
					//若无法从父类加载器获取loader，那么自己实例化一个loader并放入缓存
            if (loader == null) {
                loader = this.createExtensionLoader(type);
            }
					//返回加载器
            return loader;
        }
    }

    private <T> ExtensionLoader<T> createExtensionLoader(Class<T> type) {
        ExtensionLoader<T> loader = null;
        	//根据SPI注解的属性判断作用域是否等于默认作用域
        if (this.isScopeMatched(type)) {
            loader = this.createExtensionLoader0(type);
        }

        return loader;
    }

    private <T> ExtensionLoader<T> createExtensionLoader0(Class<T> type) {
          //检查拓展目录是否被删除
        this.checkDestroyed();
        //根据类型创建加载器并放入缓存
        this.extensionLoadersMap.putIfAbsent(type, new ExtensionLoader(type, this, this.scopeModel));
        //从缓存获取loader
        ExtensionLoader<T> loader = (ExtensionLoader)this.extensionLoadersMap.get(type);
        //返回loader
        return loader;
    }

2.获取拓展实例对象

执行这行代码获取拓展类的实例对象

Greeting englishGreeting = extensionLoader.getExtension("english");

源码如下

    public T getExtension(String name) {
    //获取拓展实例对象
        T extension = this.getExtension(name, true);
        if (extension == null) {
            throw new IllegalArgumentException("Not find extension: " + name);
        } else {
        //获取到了返回
            return extension;
        }
    }

public T getExtension(String name, boolean wrap) {
 //检查拓展目录是否被删除
        this.checkDestroyed();
        //若参数为空，抛异常
        if (StringUtils.isEmpty(name)) {
            throw new IllegalArgumentException("Extension name == null");
        }
        //若拓展类名称为true,表示使用SPI注解中声明的默认拓展实现类 
        else if ("true".equals(name)) {
            return this.getDefaultExtension();
        } else {
            String cacheKey = name;
            if (!wrap) {
                cacheKey = name + "_origin";
            }
					//尝试从缓存中获取拓展类实例对象，如果获取不到cacheKey对应的holder
					//则会创建一个空的holder再返回
            Holder<Object> holder = this.getOrCreateHolder(cacheKey);
            Object instance = holder.get();
            //若获取不到，则采用双重检验的单例模式创建实例对象，代码第一次执行是获取不到对象的，
            //此时instance为null
            //第一层判断是为了提高执行速度，防止实例对象不为空时还去竞争锁
            if (instance == null) {
                synchronized(holder) {
                    instance = holder.get();
                    //第二层判断是为了避免创建重复的实例对象
                    if (instance == null) {
                    //获取拓展类实例对象
                        instance = this.createExtension(name, wrap);
                     //将实例对象放入缓存
                        holder.set(instance);
                    }
                }
            }
				//返回实例对象
            return instance;
        }
    }

    private Holder<Object> getOrCreateHolder(String name) {
    //根据推展类名称获取缓存对象holder
        Holder<Object> holder = (Holder)this.cachedInstances.get(name);
        //获取不到，则创建一个空的holder并放入缓存
        if (holder == null) {
            this.cachedInstances.putIfAbsent(name, new Holder());
            holder = (Holder)this.cachedInstances.get(name);
        }
			//返回holder
        return holder;
    }

Holder类是一个缓存对象，用于缓存自定义键名对应的拓展类实例对象

public class Holder<T> {
//volatil的作用是禁止指令重排序
    private volatile T value;

    public Holder() {
    }
	
    public void set(T value) {
        this.value = value;
    }

    public T get() {
        return this.value;
    }
}

可以看到缓存Holder类用volatile修饰变量，这样做是为了禁止指令重排序，避免返回一个未初始化完成的实例对象，创建一个对象分为3步

  1. 为对象分配内存空间
  2. 初始化对象
  3. 将对象指向1所分配的内存空间

若holder没有用volatile修饰，2和3的指令发生顺序颠倒，此时指令的执行顺序为1->3->2,当执行完3时，代码执行到第二层 if 判断，发现instance不为null,此时直接返回instance,返回的是还未初始化的对象(对象的属性未赋值)。

3.创建拓展类的实例对象

第一次执行时缓存是获取不到实例对象的，所以需要创建，之后就能从缓存中直接获取。

 private T createExtension(String name, boolean wrap) {
 	//解析配置文件，先获取所有的拓展类，再根据类名获取对应的class
        Class<?> clazz = (Class)this.getExtensionClasses().get(name);
        if (clazz != null && !this.unacceptableExceptions.contains(name)) {
            try {
            //根据类对象从缓存获取类实例对象
                T instance = this.extensionInstances.get(clazz);
               //获取不到，则通过反射的方式创建实例对象并放入缓存
                if (instance == null) {
                    this.extensionInstances.putIfAbsent(clazz, this.createExtensionInstance(clazz));
                    instance = this.extensionInstances.get(clazz);
                    //前置处理
                    instance = this.postProcessBeforeInitialization(instance, name);
                    //依赖注入
                    this.injectExtension(instance);
                    //后置处理
                    instance = this.postProcessAfterInitialization(instance, name);
                }
						//包装类的处理，用于实现AOP功能
                if (wrap) {
                    List<Class<?>> wrapperClassesList = new ArrayList();
                    if (this.cachedWrapperClasses != null) {
                        wrapperClassesList.addAll(this.cachedWrapperClasses);
                        wrapperClassesList.sort(WrapperComparator.COMPARATOR);
                        Collections.reverse(wrapperClassesList);
                    }

                    if (CollectionUtils.isNotEmpty(wrapperClassesList)) {
                        Iterator var6 = wrapperClassesList.iterator();

                        while(var6.hasNext()) {
                            Class<?> wrapperClass = (Class)var6.next();
                            Wrapper wrapper = (Wrapper)wrapperClass.getAnnotation(Wrapper.class);
                            boolean match = wrapper == null || (ArrayUtils.isEmpty(wrapper.matches()) || ArrayUtils.contains(wrapper.matches(), name)) && !ArrayUtils.contains(wrapper.mismatches(), name);
                            if (match) {
                                instance = this.injectExtension(wrapperClass.getConstructor(this.type).newInstance(instance));
                                instance = this.postProcessAfterInitialization(instance, name);
                            }
                        }
                    }
                }
						//生命周期管理
                this.initExtension(instance);
                return instance;
            } catch (Throwable var10) {
                throw new IllegalStateException("Extension instance (name: " + name + ", class: " + this.type + ") couldn't be instantiated: " + var10.getMessage(), var10);
            }
        } else {
            throw this.findException(name);
        }
    }

（1)解析配置文件，获取拓展类

    private Map<String, Class<?>> getExtensionClasses() {
    //从缓存中获取拓展类
        Map<String, Class<?>> classes = (Map)this.cachedClasses.get();
        //缓存获取不到，通过双重检查锁的单例模式创建拓展类
        if (classes == null) {
            synchronized(this.cachedClasses) {
                classes = (Map)this.cachedClasses.get();
                if (classes == null) {
                    try {
                    //解析配置文件，获取类信息并放入缓存
                        classes = this.loadExtensionClasses();
                    } catch (InterruptedException var5) {
                        logger.error("0-15", "", "", "Exception occurred when loading extension class (interface: " + this.type + ")", var5);
                        throw new IllegalStateException("Exception occurred when loading extension class (interface: " + this.type + ")", var5);
                    }

                    this.cachedClasses.set(classes);
                }
            }
        }

        return classes;
    }

    private Map<String, Class<?>> loadExtensionClasses() throws InterruptedException {
        //检查拓展目录是否被销毁
        this.checkDestroyed();
        //判断SPI注解中的默认参数是否合法
        this.cacheDefaultExtensionName();
        Map<String, Class<?>> extensionClasses = new HashMap();
        LoadingStrategy[] var2 = strategies;
        int var3 = var2.length;
			//解析三个配置文件的信息，并将类信息放入缓存
			//三个配置文件 META-INF/dubbo/,META-INF/dubbo/internal/,META-INF/services/
        for(int var4 = 0; var4 < var3; ++var4) {
            LoadingStrategy strategy = var2[var4];
            this.loadDirectory(extensionClasses, strategy, this.type.getName());
            if (this.type == ExtensionInjector.class) {
                this.loadDirectory(extensionClasses, strategy, ExtensionFactory.class.getName());
            }
        }

        return extensionClasses;
    }

(2)实例化对象

 T instance = this.extensionInstances.get(clazz);
                if (instance == null) {
                    this.extensionInstances.putIfAbsent(clazz, this.createExtensionInstance(clazz));
                    instance = this.extensionInstances.get(clazz);
                    }
	//通过反射的方式创建实例对象
    private Object createExtensionInstance(Class<?> type) throws ReflectiveOperationException {
        return this.instantiationStrategy.instantiate(type);
    }

(3)前置处理
前置处理和Spring的前置处理类似，可以在实例对象初始化之前执行一些自定义的初始化逻辑，例如检查实例对象是否满足某些条件，或者为实例对象添加一些额外的功能。

instance = this.postProcessBeforeInitialization(instance, name);

 private T postProcessBeforeInitialization(T instance, String name) throws Exception {
        ExtensionPostProcessor processor;
        if (this.extensionPostProcessors != null) {
            for(Iterator var3 = this.extensionPostProcessors.iterator(); var3.hasNext(); instance = processor.postProcessBeforeInitialization(instance, name)) {
                processor = (ExtensionPostProcessor)var3.next();
            }
        }

        return instance;
    }

(4)依赖注入
Dubbo的依赖注入只支持Setter方法级别的注入。

this.injectExtension(instance);

 private T injectExtension(T instance) {
        if (this.injector == null) {
            return instance;
        } else {
            try {
                Method[] var2 = instance.getClass().getMethods();
                int var3 = var2.length;

                for(int var4 = 0; var4 < var3; ++var4) {
                    Method method = var2[var4];
                    //方法是setter方法，方法不包含DisableInject注解且instance不是基本数据类型
                    if (this.isSetter(method) && !method.isAnnotationPresent(DisableInject.class) && method.getDeclaringClass() != ScopeModelAware.class && (!(instance instanceof ScopeModelAware) && !(instance instanceof ExtensionAccessorAware) || !ignoredInjectMethodsDesc.contains(ReflectUtils.getDesc(method)))) {
                    //获取方法的参数类型
                        Class<?> pt = method.getParameterTypes()[0];
                        if (!ReflectUtils.isPrimitives(pt)) {
                            try {
                            //获取参数值
                                String property = this.getSetterProperty(method);
                               //根据参数类型和参数值获取依赖对象
                                Object object = this.injector.getInstance(pt, property);
                                if (object != null) {
                                //将依赖对象object注入instance
                                    method.invoke(instance, object);
                                }
                            } catch (Exception var9) {
                                logger.error("0-15", "", "", "Failed to inject via method " + method.getName() + " of interface " + this.type.getName() + ": " + var9.getMessage(), var9);
                            }
                        }
                    }
                }
            } catch (Exception var10) {
                logger.error("0-15", "", "", var10.getMessage(), var10);
            }

            return instance;
        }
    }

(5)后置处理
后置处理的思想与Spring的后置处理类似。

 instance = this.postProcessAfterInitialization(instance, name);
 
    private T postProcessAfterInitialization(T instance, String name) throws Exception {
        if (instance instanceof ExtensionAccessorAware) {
            ((ExtensionAccessorAware)instance).setExtensionAccessor(this.extensionDirector);
        }

        ExtensionPostProcessor processor;
        if (this.extensionPostProcessors != null) {
            for(Iterator var3 = this.extensionPostProcessors.iterator(); var3.hasNext(); instance = processor.postProcessAfterInitialization(instance, name)) {
                processor = (ExtensionPostProcessor)var3.next();
            }
        }

        return instance;
    }

(6)包装类Wrapper处理
Dubbo的AOP功能就是通过Wrapper实现的。

 if (wrap) {
                    List<Class<?>> wrapperClassesList = new ArrayList();
            				//判断wrapper缓存包装类集合是否为空
            				// 不为空则加入list集合中，然后排序之后再翻转
                    if (this.cachedWrapperClasses != null) {
                        wrapperClassesList.addAll(this.cachedWrapperClasses);
                        wrapperClassesList.sort(WrapperComparator.COMPARATOR);
                        Collections.reverse(wrapperClassesList);
                    }
									//判断wrapper包装类集合不为空
                    if (CollectionUtils.isNotEmpty(wrapperClassesList)) {
                        Iterator var6 = wrapperClassesList.iterator();
							//遍历集合中的每一个包装类
                        while(var6.hasNext()) {
                            Class<?> wrapperClass = (Class)var6.next();
                            //获取包装类的注解
                            Wrapper wrapper = (Wrapper)wrapperClass.getAnnotation(Wrapper.class);
                            //判断是否符合包装条件
                            boolean match = wrapper == null || (ArrayUtils.isEmpty(wrapper.matches()) || ArrayUtils.contains(wrapper.matches(), name)) && !ArrayUtils.contains(wrapper.mismatches(), name);
                           //符合包装条件，将当前实例对象添加到包装类中，并做一些后置处理
                            if (match) {
                            //将instance作为参数传给wrapper的构造方法，通过反射的方式创建wrapper实例，
                            //再往wrapper实例注入依赖，然后将wrapper赋值给instance,再对instance做后置处理
                                instance = this.injectExtension(wrapperClass.getConstructor(this.type).newInstance(instance));
                                instance = this.postProcessAfterInitialization(instance, name);
                            }
                        }
                    }
                }

(7)生命周期管理

  this.initExtension(instance);
   
    private void initExtension(T instance) {
        if (instance instanceof Lifecycle) {
            Lifecycle lifecycle = (Lifecycle)instance;
            lifecycle.initialize();
        }

    }

http://www.kler.cn/a/312675.html

相关文章：

  • 管家婆财贸ERP BB059.银行流水导入对账
  • 无人机动力测试台如何快速外接第三方传感器
  • Spring框架之适配器模式 (Adapter Pattern)
  • XML Schema 字符串数据类型
  • Java反序列化之CommonsCollections2链的学习
  • 【大数据学习 | kafka高级部分】kafka中的选举机制
  • Linux 开发工具（vim、gcc/g++、make/Makefile）+【小程序：进度条】-- 详解
  • 新媒体运营
  • 非守护线程会阻止JVM的终止吗
  • 大联大诠鼎集团推出基于联咏科技、思特威和TDK产品的电子防抖（EIS）摄像头方案
  • 面试复盘与 AI 大模型学习
  • BitLocker硬盘加密的详细教程分享
  • 【简单点】docker如何部署tomcat
  • 3. Internet 协议的安全性
  • 1.4 计算机网络的性能指标
  • 【JAVA开源】基于Vue和SpringBoot的校园美食分享平台
  • Linux创建快捷命令
  • 经纬度计算距离方法
  • Git：版本控制工具介绍
  • 【busybox记录】【shell指令】timeout
  • Flink 与 Kubernetes (K8s)、YARN 和 Mesos集成对比
  • HarmonyOS元服务与卡片
  • 基于Vue 3组合函数的分页、搜索与排序实践 —— nbsaas-boot项目的实际应用
  • .Net Core 生成管理员权限的应用程序
  • 部署在线GBA游戏，并通过docker安装启动
  • 二级等保测评中安全物理环境的重要性及高危项分析