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

Dubbo扩展点加载机制

article 2025/1/7 2:22:57

        加载机制中已经存在的一些关键注解，如@SPI、©Adaptive> ©Activateo然后介绍整个加载机制中最核心的ExtensionLoader的工作流程及实现原理。最后介绍扩展中使用的类动态编译的实 
现原理。

Java SPI

Java 5 中的服务提供商icon-default.png?t=O83Ahttps://docs.oracle.com/javase/1.5.0/docs/guide/jar/jar.html#Service%20Provider

SPI 插件扩展点使用手册

https://cn.dubbo.apache.org/zh-cn/overview/mannual/java-sdk/reference-manual/spi/

JDK标准的SPI会一次性实例化扩展点所有实现，如果有扩展实现则初始化很耗时，如果没 
用上也加载，则浪费资源。

如果扩展加载失败，则连扩展的名称都蕤取不到了。比如JDK标准的ScriptEngine,通过 
getName ()获取脚本类型的名称，如果RubyScriptEngine因为所依赖的j ruby .jar不存在，导致 
RubyScriptEngine类加载失败，这个失败原因被“吃掉” 了，和Ruby对应不起来，当用户 
执行Ruby脚本时，会报不支持Ruby,而不是真正失败的原因。


增加了对扩展IoC和AOP的支持，一个扩展可以直接setter注入其他扩展。在Java SPI的使 
用示例章节(代码清单4-1 )中已经看到，java.util.ServiceLoader会一次把Printservice 
接口下的所有实现类全部初始化，用户直接调用即可oDubbo SPI只是加载配置文件中的类， 
并分成不同的种类缓存在内存中，而不会立即全部初始化，在性能上有更好的表现。

 ProtocolFilterWrapper 是 Dubbo 框架中的一个核心类，用于在服务提供者和消费者之间添加过滤器链。ProtocolFilterWrapper 通过 @Activate 注解来确定哪些过滤器适用于当前的 URL。以下是 ProtocolFilterWrapper 确定过滤器适用当前 URL 的详细过程：
1. ProtocolFilterWrapper 类
ProtocolFilterWrapper 是一个装饰器模式的实现，它包装了一个 Protocol 实例，并在其上添加了过滤器链。以下是 ProtocolFilterWrapper 的主要逻辑：

import com.alibaba.dubbo.common.Constants;
import com.alibaba.dubbo.common.URL;
import com.alibaba.dubbo.common.extension.ExtensionLoader;
import com.alibaba.dubbo.rpc.Exporter;
import com.alibaba.dubbo.rpc.Invoker;
import com.alibaba.dubbo.rpc.Protocol;

public class ProtocolFilterWrapper implements Protocol {

    private final Protocol protocol;

    public ProtocolFilterWrapper(Protocol protocol) {
        this.protocol = protocol;
    }

    @Override
    public int getDefaultPort() {
        return protocol.getDefaultPort();
    }

    @Override
    public Exporter<T> export(Exporter<T> exporter) {
        return new InvokerDelegator<>(wrapInvoker(exporter.getInvoker()), exporter);
    }

    @Override
    public <T> Invoker<T> refer(Class<T> type, URL url) {
        return wrapInvoker(protocol.refer(type, url));
    }

    private <T> Invoker<T> wrapInvoker(Invoker<T> invoker) {
        URL url = invoker.getUrl();
        // 获取所有激活的过滤器
        List<Filter> filters = ExtensionLoader.getExtensionLoader(Filter.class).getActivateExtension(url, Constants.KEYS, Constants.DEFAULT_KEY);
        if (filters.size() == 0) {
            return invoker;
        }
        return new FilterChainWrapper(invoker, filters);
    }

 SPI 提供商可以调用 ExtensionLoader.getActivateExtension(URL, String, String) 以查找具有给定条件的所有已激活的扩展。而getActivateExtension 会间接调用 com.alibaba.dubbo.common. extension.ExtensionLoader#loadExtensionClasses

其中 Type 是 由 ExtensionLoader.getExtensionLoader(Filter.class)，决定为 Filter.

L565 - 567 就是解析 Filter 的接口上@SPI注解信息.（Filter.class 也可以替换成其他的类性）

com.alibaba.dubbo.common.extension.ExtensionLoader#loadDirectory 会间接调用 com.alibaba.dubbo.common.extension.ExtensionLoader#loadClass

在此方法中会解析注解@Adaptive、@Activate

