dubbo SPI源码解读： ExtensionLoader 加载过程

最新推荐文章于 2021-11-08 10:48:24 发布
最新推荐文章于 2021-11-08 10:48:24 发布
阅读量253 收藏 1
点赞数
分类专栏： 微服务 文章标签： java dubbo
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhoushimiao1990/article/details/117198724
版权

上一篇博客中我们介绍了dubbo中SPI功能的使用规则，这里我们看一下它的加载过程：

这里它的加载过程就两步：

  1.  获取ExtensionLoader的实例对象 
  2. 通过ExtensionLoader的实例对象获取到我们要的扩展点实例

1、获取ExtensionLoader实例对象

getExtensionLoader 方法做了这么几件事： 

1、 判断class对象是否为空、是否为接口、类上是否有@SPI注解

2、查询缓存获取ExtensionLoader实例， 如果没有则创建一个实例对象，并放入缓存中

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 interface!");
        }
        // 如果没有SPI注解，报错 
        if (!withExtensionAnnotation(type)) {
            throw new IllegalArgumentException("Extension type(" + type +
                    ") is not extension, because WITHOUT @" + SPI.class.getSimpleName() + " Annotation!");
        }
        // 先查询缓存，缓存中没有则创建
        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;
    }

我们可以看一下它的构造方法： 

    private ExtensionLoader(Class<?> type) {
        this.type = type;
        /**
         * type如果是ExtensionFactory类型，那么objectFactory是null,否则是ExtensionFactory类型的适配器类型
         */
        objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
    }

私有构造，说明它无法在外部进行实例化； ExtensionFactory  是通过扩展点类型和名称来获取扩展点的。

@SPI
public interface ExtensionFactory {

    /**
     * Get extension.
     *
     * @param type object type.
     * @param name object name.
     * @return object instance.
     */
    <T> T getExtension(Class<T> type, String name);

}

ExtensionFactory  的扩展点有三个：

2、获取扩展点实例：

getAdaptiveExtension方法获取扩展点实例， 它也是先从缓存中获取扩展点实例，如果没有则创建， 并放入缓存中：createAdaptiveExtension方法

    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;
    }

1、createAdaptiveExtension： 调用getAdaptiveExtensionClass

  1. 获取到适配器类的Class。
  2. 利用反射创建适配器类的实例。
  3. injectExtension是dubbo的DI，依赖注入，如果适配器类有属性的set方法，会自动注入。
   private T createAdaptiveExtension() {
        try {
            return injectExtension((T) getAdaptiveExtensionClass().newInstance());
        } catch (Exception e) {
            throw new IllegalStateException("Can not create adaptive extension " + type + ", cause: " + e.getMessage(), e);
        }
    }

2、getAdaptiveExtensionClass： 

  1.   SPI扫描： 包括@SPI、@Adaptive注解的类和方法、 SPI 配置文件（这一步是SPI的关键）
  2.   如果上一步获取到了cachedAdaptiveClass 则返回
  3.   创建cachedAdaptiveClass 动态代理类
    private Class<?> getAdaptiveExtensionClass() {
        /**
         * 触发SPI流程的扫描
         */
        getExtensionClasses();
        /**
         * 如果通过上面的步骤可以获取到cachedAdaptiveClass直接返回
         */
        if (cachedAdaptiveClass != null) {
            return cachedAdaptiveClass;
        }
        /**
         * 利用动态代理创建一个扩展类
         */
        return cachedAdaptiveClass = createAdaptiveExtensionClass();
    }

2.1、 getExtensionClasses ： 

这里先是查询一次缓存，如果缓存中没有则开始加载扩展点： loadExtensionClasses

    private Map<String, Class<?>> getExtensionClasses() {
        Map<String, Class<?>> classes = cachedClasses.get();
        if (classes == null) {
            synchronized (cachedClasses) {
                classes = cachedClasses.get();
                if (classes == null) {
                    /**
                     * 开始加载
                     */
                    classes = loadExtensionClasses();
                    cachedClasses.set(classes);
                }
            }
        }
        return classes;
    }

2.1.1、 loadExtensionClasses 加载扩展点

