Dubbo SPI 可扩展机制

最新推荐文章于 2024-09-06 22:12:43 发布
原创 最新推荐文章于 2024-09-06 22:12:43 发布 · 399 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

Dubbo SPI（Service Provider Interface）是Dubbo框架中的服务发现机制，它允许在不修改源码的情况下扩展服务。与Java SPI相比，Dubbo SPI提供了更强大的功能，如依赖注入和自适应扩展。在Dubbo SPI中，通过`ExtensionLoader`加载扩展配置，实例化扩展类，并进行依赖注入和AOP处理。扩展点可以通过`@SPI`和`@Adaptive`注解定义，默认实现和自适应机制可以根据URL参数动态选择。此外，`@Activate`注解用于激活特定条件下的扩展点。Dubbo SPI还支持与Spring的集成，实现更加灵活的扩展点管理。

博文目录

文章目录

JDK java.util.ServiceLoader SPI 扩展机制

Dubbo SPI 示例

// 配置
// 在指定目录文件下添加内容 META-INF/dubbo/com.mrathena.Person
yellow=com.mrathena.YellowPerson
black=com.mrathena.BlackPerson
white=com.mrathena.WhitePerson
// Demo
ExtensionLoader<Person> extensionLoader = ExtensionLoader.getExtensionLoader(Person.class);
Person person = extensionLoader.getExtension("black");
System.out.println(person);
System.out.println(extensionLoader.getExtension("yellow"));
// 结果
com.mrathena.BlackPerson@2acf57e3
com.mrathena.YellowPerson@96532d6

Dubbo SPI 实例

ExtensionLoader<Protocol> extensionLoader = ExtensionLoader.getExtensionLoader(Protocol.class);
Protocol protocol = extensionLoader.getExtension("dubbo");
// 结果
org.apache.dubbo.rpc.protocol.ProtocolListenerWrapper@6b2fad11

上面这个Demo就是Dubbo常见的写法，表示获取"dubbo"对应的Protocol扩展点。Protocol是一个接口。

在ExtensionLoader类的内部有一个static的ConcurrentHashMap，用来缓存某个接口类型所对应的ExtensionLoader实例

Dubbo SPI 和 Java SPI 的对比

Dubbo SPI 是在 Java SPI 的基础上做了扩展, 使得其功能更加强大, 针对 Java SPI 的如下一些不足做了优化

  • 只能遍历所有的实现，并全部实例化
  • 配置文件中只是简单的列出了所有的扩展实现，而没有给他们命名。导致在程序中很难去准确的引用它们
  • 扩展如果依赖其他的扩展，做不到自动注入和装配
  • 扩展很难和其他的框架集成，比如扩展里面依赖了一个Spring bean，原生的Java SPI不支持

Dubbo SPI 的好处

  • 不需要改动源码就可以实现扩展，解耦。
  • 实现扩展对原来的代码几乎没有侵入性。
  • 只需要添加配置就可以实现扩展，符合开闭原则。

Dubbo SPI 概念

ExtensionLoader

ExtensionLoader表示某个接口的扩展点加载器，可以用来加载某个扩展点实例

在ExtensionLoader中有几个非常重要的属性：

  • ConcurrentMap<Class<?>, ExtensionLoader<?>> EXTENSION_LOADERS = new ConcurrentHashMap<>(), 缓存某个接口类型所对应的ExtensionLoader实例
  • Class<?> type：表示当前ExtensionLoader实例是哪个接口的扩展点加载器
  • ExtensionFactory objectFactory：扩展点工厂（对象工厂），可以获得某个对象

ExtensionLoader和ExtensionFactory的区别在于：

  • ExtensionLoader最终所得到的对象是Dubbo SPI机制产生的
  • ExtensionFactory最终所得到的对象可能是Dubbo SPI机制所产生的，也可能是从Spring容器中所获得的对象

在ExtensionLoader中有三个常用的方法：

  • getExtension(“dubbo”)：表示获取名字为dubbo的扩展点实例
  • getAdaptiveExtension()：表示获取一个自适应的扩展点实例
  • getActivateExtension(URL url, String[] values, String group)：表示一个可以被url激活的扩展点实例

自适应扩展点实例:

  • 它其实就是当前这个接口的一个代理对象
ExtensionLoader<Protocol> extensionLoader = ExtensionLoader.getExtensionLoader(Protocol.class);
Protocol protocol = extensionLoader.getExtension("dubbo");

当我们调用上述代码，我们会将得到一个DubboProtocol的实例对象，但在getExtension()方法中，Dubbo会对DubboProtocol对象进行依赖注入（也就是自动给属性赋值，属性的类型为一个接口，记为A接口），这个时候，对于Dubbo来说它并不知道该给这个属性赋什么值，换句话说，Dubbo并不知道在进行依赖注入时该找一个什么的的扩展点对象给这个属性，这时就会预先赋值一个A接口的自适应扩展点实例，也就是A接口的一个代理对象。

后续，在A接口的代理对象被真正用到时，才会结合URL信息找到真正的A接口对应的扩展点实例进行调用。

Dubbo SPI 有如下几个概念

  • 扩展点：一个接口
  • 扩展：扩展点的实现类
  • 扩展自适应实例：其实就是一个Extension的代理，它实现了扩展点接口并持有该接口的引用。在调用扩展点的接口方法时，会根据实际的参数来决定要使用哪个扩展。dubbo会根据接口中的参数，自动地决定选择哪个实现
  • @SPI：该注解作用于接口上，表明该接口是一个扩展点, 可选value属性, 指定该接口的默认实现是value值对应的实现类, 在调用 getExtension(“true”)时, 将会调用 getDefaultExtension() 获取 value 对应的实现类实例
  • @Adaptive：该注解用在扩展接口的方法上，表示该方法是一个自适应方法，Dubbo在为扩展点生成自适应实例时，如果方法有该注解，会为该方法生成对应的代码。该注解也可以用在接口的某个实现类上，表示该实现类是扩展接口的自适应实现类，调用getAdaptiveExtension方法时将直接返回该实例而不是创建代理对象