    /**
     * @param extensionClasses ExtensionLoader#cachedClasses 成员变量
     * @param resourceURL
     * @param clazz ExtensionLoader#loadResource 中 加载 Class.forName(  类全限定名 )
     * @param name  ExtensionLoader#loadResource 中 在配置文件中设置的别名
     *              上两参数请参考 com.alibaba.dubbo.common.extension.SPI
     * @throws NoSuchMethodException
     */
    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 when load extension class(interface: " +
                    type + ", class line: " + clazz.getName() + "), class "
                    + clazz.getName() + "is not subtype of interface.");
        }
        if (clazz.isAnnotationPresent(Adaptive.class)) {
            // 由于调用者 ExtensionLoader.loadResource 循环调用了 loadClass ，如果类上标注了 @Adaptive 注解，则该类为 Adaptive 类，并且只能有一个
            if (cachedAdaptiveClass == null) {
                cachedAdaptiveClass = clazz;
            } else if (!cachedAdaptiveClass.equals(clazz)) {
                throw new IllegalStateException("More than 1 adaptive class found: "
                        + cachedAdaptiveClass.getClass().getName()
                        + ", " + clazz.getClass().getName());
            }
        } else if (isWrapperClass(clazz)) {
            // 判断为 包装类,则维护到 ExtensionLoader.cachedWrapperClasses
            Set<Class<?>> wrappers = cachedWrapperClasses;
            if (wrappers == null) {
                cachedWrapperClasses = new ConcurrentHashSet<Class<?>>();
                wrappers = cachedWrapperClasses;
            }
            wrappers.add(clazz);
        } else {
            clazz.getConstructor();
            if (name == null || name.length() == 0) {
                // 如果没有名字则尝试扫描 @Extension 注解， Extension 注解已经弃用了
                name = findAnnotationName(clazz);
                if (name.length() == 0) {
                    throw new IllegalStateException("No such extension name for the class " + clazz.getName() + " in the config " + resourceURL);
                }
            }
            // 将首个类上@Activate 信息维护到 ExtensionLoader.cachedActivates 中
            // 将 别名 维护到 ExtensionLoader.cachedNames 中
            // 将 别名&类 维护到 ExtensionLoader#cachedClasses 中
            String[] names = NAME_SEPARATOR.split(name);
            if (names != null && names.length > 0) {
                Activate activate = clazz.getAnnotation(Activate.class);
                if (activate != null) {
                    cachedActivates.put(names[0], activate);
                }
                for (String n : names) {
                    if (!cachedNames.containsKey(clazz)) {
                        cachedNames.put(clazz, n);
                    }
                    Class<?> c = extensionClasses.get(n);
                    if (c == null) {
                        extensionClasses.put(n, clazz);
                    } else if (c != clazz) {
                        throw new IllegalStateException("Duplicate extension " + type.getName() + " name " + n + " on " + c.getName() + " and " + clazz.getName());
                    }
                }
            }
        }
    }

工作流程

  1. 框架读取SPI对应路径下的配置文件，并根据配置加载所有扩展类并缓存(不初始化)。
  2. 根据传入的名称初始化对应的扩展类。
  3. 尝试查找符合条件的包装类：包含扩展点的setter方法，
  4. 返回对应的扩展类实例。

        getAdaptiveExtension也相对独立，只有加载配置信息部分与getExtension共用了同一个 
方法。和获取普通扩展类一样，框架会先检查缓存中是否有已经初始化化好的Adaptive实例， 
没有则调用createAdaptiveExtension重新初始化。初始化过程分为4步：
和getExtension 一样先加载配置文件。

  1. 生成自适应类的代码字符串。
  2.  获取类加载器和编译器，并用编译器编译刚才生成的代码字符串。Dubbo 一共有三种 
  3. 类型的编译器实现。
  4. 返回对应的自适应类实例。

getExtension 的实现原理