它的主要职能有两个： 

  1. 加载当前SPI默认实现
  2. 加载这个类的所有扩展点实现，且按照name和class对象的形式存储
    /**
     * synchronized in getExtensionClasses
     */
    private Map<String, Class<?>> loadExtensionClasses() {
        cacheDefaultExtensionName();

        Map<String, Class<?>> extensionClasses = new HashMap<>();

        for (LoadingStrategy strategy : strategies) {
            loadDirectory(extensionClasses, strategy.directory(), type.getName(), strategy.preferExtensionClassLoader(), strategy.overridden(), strategy.excludedPackages());
            loadDirectory(extensionClasses, strategy.directory(), type.getName().replace("org.apache", "com.alibaba"), strategy.preferExtensionClassLoader(), strategy.overridden(), strategy.excludedPackages());
        }

        return extensionClasses;
    }

2.1.1.1： cacheDefaultExtensionName 加载并缓存当前SPI默认实现

    private void cacheDefaultExtensionName() {
        // 获取当前类是够包含SPI注解， 一般走道这里就是拥有该注解
        final SPI defaultAnnotation = type.getAnnotation(SPI.class);
        if (defaultAnnotation == null) {
            return;
        }
        // 获取SPI注解的value值
        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) {
                cachedDefaultName = names[0];
            }
        }
    }

2.1.1.2：loadDirectory 加载扩展点实现

这里的主要工作是： 

  1. 拼接文件名
  2. 先从缓存中尝试获取需要的扩展点
  3. 如果URL为空，即没有文件或文件中没有任何配置，尝试从其他线程获取扩展点
  4. 如果URL存在，逐个遍历文件资源，并加载资源信息到ExtensionClasses中
    private void loadDirectory(Map<String, Class<?>> extensionClasses, String dir, String type,
                               boolean extensionLoaderClassLoaderFirst, boolean overridden, String... excludedPackages) {
        // 拼接文件名： 路径/包名.接口名
        String fileName = dir + type;
        try {
            // 寻找classloader和url列表
            Enumeration<java.net.URL> urls = null;
            ClassLoader classLoader = findClassLoader();

            // 如果需要，先从当前类的ClassLoader中获取
            if (extensionLoaderClassLoaderFirst) {
                ClassLoader extensionLoaderClassLoader = ExtensionLoader.class.getClassLoader();
                if (ClassLoader.getSystemClassLoader() != extensionLoaderClassLoader) {
                    urls = extensionLoaderClassLoader.getResources(fileName);
                }
            }
            // 如果找不到任何URL列表，继续尝试去其他当前线程的ClassLoader中寻找
            if (urls == null || !urls.hasMoreElements()) {
                if (classLoader != null) {
                    urls = classLoader.getResources(fileName);
                } else {
                    urls = ClassLoader.getSystemResources(fileName);
                }
            }
            // 如果URL列表存在， 逐个遍历资源文件，并加载资源信息到extensionClasses
            if (urls != null) {
                while (urls.hasMoreElements()) {
                    java.net.URL resourceURL = urls.nextElement();
                    loadResource(extensionClasses, classLoader, resourceURL, overridden, excludedPackages);
                }
            }
        } catch (Throwable t) {
            logger.error("Exception occurred when loading extension class (interface: " +
                    type + ", description file: " + fileName + ").", t);
        }
    }

这里需要注意两个方法： loadResource 和 loadClass。

  • loadResource主要用于读取文件操作，并将读取到的信息交给loadClass加载
  • loadClass 用于完成类的映射，执行完该方法后，会对几个字段进行更新
    • cachedAdaptiveClass： 当前Extension类型对应的AdaptiveExtension类型，只有一个
    • cachedWrapperClass： 当前Extension类型对应的所有Wrapper实现类型，无顺序
    • chchedActivated： 当前Extension实现自动激活实现缓存（ map 类型）
    • cachedNames：扩展点实现类对应的名称， 如果配置多个名称则值为第一个