Dubbo SPI 主流程

  • 根据传入的接口类型从指定位置加载扩展配置, 并缓存在一个 扩展名(String):实现类类型(Class) 的map中
  • 根据传入的name, 从该map中拿到对应的class, 并实例化
  • 对该实例执行依赖注入 ioc
  • 对该实例执行包装并对接过执行依赖注入(如有包装类) aop
  • 最后返回包装后的实例

加载扩展配置 与 扩展类实例化

public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
    if (type == null) {
        throw new IllegalArgumentException("Extension type == null");
    }
    if (!type.isInterface()) {
        throw new IllegalArgumentException("Extension type (" + type + ") is not an interface!");
    }
    if (!withExtensionAnnotation(type)) {
        throw new IllegalArgumentException("Extension type (" + type +
                ") is not an extension, because it is NOT annotated with @" + SPI.class.getSimpleName() + "!");
    }

	// 先看看缓存里面有没有, 没有就放一个
    ExtensionLoader<T> loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
    if (loader == null) {
        EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));
        loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
    }
    return loader;
}

// 在调用getExtension去获取一个扩展点实例后，会对实例进行缓存，下次再获取同样名字的扩展点实例时就会从缓存中拿了。
public T getExtension(String name) {
    if (StringUtils.isEmpty(name)) {
        throw new IllegalArgumentException("Extension name == null");
    }
    // 获取默认扩展类
    if ("true".equals(name)) {
        return getDefaultExtension();
    }

	// 要确保各name对应的实现类都是单例的, 可以根据获取的name的不同加不同的锁(不同name使用同一把锁会影响性能), 但是在name对应的实现类还没有实例化时, 对象为null, 该如何加锁呢? 搞一个Holder对象来持有该实例, 不管实现类是否已初始化, Holder对象都可以被加锁, Holder对象加锁即相当于给不同扩展点加锁了
	// 获取到Holder对象
    final Holder<Object> holder = getOrCreateHolder(name);
    Object instance = holder.get();

    // 如果有两个线程同时来获取同一个name的扩展点对象，那只会有一个线程会进行创建
    if (instance == null) {
        synchronized (holder) {
        	// 一个name对应一把锁
            instance = holder.get();
            if (instance == null) {
                // 创建扩展点实例对象
                instance = createExtension(name);
                holder.set(instance);
            }
        }
    }
    return (T) instance;
}

// 从缓存中获取name对应的Holder对象, 不存在则存入一个新的
private Holder<Object> getOrCreateHolder(String name) {
    // Map<String, Object>
    Holder<Object> holder = cachedInstances.get(name);
    if (holder == null) {
        cachedInstances.putIfAbsent(name, new Holder<>());
        holder = cachedInstances.get(name);
    }
    return holder;
}

// 创建扩展实例的核心流程
// 在调用createExtension(String name)方法去创建一个扩展点实例时，要经过以下几个步骤：
// 1. 根据name找到对应的扩展点实现类
// 2. 根据实现类生成一个实例，把实现类和对应生成的实例进行缓存
// 3. 对生成出来的实例进行依赖注入（给实例的属性进行赋值）
// 4. 对依赖注入后的实例进行AOP（Wrapper）,把当前接口类的所有的Wrapper全部一层一层包裹在实例对象上，没包裹个Wrapper后，也会对Wrapper对象进行依赖注入
// 5. 返回最终的Wrapper对象
private T createExtension(String name) {
    // 获取并缓存所有扩展类 {name:Class}, 接口的所有实现类, 然后获取name对应的实现类
    Class<?> clazz = getExtensionClasses().get(name);
    if (clazz == null) {
        throw findException(name);
    }

    try {
        // 实例缓存, 实现类class:instance
        T instance = (T) EXTENSION_INSTANCES.get(clazz);
        if (instance == null) {
            // 创建实例
            EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance());
            instance = (T) EXTENSION_INSTANCES.get(clazz);
        }

        // 依赖注入 IOC
        injectExtension(instance);

        // AOP，cachedWrapperClasses无序, 所有包装类都包装一遍
        Set<Class<?>> wrapperClasses = cachedWrapperClasses;
        if (CollectionUtils.isNotEmpty(wrapperClasses)) {
            for (Class<?> wrapperClass : wrapperClasses) {
                instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
            }
        }

        return instance;
    } catch (Throwable t) {
        throw new IllegalStateException("Extension instance (name: " + name + ", class: " +
                type + ") couldn't be instantiated: " + t.getMessage(), t);
    }
}

// 加载当前ExtensionLoader对象中指定的接口的所有扩展
// getExtensionClasses()是用来加载当前接口所有的扩展点实现类的，返回一个Map。之后可以从这个Map中按照指定的name获取对应的扩展点实现类。
// 当把当前接口的所有扩展点实现类都加载出来后也会进行缓存，下次需要加载时直接拿缓存中的。
private Map<String, Class<?>> getExtensionClasses() {
    // cachedClasses是一个Holder对象，持有的就是一个Map<String, Class<?>>
    // private final Holder<Map<String, Class<?>>> cachedClasses = new Holder<>();
    // 为什么要多此一举，也是为了解决并发，Holder对象用来作为锁
    Map<String, Class<?>> classes = cachedClasses.get();
    if (classes == null) {
        synchronized (cachedClasses) {
            classes = cachedClasses.get();
            if (classes == null) {
            	// 加载、解析文件 Map, name:clazz
                classes = loadExtensionClasses();
                // holder cachedClasses 中保存 map, name:clazz
                cachedClasses.set(classes);
            }
        }
    }
    return classes;
}

// 指定的路径
private static final String SERVICES_DIRECTORY = "META-INF/services/";
private static final String DUBBO_DIRECTORY = "META-INF/dubbo/";
private static final String DUBBO_INTERNAL_DIRECTORY = DUBBO_DIRECTORY + "internal/";