ExtensionLoader#getExtension 会调用ExtensionLoader#createExtension 方法

    /**
     *  创建扩展实例
     * @param name  别名
     * @return
     */
    private T createExtension(String name) {
        Class<?> clazz = getExtensionClasses().get(name);
        if (clazz == null) {
            throw findException(name);
        }
        try {
            // 先尝试从缓存中获取实例
            T instance = (T) EXTENSION_INSTANCES.get(clazz);
            if (instance == null) {
                // 不存在的话则通过反射创建实例
                EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance());
                instance = (T) EXTENSION_INSTANCES.get(clazz);
            }
            // 反射执行 setter 方法
            injectExtension(instance);
            Set<Class<?>> wrapperClasses = cachedWrapperClasses;
            if (wrapperClasses != null && !wrapperClasses.isEmpty()) {
                // 检查是否有包装类
                for (Class<?> wrapperClass : wrapperClasses) {
                    // 通过反射创建包装类实例,再执行包装实例的 setter 方法, 最后更新包装类实例
                    // 这里我们能看出 包装类需要 实现 接口，并且包装类需要有一个构造函数，构造参数是接口类型
                    instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
                }
            }
            return instance;
        } catch (Throwable t) {
            throw new IllegalStateException("Extension instance(name: " + name + ", class: " +
                    type + ")  could not be instantiated: " + t.getMessage(), t);
        }
    }

getAdaptiveExtension 的实现原理

        在getAdaptiveExtension()方法中，会为扩展点接口自动生成实现类字符串，实现类主要包含以下逻辑：为接口中每个有^Adaptive注解的方法生成默实现(没有注解的方法则生成空实现)，每个默认实现都会从URL中提取Adaptive参数值，并以此为依据动态加载扩展点。然后，框架会使用不同的编译器，把实现类字符串编译为自适应类并返回。

         生成完代码之后就要对代码进行编译，生成一个新的Classo Dubbo中的编译器也是一个自 
适应接口，但@Adaptive注解是加在实现类AdaptiveCompiler上的。这样一来AdaptiveCompiler 
就会作为该自适应类的默认实现，不需要再做代码生成和编译就可以使用了。

    private Class<?> createAdaptiveExtensionClass() {
        String code = createAdaptiveExtensionClassCode();
        ClassLoader classLoader = findClassLoader();
        com.alibaba.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
        return compiler.compile(code, classLoader);
    }

// TODO ：待续


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

相关文章：

  • 麒麟信安云在长沙某银行的应用入选“云建设与应用领航计划（2024）”，打造湖湘金融云化升级优质范本
  • MCGS学习记录
  • uni-app:实现普通选择器，时间选择器，日期选择器，多列选择器
  • Go小技巧易错点100例（二十一）
  • 【LeetCode Hot100 二分查找】搜索插入位置、搜索二维矩阵、搜索旋转排序数组、寻找两个正序数组的中位数
  • 【CSS】 ---- CSS 实现图片背景清除的滑动效果三种方法
  • 庐山派K230学习日记1 从点灯到吃灰
  • mysql error：1071 -Specified key was too long； max key length is 767 bytes
  • 【深度学习】RNN循环神经网络的原理
  • Golang的代码质量分析工具
  • C# 设计模式（结构型模式）：组合模式
  • 基于jQuery的图片浏览插件（1）
  • 探索新一代框架：基于ECS架构的轻量化Web开发
  • C# 设计模式（结构型模式）：桥接模式
  • 2024年大型语言模型（LLMs）的发展回顾
  • DataCap 2024.4.1 版本发布：MongoDB 驱动支持、工作流引擎升级
  • Selenium 浏览器驱动代理 - 无需下载本地浏览器驱动镜像！（Java 版本！）
  • JavaEE 前后端交互与数据库连接练习
  • mybatisPlus拦截sql失败----已解决
  • basic-validation-using-flask-gladiator-module-in-python
  • APM 3.0.2 | 聚合B站、油管和MF的音乐播放器，支持歌词匹配
  • 2025 小模型技术：驱动低代码与物联网融合发展新引擎
  • Markdown段落的空行缩进用法
  • STM32 拓展 RTC（实时时钟）
  • 前端，npm install安装依赖卡在sill idealTree buildDeps（设置淘宝依赖）
  • ElasticSearch11-8.x 新特性