2.2 createAdaptiveExtensionClass 创建扩展点的代理类对象

  1. 实例化一个新的Adaptive代码生成器， 并生成代码
  2. 获取类加载器
  3. 通过扩展点，寻找编译器， 目前有java自带的编译器和javassis编译器
  4. 编译生成class对象
    private Class<?> createAdaptiveExtensionClass() {
        // 实例化一个新的Adaptive代码生成器， 并生成代码
        String code = new AdaptiveClassCodeGenerator(type, cachedDefaultName).generate();
        // 获取类加载器
        ClassLoader classLoader = findClassLoader();
        // 通过扩展点，寻找编译器， 目前有java自带的编译器和javassis编译器
        org.apache.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(org.apache.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
        // 编译生成class
        return compiler.compile(code, classLoader);
    }

2.2.1： 通过 AdaptiveClassCodeGenerator.generate 方法来生成代码

    /**
     * generate and return class code
     */
    public String generate() {
        // 如果没有任何方法有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();
    }

 

三水写代码
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Dubbo——扩展点加载机制
meilong_whpu的专栏
05-15 4606
扩展点加载机制        只有标有@SPI注解的接口类才会查找扩展点的实现，依次从下面这三个路径读取扩展点文件：META-INF/dubbo/internal 、META-INF/dubbo/ 、META-INF/services/，其中dubbo内部实现的各种扩展文件都放在META-INF/dubbo/internal目录下面。 以com.alibaba.dubbo.rpc.ProxyFac...
Dubbo自适应拓展学习笔记
伊甸园
05-29 1352
关于阅读开源代码的一些想法 在编写本文前，其实已经写了一篇关于Dubbo 自适应拓展特性的草稿，但是通篇写下来，所做的也不过是copy-write的过程，这样的文章对于我来说，又有什么意义呢？ 尽管我多次想编写一篇详尽有效的文档，试图如同大神一样去理清Dubbo源码的脉络，但是深入其间才发现力有所不逮。因此便重新把那篇文章给删了，推倒重来，将阅读人群从别人转向自己。 这样一来，就变得清晰简单的许多...
Dubbo SPI源码分析--getExtensionLoader 加载过程
rzpy_qifengxiaoyue的博客
08-14 156
如何进行实例化 ExtensionLoader public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) { // 必须传入类型 if (type == null) { throw new IllegalArgumentException("Extension type == null"); } /.
spi 动态加载、卸载_Dubbo高扩展性的基石 SPI 最核心的类 ExtensionLoader
weixin_39583162的博客
12-02 95
Dubbo SPI:(version:2.6.*)Dubbo 微内核 + 插件 模式，得益于 Dubbo SPI 。其中 ExtentionLoader是 Dubbo SPI 最核心的类，它负责扩展点的加载和生命周期管理。ExtensionLoaderExtensionLoader 类似于 Java SPI 的 ServiceLoader，负责扩展的加载和生命周期维护，它是 Dubbo SPI 最...
Dubbo Adaptive机制详解
weixin_33967071的博客
06-03 2700
2019独角兽企业重金招聘Python工程师标准>>> ...
深度解析Dubbo的可扩展机制SPI源码：从理论到实践，打造高效、稳定的分布式服务框架
最新发布
01-11
下面我们将从理论到实践，详细解析Dubbo SPI的源码及其工作原理。 首先，我们来看一下Dubbo SPI架构图。Dubbo SPI由ExtensionLoader、ExtensionFactory、Adaptive Extension等组件构成。ExtensionLoader是接口的...
dubbo-spiDemo:精神病
05-16
Dubbo SPI（Service Provider Interface）是阿里巴巴开源的Java服务发现框架，它允许开发者在运行时动态地查找和加载服务提供者。SPI机制是基于Java的ServiceLoader类实现的，是Java标准扩展的一种方式，用于解耦...
dubbo2.0源码解读
05-24
《Dubbo 2.0 源码解读》是一份深度剖析Dubbo核心机制和技术细节的资料，旨在帮助开发者深入理解这一著名Java微服务框架的工作原理。以下是对这份资料主要知识点的详细阐述： 1. **源码阅读路径**：源码阅读是提升...
Dubbo源码分析之SPI
01-31
1. **ExtensionLoader**：这是Dubbo SPI的核心类，负责加载服务实现。它会缓存已加载的服务，避免重复加载，并提供获取默认服务、所有服务实例、按条件过滤服务等方法。 2. **AdaptiveExtension**：适应性扩展是...
dubbo spi可扩展机制源码解析
12-24
Dubbo SPI（Service Provider Interface）是阿里巴巴开源的Dubbo框架中的一个重要特性，它提供了一种动态发现服务提供者和加载实现类的机制，使得服务消费者无需关心服务提供者的具体实现，增强了系统的可扩展性和...
dubbo spi 原理解析
qq_20417529的博客
03-09 306
一、spi 使用 创建spi 接口及对应实现 package apache.dubbo.test.spi; import org.apache.dubbo.common.extension.SPI; @SPI public interface SpiInterface { void method(); } public class SpiInterfaceImpl implements SpiInterface { @Override public void method(
Dubbo系列讲解之扩展点实现原理分析【2万字分享】，java技术支持和java开发
m0_63102464的博客
11-08 311
// 异常信息缓存起来，下一次进来时如果发现是创建实例是出现异常，就直接抛出异常。这里的设计应该是当扩展点创建异常时避免多次执行创建流程的优化 createAdaptiveInstanceError = t; throw new IllegalStateException("Failed to create adaptive instance: " + t.toString(), t); } } } } return (T) instance; } 该方法主要做了以下几件事 从缓存cachedAdapt
Dubbo-SPI扩展点加载机制
yangyanping20108的博客
07-28 267
javassist Javassist是一款字节码编辑工具，可以直接编辑和生成Java生成的字节码，以达到对.class文件进行动态修改的效果。熟练使用这套工具，可以让Java编程更接近与动态语言编程。 maven依赖 <dependency> <groupId>org.javassist</groupId> <artifactId>javassist</artifactId&gt
Dubbo源码 SPI实现ExtensionLoader
少爷
03-07 574
Dubbo源码 SPI实现ExtensionLoaderSPI 全称为 (Service Provider Interface) ，JDK也默认提供了SPI的一种实现，不过对比Dubbo的实现，JDK的实现就非常简单。简单说下JDK默认的SPI用法。 1. 定义Service接口 2. 增加Service实现类 3. META-INF/services目录下建立以接口包全名命名的文件，文件中写
2.Dubbo动态扩展
ex-huh001的博客
12-21 2884
我们知道dubbo通过SPI机制实现了灵活的动态扩展，但是这些扩展的优先级怎么样？怎么去判断最后采用的是哪个实现？ 先上结论：@Adaptive注解实现类 >配置名对应的实现（例如:<provider protocol=dubbo ..>）> @Spi注解上的默认值 具体加载和选择执行流程图 图片在线链接：https://www.processon.com/view/link/5fd4ae5c7d9c0806f72ee982 接下来我们从这一行代码分析，Du...
一、ExtensionLoader扩展点加载类解析（dubbo）
juded的博客
01-25 815
扩展点特性参考扩展点加载官方文档。 大白话 问：扩展点加载到底是什么东东？ 首先得说一下dubbo的基本设计原则 1、采用 Microkernel + Plugin 模式，Microkernel 只负责组装 Plugin，Dubbo 自身的功能也是通过扩展点实现的，也就是 Dubbo 的所有功能点都可被用户自定义扩展所替换。 2、采用 URL 作为配置信息的统一格式，所
Dubbo系列-3.扩展核心ExtensionLoader
熊猫猫
07-14 6128
JDK的标准SPI对比dubbo的SPI 源码解析 getAdaptiveExtension getAdaptiveExtensionClass getExtensionClasses loadFile从目录加载扩展实现 createAdaptiveExtensionClass injectExtension getActivateExtension getExtension createExten
dubbo中ExtensionLoader解析
葫芦娃的博客
04-03 789
在上一篇《java中spi机制解读》中指出java的SPI机制存在以下缺点：只能获取配置中所有的接口实现，不能按照需要获取。所以ExtensionLoader加强了java中SPI机制的功能：可以按照名字加载实现类；在加载实现类过程中新增本文以获取Protocol接口实现类为例进行说明： private static final Protocol protocol = ExtensionLoade...
Apache Dubbo3 源码深入解析
04-07
Apache Dubbo 是一款易用、高性能的 WEB 和 RPC 框架，同时为构建企业级微服 务提供服务发现、流量治理、可观测、认证鉴权等能力、工具与最佳实践。 使用 Dubbo 开发的微服务原生具备相互之间的远程地址发现与通信能力，利用 Dubbo 提供的丰富服务治理特性，可以实现诸如服务发现、负载均衡、流量调度等服务治理诉求。Dubbo 被设计为高度可扩展，用户可以方便的实现流量拦截、选址的各种定制逻辑。 在云原生时代，Dubbo相继衍生出了Dubbo3、Proxyless Mesh等架构与解决方案，在易用性、超大规模微服务实践、云原生基础设施适配、安全性等几大方向上进行了全面升级。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值