private Map<String, Class<?>> loadExtensionClasses() {
    // cache接口默认的扩展类
    cacheDefaultExtensionName();

	// Dubbo在加载一个接口的扩展点时，思路是这样的：
	// 1. 根据接口的全限定名去META-INF/dubbo/internal/目录下寻找对应的文件，调用loadResource方法进行加载
	// 2. 根据接口的全限定名去META-INF/dubbo/目录下寻找对应的文件，调用loadResource方法进行加载
	// 3. 根据接口的全限定名去META-INF/services/目录下寻找对应的文件，调用loadResource方法进行加载
	// 从各类加载器负责的路径中查找所有指定路径和文件名的SPI扩展配置文件, 并将其内容加载到extensionClasses中
    Map<String, Class<?>> extensionClasses = new HashMap<>();
    loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY, type.getName());
    loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));
    loadDirectory(extensionClasses, DUBBO_DIRECTORY, type.getName());
    loadDirectory(extensionClasses, DUBBO_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));
    loadDirectory(extensionClasses, SERVICES_DIRECTORY, type.getName());
    loadDirectory(extensionClasses, SERVICES_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));
    return extensionClasses;
}

private void cacheDefaultExtensionName() {
	// 判断该ExtensionLoader对应的接口上是否有@SPI注解
    final SPI defaultAnnotation = type.getAnnotation(SPI.class);
    if (defaultAnnotation == null) {
        return;
    }

	// 获取@SPI注解指定的默认实现类的name
    String value = defaultAnnotation.value();
    if ((value = value.trim()).length() > 0) {
        String[] names = NAME_SEPARATOR.split(value);
        if (names.length > 1) {
            throw new IllegalStateException("More than 1 default extension name on extension " + type.getName()
                    + ": " + Arrays.toString(names));
        }
        if (names.length == 1) {
        	// 将默认实现类的name存到成员变量cachedDefaultName中
            cachedDefaultName = names[0];
        }
    }
}

private void loadDirectory(Map<String, Class<?>> extensionClasses, String dir, String type) {
    String fileName = dir + type;
    try {
        // 根据文件中的内容得到urls， 每个url表示一个扩展配置文件, http=org.apache.dubbo.rpc.protocol.http.HttpProtocol
        Enumeration<java.net.URL> urls;
        ClassLoader classLoader = findClassLoader();
        if (classLoader != null) {
            urls = classLoader.getResources(fileName);
        } else {
            urls = ClassLoader.getSystemResources(fileName);
        }
        if (urls != null) {
            while (urls.hasMoreElements()) {
                java.net.URL resourceURL = urls.nextElement();
                // 遍历url进行加载, 把扩展类添加到extensionClasses中
                loadResource(extensionClasses, classLoader, resourceURL);
            }
        }
    } catch (Throwable t) {
        logger.error("Exception occurred when loading extension class (interface: " +
                type + ", description file: " + fileName + ").", t);
    }
}

// loadResource方法就是完成对文件内容的解析，按行进行解析，会解析出"="两边的内容，"="左边的内容就是扩展点的name，右边的内容就是扩展点实现类，并且会利用ExtensionLoader类的类加载器来加载扩展点实现类。
// 然后调用loadClass方法对name和扩展点实例进行详细的解析，并且最终把他们放到Map中去。
private void loadResource(Map<String, Class<?>> extensionClasses, ClassLoader classLoader, java.net.URL resourceURL) {
    try {
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(resourceURL.openStream(), StandardCharsets.UTF_8))) {
            String line;
            while ((line = reader.readLine()) != null) {
                final int ci = line.indexOf('#');
                if (ci >= 0) {
                    line = line.substring(0, ci);
                }
                line = line.trim();
                if (line.length() > 0) {
                    try {
                        String name = null;
                        int i = line.indexOf('=');
                        if (i > 0) {
                        	// 同时支持name=class和class两种格式, name支持用,分割, 多个name指向通一个实现类class
                            name = line.substring(0, i).trim();
                            line = line.substring(i + 1).trim();
                        }
                        if (line.length() > 0) {
                            // 加载类，并添加到extensionClasses中
                            loadClass(extensionClasses, resourceURL, Class.forName(line, true, classLoader), name);
                        }
                    } catch (Throwable t) {
                        IllegalStateException e = new IllegalStateException("Failed to load extension class (interface: " + type + ", class line: " + line + ") in " + resourceURL + ", cause: " + t.getMessage(), t);
                        exceptions.put(line, e);
                    }
                }
            }
        }
    } catch (Throwable t) {
        logger.error("Exception occurred when loading extension class (interface: " +
                type + ", class file: " + resourceURL + ") in " + resourceURL, t);
    }
}

// 这里的clazz是type的一个实现类
// loadClass方法会做如下几件事情：
// 1. 当前扩展点实现类上是否存在@Adaptive注解，如果存在则把该类认为是当前接口的默认自适应类（接口代理类），并把该类存到cachedAdaptiveClass属性上。
// 2. 当前扩展点实现是否是一个当前接口的一个Wrapper类，如果判断的？就是看当前类中是否存在一个构造方法，该构造方法只有一个参数，参数类型为接口类型，如果存在这一的构造方法，那么这个类就是该接口的Wrapper类，如果是，则把该类添加到cachedWrapperClasses中去， cachedWrapperClasses是一个set。
// 3. 如果不是自适应类，或者也不是Wrapper类，则判断是有存在name，如果没有name，则报错。
// 4. 如果有多个name，则判断一下当前扩展点实现类上是否存在@Activate注解，如果存在，则把该类添加到cachedActivates中，cachedWrapperClasses是一个map。
// 5. 最后，遍历多个name，把每个name和对应的实现类存到extensionClasses中去，extensionClasses就是上文所提到的map。
// 至此，加载类就走完了。
// 回到createExtension(String name)方法中的逻辑，当前这个接口的所有扩展点实现类都扫描完了之后，就可以根据用户所指定的名字，找到对应的实现类了，然后进行实例化，然后进行IOC(依赖注入)和AOP。
private void loadClass(Map<String, Class<?>> extensionClasses, java.net.URL resourceURL, Class<?> clazz, String name) throws NoSuchMethodException {
    if (!type.isAssignableFrom(clazz)) {
        throw new IllegalStateException("Error occurred when loading extension class (interface: " +
                type + ", class line: " + clazz.getName() + "), class "
                + clazz.getName() + " is not subtype of interface.");
    }
    // 判断该实现类是否为自适应扩展, 即判断该实现类是否有Adaptive注解(该注解可以用在类型和方法上)
    if (clazz.isAnnotationPresent(Adaptive.class)) {
    	// 如果成员属性cachedAdaptiveClass是null, 则把该实现类赋值给它
        cacheAdaptiveClass(clazz);
    // 判断该实现类是否为包装类
    } else if (isWrapperClass(clazz)) {
        // 是一个Wrapper类, 在成员属性cachedWrapperClasses中添加该该实现类
        cacheWrapperClass(clazz);
    // 该实现类就是一个普通的实现类, 非自适应也非包装
    } else {
        // 需要有无参的构造方法(获取,没有则报错)
        clazz.getConstructor();

        // 在文件中没有指定name
        if (StringUtils.isEmpty(name)) {
        	// 没有name, 则获取默认name, 实现类的@Extension注解或者默认SimpleClassName
            name = findAnnotationName(clazz);
            if (name.length() == 0) {
                throw new IllegalStateException("No such extension name for the class " + clazz.getName() + " in the config " + resourceURL);
            }
        }

		// 用 Pattern NAME_SEPARATOR = Pattern.compile("\\s*[,]+\\s*") 来分割name
        String[] names = NAME_SEPARATOR.split(name);
        if (ArrayUtils.isNotEmpty(names)) {
            // 判断该实现类上有没有@Activate注解, 有的话就存到成员属性cachedActivates中
            cacheActivateClass(clazz, names[0]);

            // 有多个名字
            for (String n : names) {
                // 存到成员属性cachedNames中, clazz:name
                cacheName(clazz, n);
                // 存到变量extensionClasses中, name:clazz
                saveInExtensionClass(extensionClasses, clazz, n);
            }
        }
    }
}

private void cacheAdaptiveClass(Class<?> clazz) {
   if (cachedAdaptiveClass == null) {
        cachedAdaptiveClass = clazz;
    } else if (!cachedAdaptiveClass.equals(clazz)) {
        throw new IllegalStateException("More than 1 adaptive class found: "
                + cachedAdaptiveClass.getName()
                + ", " + clazz.getName());
    }
}

private boolean isWrapperClass(Class<?> clazz) {
    try {
    	// 获取该实现类的参数类型为type的单参构造函数, 报错说明没有
        clazz.getConstructor(type);
        return true;
    } catch (NoSuchMethodException e) {
        return false;
    }
}

private void cacheWrapperClass(Class<?> clazz) {
  if (cachedWrapperClasses == null) {
        cachedWrapperClasses = new ConcurrentHashSet<>();
    }
    cachedWrapperClasses.add(clazz);
}

private String findAnnotationName(Class<?> clazz) {
	// 从该实现类上获取@Extension注解
    org.apache.dubbo.common.Extension extension = clazz.getAnnotation(org.apache.dubbo.common.Extension.class);
    if (extension != null) {
    	// 存在则返回该注解的value
        return extension.value();
    }

	// 否则返回 未指定name时的默认name
    String name = clazz.getSimpleName();
    // 如果该实现类的简单类名的结尾包含了接口的简单类名, 那么就把结尾相同的部分扔掉
    if (name.endsWith(type.getSimpleName())) {
        name = name.substring(0, name.length() - type.getSimpleName().length());
    }
    return name.toLowerCase();
}

private void cacheActivateClass(Class<?> clazz, String name) {
	// 判断该实现类上有没有@Activate注解
    Activate activate = clazz.getAnnotation(Activate.class);
    if (activate != null) {
    	// 有就添加到成员属性cachedActivates中
        cachedActivates.put(name, activate);
    } else {
        // support com.alibaba.dubbo.common.extension.Activate
        // 没有的话看看有没有alibaba包下的@Acivate注解, 做同样的判断和操作
        com.alibaba.dubbo.common.extension.Activate oldActivate = clazz.getAnnotation(com.alibaba.dubbo.common.extension.Activate.class);
        if (oldActivate != null) {
            cachedActivates.put(name, oldActivate);
        }
    }
}

private void cacheName(Class<?> clazz, String name) {
    if (!cachedNames.containsKey(clazz)) {
        cachedNames.put(clazz, name);
    }
}

private void saveInExtensionClass(Map<String, Class<?>> extensionClasses, Class<?> clazz, String name) {
    Class<?> c = extensionClasses.get(name);
    if (c == null) {
        extensionClasses.put(name, clazz);
    } else if (c != clazz) {
        String duplicateMsg = "Duplicate extension " + type.getName() + " name " + name + " on " + c.getName() + " and " + clazz.getName();
        logger.error(duplicateMsg);
        throw new IllegalStateException(duplicateMsg);
    }
}

Dubbo SPI IOC 依赖注入

  1. 根据当前实例的类，找到这个类中的setter方法，进行依赖注入
  2. 先分析出setter方法的参数类型pt
  3. 再截取出setter方法所对应的属性名property
  4. 调用objectFactory.getExtension(pt, property)得到一个对象，这里就会从Spring容器或通过DubboSpi机制得到一个对象，比较特殊的是，如果是通过DubboSpi机制得到的对象，是pt这个类型的一个自适应对象(代理对象)。
  5. 再反射调用setter方法进行注入
// 在getExtensionLoader的时候
ExtensionLoader<Person> extensionLoader = ExtensionLoader.getExtensionLoader(Person.class);
// 会往缓存中put一个new ExtensionLoader<T>(type), 这时会调用ExtensionLoader的构造函数
EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));
// objectFactory对象本质上是一个ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
// 同样走的SPI机制, 获取的是自适应的扩展, 即所有实现类上有@Adaptive注解的那个实现类, 即AdaptiveExtensionFactory
private ExtensionLoader(Class<?> type) {
    this.type = type;
    // objectFactory表示当前ExtensionLoader内部的一个对象工厂，可以用来获取对象  AdaptiveExtensionFactory
    objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
}

private T injectExtension(T instance) {

    if (objectFactory == null) {
        return instance;
    }

    try {
    	// 遍历所有method, 找到setter方法
        for (Method method : instance.getClass().getMethods()) {
            if (!isSetter(method)) {
                continue;
            }

            // 利用set方法注入
            // 如果方法上有@DisableInject注解则跳过
            if (method.getAnnotation(DisableInject.class) != null) {
                continue;
            }

            // 获取setter的参数类型, 如果是基本数据类型java.lang.Boolean等或者java.lang.Void则跳过
            Class<?> pt = method.getParameterTypes()[0];
            if (ReflectUtils.isPrimitives(pt)) {
                continue;
            }

            try {
                // 得到setXxx中的xxx, 即属性名字
                String property = getSetterProperty(method);

                // 根据参数类型或属性名，从objectFactory中获取到对象，然后调用set方法进行注入
                // 这里的objectFactory对象是AdaptiveExtensionFactory的一个实例
                Object object = objectFactory.getExtension(pt, property);
                if (object != null) {
                	// 调用set方法
                    method.invoke(instance, object);
                }
            } catch (Exception e) {
                logger.error("Failed to inject via method " + method.getName()
                        + " of interface " + type.getName() + ": " + e.getMessage(), e);
            }

        }
    } catch (Exception e) {
        logger.error(e.getMessage(), e);
    }
    return instance;
}

// AdaptiveExtensionFactory 构造函数
public AdaptiveExtensionFactory() {
    // 支持哪些ExtensionFactory (Spi, SPring)
    ExtensionLoader<ExtensionFactory> loader = ExtensionLoader.getExtensionLoader(ExtensionFactory.class);
    List<ExtensionFactory> list = new ArrayList<ExtensionFactory>();
    // 还是调用 加载当前ExtensionLoader对象中指定的接口的所有扩展的方法 Map<String, Class<?>> getExtensionClasses()
    // META-INF/dubbo/internal/org.apache.dubbo.common.extension.ExtensionFactory
    // 该文件有两个, 一个是 dubbo-common 中的, 一个是 dubbo-config-spring 中的, 内容分别如下
    // ---- dubbo-common
    // adaptive=org.apache.dubbo.common.extension.factory.AdaptiveExtensionFactory
	// spi=org.apache.dubbo.common.extension.factory.SpiExtensionFactory
	// ---- dubbo-config-spring
	// spring=org.apache.dubbo.config.spring.extension.SpringExtensionFactory
	// ----
	// 通过 loadClass 方法得知, 如果实现类有@Adaptive注解或实现类是包装类, 则不会添加到extensionClasses这个map中
	// 所以实现类只有 SpiExtensionFactory 和 SpringExtensionFactory
	// 测试时只有Spi一个实现类, 猜测这里会根据是否为Spring环境来判断是否加载 SpringExtensionFactory 这个实现类(jar按需加载?)
    for (String name : loader.getSupportedExtensions()) { // spi, spring
        list.add(loader.getExtension(name));
    }
    factories = Collections.unmodifiableList(list);
}

@Override
public <T> T getExtension(Class<T> type, String name) {
    // 遍历两个ExtensionFactory，从ExtensionFactory中得到实例，只要从某个ExtensionFactory中获取到对象实例就可以了
    // 顺序是先 Spring 再 Spi ?
    // 分别查看两个实现类的getExtension方法
    for (ExtensionFactory factory : factories) {
        T extension = factory.getExtension(type, name);  // SpringExtensionFactory, SpiExtensionFactory
        if (extension != null) {
            return extension;
        }
    }
    return null;
}

// SpringExtensionFactory, 从ApplicationContext中先根据name找, 没有的话再根据type找
public <T> T getExtension(Class<T> type, String name) {
    //SPI should be get from SpiExtensionFactory
    // 如果接口上存在SPI注解，就不从spring中获取对象实例了
    if (type.isInterface() && type.isAnnotationPresent(SPI.class)) {
        return null;
    }
    // 从ApplicationContext中获取bean, byname
    for (ApplicationContext context : CONTEXTS) {
        if (context.containsBean(name)) {
            Object bean = context.getBean(name);
            if (type.isInstance(bean)) {
                return (T) bean;
            }
        }
    }
    logger.warn("No spring extension (bean) named:" + name + ", try to find an extension (bean) of type " + type.getName());
    if (Object.class == type) {
        return null;
    }
    // byType
    for (ApplicationContext context : CONTEXTS) {
        try {
            return context.getBean(type);
        } catch (NoUniqueBeanDefinitionException multiBeanExe) {
            // ...
        }
    }
    logger.warn("No spring extension (bean) named:" + name + ", type:" + type.getName() + " found, stop get bean.");
    return null;
}

// SpiExtensionFactory
public <T> T getExtension(Class<T> type, String name) {
    // 接口上存在SPI注解
    if (type.isInterface() && type.isAnnotationPresent(SPI.class)) {
        ExtensionLoader<T> loader = ExtensionLoader.getExtensionLoader(type);
        if (!loader.getSupportedExtensions().isEmpty()) {
            return loader.getAdaptiveExtension(); // 接口的Adaptive类（代理对象）
        }
    }
    return null;
}

public T getAdaptiveExtension() {
    Object instance = cachedAdaptiveInstance.get();
    if (instance == null) {
        if (createAdaptiveInstanceError != null) {
            throw new IllegalStateException("Failed to create adaptive instance: " +
                    createAdaptiveInstanceError.toString(),
                    createAdaptiveInstanceError);
        }

        synchronized (cachedAdaptiveInstance) {
            instance = cachedAdaptiveInstance.get();
            if (instance == null) {
                try {
                    instance = createAdaptiveExtension();
                    cachedAdaptiveInstance.set(instance);
                } catch (Throwable t) {
                    createAdaptiveInstanceError = t;
                    throw new IllegalStateException("Failed to create adaptive instance: " + t.toString(), t);
                }
            }
        }
    }

    return (T) instance;
}

private T createAdaptiveExtension() {
    try {
        return injectExtension((T) getAdaptiveExtensionClass().newInstance());
    } catch (Exception e) {
        throw new IllegalStateException("Can't create adaptive extension " + type + ", cause: " + e.getMessage(), e);
    }
}

private Class<?> getAdaptiveExtensionClass() {
    // 获取当前接口的所有扩展类
    getExtensionClasses();
    // 缓存了@Adaptive注解标记的类
    if (cachedAdaptiveClass != null) {
        return cachedAdaptiveClass;
    }
    // 如果某个接口没有手动指定一个Adaptive类，那么就自动生成一个Adaptive类
    return cachedAdaptiveClass = createAdaptiveExtensionClass();
}

private Class<?> createAdaptiveExtensionClass() {
    // type是类型, cachedDefaultName是接口默认的扩展点实现的名字
    String code = new AdaptiveClassCodeGenerator(type, cachedDefaultName).generate();
    ClassLoader classLoader = findClassLoader();
    org.apache.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(org.apache.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
    return compiler.compile(code, classLoader);
}

public String generate() {
    // no need to generate adaptive class since there's no adaptive method found.
    // 接口上必须至少有一个方法有@Adaptive注解才行
    if (!hasAdaptiveMethod()) {
        throw new IllegalStateException("No adaptive method exist on extension " + type.getName() + ", refuse to create the adaptive class!");
    }

    StringBuilder code = new StringBuilder();
    code.append(generatePackageInfo());
    code.append(generateImports());
    code.append(generateClassDeclaration());

    // 遍历接口中的方法，生成代理方法
    Method[] methods = type.getMethods();
    for (Method method : methods) {
        code.append(generateMethod(method));
    }
    code.append("}");

    if (logger.isDebugEnabled()) {
        logger.debug(code.toString());
    }
    return code.toString();
}

举个栗子来看下生成的自适应扩展点实现类的结构

见下方 Dubbo SPI Adaptive 自适应机制

dubbo SPI AOP

Wrapper类: 实现某个接口并持有该接口的引用, 并提供了注入该接口的单参构造函数的类, 需要配置到接口的SPI扩展文件中

dubbo中也实现了一套非常简单的AOP，就是利用Wrapper，如果一个接口的扩展点中包含了多个Wrapper类，那么在实例化完某个扩展点后，就会利用这些Wrapper类对这个实例进行包裹，比如：现在有一个DubboProtocol的实例，同时对于Protocol这个接口还有很多的Wrapper，比如ProtocolFilterWrapper、ProtocolListenerWrapper，那么，当对DubboProtocol的实例完成了IOC之后，就会先调用new ProtocolFilterWrapper(DubboProtocol实例)生成一个新的Protocol的实例，再对此实例进行IOC，完了之后，会再调用new ProtocolListenerWrapper(ProtocolFilterWrapper实例)生成一个新的Protocol的实例，然后进行IOC，从而完成DubboProtocol实例的AOP。

// AOP，cachedWrapperClasses无序, 将cachedWrapperClasses中所有的包装类都包一遍, 同时还做一下依赖注入
Set<Class<?>> wrapperClasses = cachedWrapperClasses;
 if (CollectionUtils.isNotEmpty(wrapperClasses)) {
     for (Class<?> wrapperClass : wrapperClasses) {
         instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
     }
 }

Dubbo SPI Adaptive 自适应机制

如果通过@Adaptive注解来指定某个类为某个接口的代理类, 则Dubbo在生成自适应扩展点对象时实际上生成的就是@Adaptive注解所注解的类的实例对象。否则Dubbo将根据接口生成一套java代码, 然后编译并拿到class对象

// 以org.apache.dubbo.rpc.Protocol接口为例
package org.apache.dubbo.rpc;

import org.apache.dubbo.common.URL;
import org.apache.dubbo.common.extension.Adaptive;
import org.apache.dubbo.common.extension.SPI;

@SPI("dubbo")
public interface Protocol {
    int getDefaultPort();
    @Adaptive
    <T> Exporter<T> export(Invoker<T> invoker) throws RpcException;
    @Adaptive
    <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException;
    void destroy();
}

// 生成出来的代理类对象为
package org.apache.dubbo.rpc;
import org.apache.dubbo.common.extension.ExtensionLoader;
public class Protocol$Adaptive implements org.apache.dubbo.rpc.Protocol {
    
    public void destroy()  {
        throw new UnsupportedOperationException("The method public abstract void org.apache.dubbo.rpc.Protocol.destroy() of interface org.apache.dubbo.rpc.Protocol is not adaptive method!");
    }

    public int getDefaultPort()  {
        throw new UnsupportedOperationException("The method public abstract int org.apache.dubbo.rpc.Protocol.getDefaultPort() of interface org.apache.dubbo.rpc.Protocol is not adaptive method!");
    }
    
    public org.apache.dubbo.rpc.Exporter export(org.apache.dubbo.rpc.Invoker arg0) throws org.apache.dubbo.rpc.RpcException {
        if (arg0 == null) 
            throw new IllegalArgumentException("org.apache.dubbo.rpc.Invoker argument == null");
        if (arg0.getUrl() == null) 
            throw new IllegalArgumentException("org.apache.dubbo.rpc.Invoker argument getUrl() == null");
        org.apache.dubbo.common.URL url = arg0.getUrl();
        String extName = ( url.getProtocol() == null ? "dubbo" : url.getProtocol() );
        if(extName == null) 
            throw new IllegalStateException("Failed to get extension (org.apache.dubbo.rpc.Protocol) name from url (" + url.toString() + ") use keys([protocol])");
        org.apache.dubbo.rpc.Protocol extension = (org.apache.dubbo.rpc.Protocol)ExtensionLoader.getExtensionLoader(org.apache.dubbo.rpc.Protocol.class).getExtension(extName);
        return extension.export(arg0);
    }

    public org.apache.dubbo.rpc.Invoker refer(java.lang.Class arg0, org.apache.dubbo.common.URL arg1) throws org.apache.dubbo.rpc.RpcException {
        if (arg1 == null) throw new IllegalArgumentException("url == null");
        org.apache.dubbo.common.URL url = arg1;
        String extName = ( url.getProtocol() == null ? "dubbo" : url.getProtocol() );
        if(extName == null) throw new IllegalStateException("Failed to get extension (org.apache.dubbo.rpc.Protocol) name from url (" + url.toString() + ") use keys([protocol])");
        org.apache.dubbo.rpc.Protocol extension = (org.apache.dubbo.rpc.Protocol)ExtensionLoader.getExtensionLoader(org.apache.dubbo.rpc.Protocol.class).getExtension(extName);
        return extension.refer(arg0, arg1);
    }
}

可以看到，Protocol接口中有四个方法，但是只有export和refer两个方法进行代理。为什么？因为Protocol接口中在export方法和refer方法上加了@Adaptive注解。但是，不是只要在方法上加了@Adaptive注解就可以进行代理，还有其他条件，比如：

  1. 该方法如果是无参的，那么则会报错
  2. 该方法有参数，可以有多个，并且其中某个参数类型是URL，那么则可以进行代理
  3. 该方法有参数，可以有多个，但是没有URL类型的参数，那么则不能进行代理
  4. 该方法有参数，可以有多个，没有URL类型的参数，但是如果这些参数类型，对应的类中存在getUrl方法（返回值类型为URL），那么也可以进行代理

所以，可以发现，某个接口的Adaptive对象，在调用某个方法时，是通过该方法中的URL参数，通过调用ExtensionLoader.getExtensionLoader(某接口.class).getExtension(扩展名); 得到一个扩展点实例，然后调用该实例对应的方法。

// Adaptive代理类在调用方法时, 根据传入的URL参数来决定返回哪个实现类实例
URL url = new URL("http://", "localhost", 8080);
url = url.addParameter("protocal", "http");

Dubbo Activate 扩展点

每个扩展点都有一个name，通过这个name可以获得该name对应的扩展点实例，但是有的场景下，希望一次性获得多个扩展点实例

ExtensionLoader<Filter> extensionLoader = ExtensionLoader.getExtensionLoader(Filter.class);
URL url = new URL("http://", "localhost", 8080);
url = url.addParameter("cache", "test");

List<Filter> activateExtensions = extensionLoader.getActivateExtension(url, new String[]{"validation"}, CommonConstants.CONSUMER);
for (Filter activateExtension : activateExtensions) {
	System.out.println(activateExtension);
}

会找到5个Filter

org.apache.dubbo.rpc.filter.ConsumerContextFilter@4566e5bd
org.apache.dubbo.rpc.protocol.dubbo.filter.FutureFilter@1ed4004b
org.apache.dubbo.monitor.support.MonitorFilter@ff5b51f
org.apache.dubbo.cache.filter.CacheFilter@25bbe1b6
org.apache.dubbo.validation.filter.ValidationFilter@5702b3b1

前三个是通过CommonConstants.CONSUMER找到的
CacheFilter是通过url中的参数找到的
ValidationFilter是通过指定的name找到的

getActivateExtension(URL url, String[] values, String group)：表示一个可以被url激活的扩展点实例

在一个扩展点类上，可以添加@Activate注解，这个注解的属性有：

  1. String[] group()：表示这个扩展点是属于哪组的，这里组通常分为PROVIDER和CONSUMER，表示该扩展点能在服务提供者端，或者消费端使用
  2. String[] value()：表示的是URL中的某个参数key，当利用getActivateExtension方法来寻找扩展点时，如果传入的url中包含的参数的所有key中，包括了当前扩展点中的value值，那么则表示当前url可以使用该扩展点。
深入探索Java SPI机制-动态扩展的艺术
w风雨无阻w的专栏
05-31 1288
SPI（Service Provider Interface）机制是Java提供的一种服务提供者发现机制。它允许实现者对某个接口提供具体的实现，并在运行时动态地加载和使用这些实现。SPI机制是Java模块化系统的重要组成部分，它使得Java框架可以轻松扩展，同时也支持替换组件。SPI机制为Java应用的模块化和扩展性提供了强大的支持，但随着微服务架构的兴起，传统的SPI机制是否还能满足我们的需求？未来，我们是否需要一种更加灵活、高效的服务发现机制？这些问题，值得我们每一位Java开发者深思。
Dubbo源码分析 ---- 基于SPI的扩展实现机制
guhong5153的专栏
03-11 2615
Dubbo源码分析–基于SPI的可扩展框架 dubbo是阿里巴巴开源出来的一套分布式服务框架，该框架可以比较方便的实现分布式服务的开发，调用等,该框架的教程地址为 http://dubbo.io/Home-zh.htm 代码已经托管到github上。 正好项目里使用了一套网关的框架来做分布式服务开发，该网关的框架是在dubbo的基础上改造而来的，改dubbo默认的基于netty的分布式服务调
扩展点加载机制(ExtensionLoader)
热门推荐
心静欣
04-08 2万+
概述来源： Dubbo的扩展点加载从JDK标准的SPI(Service Provider Interface)扩展点发现机制加强而来。Dubbo改进了JDK标准的SPI的以下问题： + JDK标准的SPI会一次性实例化扩展点所有实现，如果有扩展实现初始化很耗时，但如果没用上也加载，会很浪费资源。 如果扩展点加载失败，连扩展点的名称都拿不到了。比如：JDK标准的ScriptEngine，通过get
聊聊Dubbo - Dubbo可扩展机制实战
weixin_33816611的博客
05-29 383
1. Dubbo的扩展机制 在Dubbo的官网上，Dubbo描述自己是一个高性能的RPC框架。今天我想聊聊Dubbo的另一个很棒的特性, 就是它的可扩展性。 如同罗马不是一天建成的，任何系统都一定是从小系统不断发展成为大系统的，想要从一开始就把系统设计的足够完善是不可能的，相反的，我们应该关注当下的需求，然后再不断地对系统进行迭代。在代码层面，要求我们适...
搞懂dubbo的SPI扩展机制
顺仔的小窝
06-14 522
引言 SPI 全称为 Service Provider Interface，是一种服务发现机制。SPI 的本质是将接口实现类的全限定名配置在文件中，并由服务加载器读取配置文件，加载实现类。这样可以在运行时，动态为接口替换实现类。正因此特性，我们可以很容易的通过 SPI 机制为我们的程序提供拓展功能。 在谈dubbo的SPI扩展机制之前，我们需要先了解下java原生的SPI机制，有助于我们更好的了解dubbo的SPI。 java原生的SPI 先上例子： 定义接口Animal ： public interf
dubbo spi可扩展机制源码解析
12-24
Dubbo SPI（Service Provider Interface）是阿里巴巴开源的Dubbo框架中的一个重要特性，它提供了一种动态发现服务提供者和加载实现类的机制，使得服务消费者无需关心服务提供者的具体实现，增强了系统的可扩展性和...
深度解析Dubbo的可扩展机制SPI源码：从理论到实践，打造高效、稳定的分布式服务框架
01-11
Dubbo的可扩展机制SPI（Service Provider Interface）是其核心特性之一，允许开发者根据需要动态扩展服务。SPI机制使得Dubbo作为一个高度可定制化的RPC框架，可以轻松地添加新的服务协议、序列化方式等组件。下面...
深度解析Dubbo的可扩展机制SPI源码：从理论到实践，打造高效、稳定的分布式服务框架.rar
03-18
在Dubbo中，Service Provider Interface (SPI) 是其核心的可扩展机制，它使得用户可以根据自己的需求自定义实现特定的功能，如协议、序列化、注册中心等。本文将深入探讨Dubbo的SPI源码，从理论到实践，揭示其设计...
Dubbo源码剖析-SPI机制(超详细深度剖析篇)
最新发布
weixin_55721317的博客
09-06 1531
Dubbo源码剖析-SPI篇
Dubbo SPI 之路由器
FireFox1997
07-22 1320
Dubbo 是一个高性能的 Java RPC 框架，由阿里巴巴开源并广泛应用于分布式系统中。在 Dubbo 的架构中，SPI（Service Provider Interface）是一个关键组件，允许在运行时动态加载不同的服务实现。SPI 机制提供了高度的可扩展性和灵活性，使得开发者可以轻松地扩展和定制 Dubbo 的功能。本文将重点探讨 Dubbo SPI 路由器的实现机制，包括其工作原理、使用场景以及如何自定义路由策略。
Dubbo SPI扩展机制
疯一样的女子
07-05 594
引言 SPI 全称为 Service Provider Interface，是一种服务发现机制。SPI 的本质是将接口实现类的全限定名配置在文件中，并由服务加载器读取配置文件，加载实现类。这样可以在运行时，动态为接口替换实现类。正因此特性，我们可以很容易的通过 SPI 机制为我们的程序提供拓展功能。 在谈dubbo的SPI扩展机制之前，我们需要先了解下java原生的SPI机制，有助于我们更好的了解dubbo的SPI。 java原生的SPI 先上例子： 1. 定义接口Animal ： publi
SPI扩展机制
tian830937的专栏
02-23 815
API 中的接口是服务提供者给服务调用者的一个功能列表，而 SPI 中更多强调的是，服务调用者对服务实现的一种约束，服务提供者根据这种约束实现的服务，可以被服务调用者发现。说白了，Java 中的 SPI 实现的就是，你按我的接口规范实现服务，我就能通过某种机制为这个接口寻找到这个服务
java 扩展机制_Java中的SPI扩展机制（有demo）
weixin_31281003的博客
02-13 314
一、什么是SPISPI ，全称为 Service Provider Interface，是一种服务发现机制。它通过在ClassPath路径下的META-INF/services文件夹查找文件，自动加载文件里所定义的类。二、设计的目的肯定是为了扩展性，在不想修改源码的情况下，去替换系统原有的实现，代价最小也最灵活。三、案例demo先看看目录接结构spi-api模块：定义扩展接口spi-client模...
理解 Dubbo SPI 扩展机制
weixin_33904756的博客
05-15 166
为什么80%的码农都做不了架构师？>>> ...
Dubbo：SPI扩展机制
Ramboy's Blogs
11-06 347
SPI 的全名为 Service Provider Interface，在面向对象的设计里面，模块之间推荐基于接口编程，而不是实现类进行硬编码，这样做也是为了模块设计的可插拔原则。为了在模块装配的时候不在程序里指明是哪个实现，就需要一种服务发现的机制，JDK 的 SPI 就是为某个接口寻找服务实现的。
SPI 机制-插件化扩展功能
08-29 425
SPI(Service Provider Interfaces),中文直译服务提供者接口，一种服务发现机制。可能很多人都不太熟悉这个机制，但是平常或多或少都用到了这个机制，比如我们使用 JDBC 连接操作数据库的时候。 SPI 主要适用于功能扩展的场景，如一些框架提供某一部分功能可以由第三方开发人员扩展，满足其自身业务需求。 假设我们在公司内实现了一个统一登陆框架，框架内部仅仅提供用户名...
dubbo源码实践-SPI扩展
Alf的专栏
12-31 1268
想要看Dubbo的源码，SPI机制必须搞明白。dubbo提供通用的处理逻辑，具体的处理细节都是使用SPI机制提供扩展和实现的。比如dubbo的服务发现，通过SPI共有6种实现(file、zookeeper、consul、etcd3、eureka、nacos)。
Dubbo源码解析-Dubbo微内核实现（SPI扩展）
Ricky
08-31 2109
Dubbo SPI扩展实现原理
Dubbo的SPI扩展机制剖析
Java面试辅导-海龟老师
09-04 577
我们都是知道一个合格的开源框架对于扩展的支持都要是相当弹性的，Dubbo 也不例外。Dubbo采用微内核+插件体系，使得设计优雅，扩展性强。Dubbo的扩展机制是基于SPI思想来实现的，但是并没有采用JDK中原生的SPI机制。 1.什么是SPI java spi的具体约定为:当服务的提供者，提供了服务接口的一种实现之后，在jar包的META-INF/services/目录里同时创建一个以服务接...
Java与Dubbo SPI机制的比较及学习代码示例
Dubbo SPI是基于Java SPI机制之上，对它进行了一定的扩展和优化。Dubbo作为一款高性能的Java RPC框架，其内部大量使用了SPI机制来实现服务的扩展。Dubbo SPI的特点包括可插拔式、点对点通信、容错和负载均衡等。 在...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值