AI 助理
备案控制台
开发者社区 Java技术进阶 文章 正文

Dubbo之SPI实现原理详解

2019-10-14 8460
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 开篇 SPI全称为Service Provider Interface，是一种服务提供机制，比如在现实中我们经常会有这种场景，就是对于一个规范定义方而言（可以理解为一个或多个接口），具体的服务实现方是不可知的（可以理解为对这些接口的实现类），那么在定义这些规范的时候，就需要规范定义方能够通过一定的方式来获取到这些服务提供方具体提供的是哪些服务，而SPI就是进行这种定义的。

开篇

 SPI全称为Service Provider Interface，是一种服务提供机制，比如在现实中我们经常会有这种场景，就是对于一个规范定义方而言（可以理解为一个或多个接口），具体的服务实现方是不可知的（可以理解为对这些接口的实现类），那么在定义这些规范的时候，就需要规范定义方能够通过一定的方式来获取到这些服务提供方具体提供的是哪些服务，而SPI就是进行这种定义的。

JDK SPI例子

说明：

  • 首先规范制定方会定义一个接口org.apache.jdk.spi.example.IHello 。
  • 其次在项目目录下的META-INF/service名称为org.apache.jdk.spi.example.IHello的文件，包含SPI实现接口全路径。
  • 通过ServiceLoader加载访问调用即可。
  • 对于jdk的SPI，其主要存在两个问题，为每个接口提供的服务一般尽量只提供一个，因为jdk的SPI默认会将所有目标文件中定义的所有子类都读取到返回使用；当定义多个子类实现时，无法动态的根据配置来使用不同的配置。
---- 定义接口
package org.apache.jdk.spi.example;

public interface IHello {
    void sayHello();
}

---- 定义实现1
package org.apache.jdk.spi.example;

public class HelloImpl1 implements IHello {
    @Override
    public void sayHello() {
        System.out.println("我是Impl1");
    }
}

---- 定义实现2
package org.apache.jdk.spi.example;

public class HelloImpl2 implements IHello {
    @Override
    public void sayHello() {
        System.out.println("我是Impl2");
    }
}

---- META-INF/services目录文件 org.apache.jdk.spi.example.IHello
org.apache.jdk.spi.example.HelloImpl1
org.apache.jdk.spi.example.HelloImpl2


---- 测试文件内容
package org.apache.jdk.spi.example;

import java.util.Iterator;
import java.util.ServiceLoader;

public class ServiceLoaderDemo {
    public static void main(String[] args){
        ServiceLoader<IHello> s = ServiceLoader.load(IHello.class);
        Iterator<IHello> iHelloIterator = s.iterator();

        while (iHelloIterator.hasNext()) {
            IHello iHello = iHelloIterator.next();
            iHello.sayHello();
        }
    }
}

jdk spi目录结构


Dubbo SPI例子

  • 定义PlantsWater的接口并通过@SPI注解进行注解，注解可选择带默认值。
  • 将watering()方法使用@Adaptive注解进行了标注，表示该方法在自动生成的子类中是需要动态实现的方法。
  • 增加grant()方法是为了表明不带@Adaptive在自动生成的子类方法内部会抛出异常。
  • 为PlantsWater增加两个实现，AppleWater和BananaWater，实际调用通过参数控制。
  • 在META-INF/dubbo下创建一个文件，该文件的名称是目标接口的全限定名，这里是org.apache.dubbo.spi.example.PlantsWater，在该文件中需要指定该接口所有可提供服务的子类。
  • 定义主函数ExtensionLoaderDemo模拟SPI调用的验证。
----定义基础应用类

public interface Fruit {}
public class Apple implements Fruit {}
public class Banana implements Fruit{}



----定义SPI类

@SPI("banana")
public interface PlantsWater {

    Fruit grant();

    @Adaptive
    String watering(URL url);
}


public class AppleWater implements PlantsWater {
    public Fruit grant() {
        return new Apple();
    }

    public String watering(URL url) {
        System.out.println("watering apple");
        return "watering finished";
    }
}


public class BananaWater implements PlantsWater {

    public Fruit grant() {
        return new Banana();
    }

    public String watering(URL url) {
        System.out.println("watering banana");
        return "watering success";
    }
}



----resources文件 org.apache.dubbo.spi.example.PlantsWater

apple=org.apache.dubbo.spi.example.AppleWater
banana=org.apache.dubbo.spi.example.BananaWater


------测试代码内容

public class ExtensionLoaderDemo {

    public static void main(String[] args) {
        // 首先创建一个模拟用的URL对象
        URL url = URL.valueOf("dubbo://192.168.0.101:20880?plants.water=apple");
        // 通过ExtensionLoader获取一个PlantsWater对象,getAdaptiveExtension已经加载了所有SPI类
        PlantsWater plantsWater = ExtensionLoader.getExtensionLoader(PlantsWater.class)
                .getAdaptiveExtension();
        // 使用该PlantsWater调用其"自适应标注的"方法，获取调用结果
        String result = plantsWater.watering(url);
        System.out.println(result);
    }
}


-----实际输出内容

十月 11, 2019 7:48:51 下午 org.apache.dubbo.common.logger.LoggerFactory info
信息: using logger: org.apache.dubbo.common.logger.jcl.JclLoggerAdapter
watering apple
watering finished

Process finished with exit code 0

dubbo spi目录结构


JDK 和 Dubbo SPI简单对比

Dubbo 的扩展点加载是基于JDK 标准的 SPI 扩展点发现机制增强而来的，Dubbo 改进了 JDK 标准的 SPI 的以下问题：

  • JDK 标准的 SPI 会一次性实例化扩展点所有实现，如果有扩展实现初始化很耗时，但如果没用上也加载，会很浪费资源。
  • 如果扩展点加载失败，就失败了，给用户没有任何通知。比如：JDK 标准的ScriptEngine，如果Ruby ScriptEngine 因为所依赖的 jruby.jar 不存在，导致 Ruby ScriptEngine 类加载失败，这个失败原因被吃掉了，当用户执行 ruby 脚本时，会报空指针异常，而不是报Ruby ScriptEngine不存在。
  • 增加了对扩展点 IoC 和 AOP 的支持，一个扩展点可以直接 setter 注入其它扩展点。


Dubbo SPI实现原理

dubbo对于SPI的实现主要是在ExtensionLoader这个类中，这个类主要有三个方法：

  • getExtension()：主要用于获取名称为name的对应的子类的对象，这里如果子类对象如果有AOP相关的配置，这里也会对其进行封装；
  • getAdaptiveExtension()：使用定义的装饰类来封装目标子类，具体使用哪个子类可以在定义的装饰类中通过一定的条件进行配置；
  • getExtensionLoader()：加载当前接口的子类并且实例化一个ExtensionLoader对象。
public T getExtension(String name);
public T getAdaptiveExtension();
public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type);


getExtension()

  • getExtension()方法的主要作用是获取name对应的子类对象返回。
  • 其实现方式是首先读取定义文件中的子类，然后根据不同的子类对象的功能的不同，比如使用@Adaptive修饰的装饰类和用于AOP的Wrapper类，将其封装到不同的缓存中。
  • 最后根据传入的name获取其对应的子类对象，并且使用相应的Wrapper类对其进行封装。

如下是getExtension()方法的源码：

    public T getExtension(String name) {
        if (StringUtils.isEmpty(name)) {
            throw new IllegalArgumentException("Extension name == null");
        }

        // 如果名称为true，则返回默认的子类对象，这里默认的子类对象的name定义在目标接口的@SPI注解中
        if ("true".equals(name)) {
            return getDefaultExtension();
        }

        // 查看当前是否已经缓存有保存目标对象的实例的Holder对象，缓存了则直接返回，
        // 没缓存则创建一个并缓存起来
        final Holder<Object> holder = getOrCreateHolder(name);
        Object instance = holder.get();

        // 如果无法从Holder中获取目标对象的实例，则使用双检查法为目标对象创建一个实例
        if (instance == null) {
            synchronized (holder) {
                instance = holder.get();
                if (instance == null) {
                    // 创建name对应的子类对象的实例
                    instance = createExtension(name);
                    holder.set(instance);
                }
            }
        }
        return (T) instance;
    }



    public T getDefaultExtension() {
        getExtensionClasses();
        if (StringUtils.isBlank(cachedDefaultName) || "true".equals(cachedDefaultName)) {
            return null;
        }
        // 通过cachedDefaultName去获取对应的子类实例
        return getExtension(cachedDefaultName);
    }


    private void cacheDefaultExtensionName() {
        // cachedDefaultName取自SPI的参数当中
        final SPI defaultAnnotation = type.getAnnotation(SPI.class);
        if (defaultAnnotation == null) {
            return;
        }

        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];
            }
        }
    }
  • 关于对于目标对象的获取，首先是从缓存里取，没取到才会进行创建。
  • 这里需要说明的是，如果传入的name为true，那么就会返回默认的子类实例，而默认的子类实例是通过其名称进行映射的，该名称存储在目标接口的@SPI注解中。



createExtension()方法的源码：

    private T createExtension(String name) {
        // 获取当前名称对应的子类类型，如果不存在，则抛出异常
        Class<?> clazz = getExtensionClasses().get(name);
        if (clazz == null) {
            throw findException(name);
        }
        try {
            // 获取当前class对应的实例，如果缓存中不存在，则实例化一个并缓存起来
            T instance = (T) EXTENSION_INSTANCES.get(clazz);
            if (instance == null) {
                EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance());
                instance = (T) EXTENSION_INSTANCES.get(clazz);
            }

            // 为生成的实例通过其set方法注入对应的实例，这里实例的获取方式不仅可以通过SPI的方式
            // 也可以通过Spring的bean工厂获取
            injectExtension(instance);
            Set<Class<?>> wrapperClasses = cachedWrapperClasses;
            if (CollectionUtils.isNotEmpty(wrapperClasses)) {
                for (Class<?> wrapperClass : wrapperClasses) {
                    // 实例化各个wrapper对象，并将目标对象通过wrapper的构造方法传入，
                    // 另外还会通过wrapper对象的set方法对其依赖的属性进行注入
                    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);
        }
    }

在createExtension()方法中，其主要做了三件事：

  • 加载定义文件中的各个子类，然后将目标name对应的子类返回后进行实例化。
  • 通过目标子类的set方法为其注入其所依赖的bean，这里既可以通过SPI，也可以通过Spring的BeanFactory获取所依赖的bean，injectExtension(instance)。
  • 获取定义文件中定义的wrapper对象，然后使用该wrapper对象封装目标对象，并且还会调用其set方法为wrapper对象注入其所依赖的属性。

关于wrapper对象，这里需要说明的是，其主要作用是为目标对象实现AOP。wrapper对象有两个特点：

    1. 与目标对象实现了同一个接口；
    1. 有一个以目标接口为参数类型的构造函数。这也就是上述createExtension()方法最后封装wrapper对象时传入的构造函数实例始终可以为instance实例的原因。



getExtensionClasses()方法的源码

    private Map<String, Class<?>> getExtensionClasses() {
        Map<String, Class<?>> classes = cachedClasses.get();
        if (classes == null) {
            synchronized (cachedClasses) {
                classes = cachedClasses.get();
                if (classes == null) {
                    // 加载定义文件，并且将定义的类按照功能缓存在不同的属性中，即：
                    // a. 目标class类型缓存在cachedClasses；
                    // b. wrapper的class类型缓存在cachedWrapperClasses；
                    // c. 用于装饰的class类型缓存在cachedAdaptiveClass；
                    classes = loadExtensionClasses();
                    cachedClasses.set(classes);
                }
            }
        }
        return classes;
    }



    private Map<String, Class<?>> loadExtensionClasses() {
        // 获取目标接口上通过@SPI注解定义的默认子类对应的名称，并将其缓存在cachedDefaultName中
        cacheDefaultExtensionName();


        // 分别在META-INF/dubbo/internal、META-INF/dubbo、META-INF/services目录下
        // 获取定义文件，并且读取定义文件中的内容，这里主要是通过META-INF/dubbo/internal
        // 获取目标定义文件
        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() {
        // 获取目标接口上通过@SPI注解定义的默认子类对应的名称，并将其缓存在cachedDefaultName中
        final SPI defaultAnnotation = type.getAnnotation(SPI.class);
        if (defaultAnnotation == null) {
            return;
        }

        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];
            }
        }
    }
  • loadExtensionClasses()主要是分别从三个目录中读取定义文件，读取该文件，并且进行缓存。



loadDirectory()方法的源码：

    private void loadDirectory(Map<String, Class<?>> extensionClasses, String dir, String type) {
        String fileName = dir + type;
        try {
            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();
                    loadResource(extensionClasses, classLoader, resourceURL);
                }
            }
        } catch (Throwable t) {
            logger.error("Exception occurred when loading extension class (interface: " +
                    type + ", description file: " + fileName + ").", t);
        }
    }



    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 = line.substring(0, i).trim();
                                line = line.substring(i + 1).trim();
                            }
                            if (line.length() > 0) {
                                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);
        }
    }
  • 这里主要是对每个目录进行加载，然后依次加载定义文件的内容，而对定义文件内容的处理主要是在loadResource()方法中，在对文件中每一行记录进行处理之后，其其最终是调用的loadClass()方法加载目标class的。



loadClass()方法的源码

    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注解，说明其是一个装饰类，则将其缓存在cachedAdaptiveClass中，
        // 需要注意的是，一个接口只能为其定义一个装饰类
        if (clazz.isAnnotationPresent(Adaptive.class)) {
            cacheAdaptiveClass(clazz);

        // 这里判断子类是否是一个wrapper类，判断方式就是检查其是否有只含一个目标接口类型参数的构造函数，
        // 有则说明其是一个AOP的wrapper类
        } else if (isWrapperClass(clazz)) {
            cacheWrapperClass(clazz);
        } else {
            // 走到这里说明当前子类不是一个功能型的类，而是最终实现具体目标的子类
            clazz.getConstructor();
            if (StringUtils.isEmpty(name)) {
                name = findAnnotationName(clazz);
                if (name.length() == 0) {
                    throw new IllegalStateException("No such extension name for the class " + clazz.getName() + " in the config " + resourceURL);
                }
            }

            String[] names = NAME_SEPARATOR.split(name);
            if (ArrayUtils.isNotEmpty(names)) {
                // 缓存ActivateClass类
                cacheActivateClass(clazz, names[0]);

                // 将目标子类缓存到extensionClasses中
                for (String n : names) {
                    cacheName(clazz, n);
                    saveInExtensionClass(extensionClasses, clazz, n);
                }
            }
        }
    }


    private void cacheActivateClass(Class<?> clazz, String name) {
        // 获取子类上的@Activate注解，该注解的主要作用是对子类进行分组的，
        // 对于分组之后的子类，可以通过getActivateExtension()来获取
        Activate activate = clazz.getAnnotation(Activate.class);
        if (activate != null) {
            cachedActivates.put(name, activate);
        } else {
            // 兼容alibaba版本的注解
            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 saveInExtensionClass(Map<String, Class<?>> extensionClasses, Class<?> clazz, String name) {
        // 将目标子类缓存到extensionClasses中
        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);
        }
    }

loadClass()方法主要作用是对子类进行划分，这里主要划分成了三部分：

  • 使用@Adaptive注解标注的装饰类；
  • 包含有目标接口类型参数构造函数的wrapper类
  • 目标处理具体业务的子类。

总结而言，getExtension()方法主要是获取指定名称对应的子类。在获取过程中，首先会从缓存中获取是否已经加载过该子类，如果没加载过则通过定义文件加载，并且使用获取到的wrapper对象封装目标对象返回。


getAdaptiveExtension()

  • ExtensionLoader在加载了定义文件之后会对子类进行一个划分，使用@Adaptive进行标注的子类和使用@Adaptive标注子类方法。
  • 使用@Adaptive进行标注的子类该子类的作用主要是用于对目标类进行装饰的，从而实现一定的目的。
  • 使用@Adaptive进行标注的方法，其使用的方式主要是在目标接口的某个方法上进行标注，这个时候，dubbo就会通过javassist字节码生成工具来动态的生成目标接口的子类对象，该子类会对该接口中标注了@Adaptive注解的方法进行重写，而其余的方法则默认抛出异常，通过这种方式可以达到对特定的方法进行修饰的目的。



getAdaptiveExtension()方法源码

    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;
    }
  • 从缓存中获取目标类的实例，不存在则创建一个该实例。



createAdaptiveExtension()方法源码

    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() {
        // 获取目标extensionClasses，如果无法获取到，则在定义文件中进行加载
        getExtensionClasses();

       // 如果目标类型有使用@Adaptive标注的子类型，则直接使用该子类作为装饰类
        if (cachedAdaptiveClass != null) {
            return cachedAdaptiveClass;
        }

        // 如果目标类型没有使用@Adaptive标注的子类型，则尝试在目标接口中查找是否有使用@Adaptive标注的
        // 方法，如果有，则为该方法动态生成子类装饰代码
        return cachedAdaptiveClass = createAdaptiveExtensionClass();
    }

    private Class<?> createAdaptiveExtensionClass() {
        // 创建子类代码的字符串对象
        String code = new AdaptiveClassCodeGenerator(type, cachedDefaultName).generate();

        // 获取当前dubbo SPI中定义的Compiler接口的子类对象，默认是使用javassist，
        // 然后通过该对象来编译生成的code，从而动态生成一个class对象
        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);
    }
  • createAdaptiveExtension()首先委托给getAdaptiveExtensionClass()方法获取一个装饰类实例，然后通过injectExtension()方法调用该实例的set方法来注入其所依赖的属性值。
  • 对于没有使用@Adaptive标注的子类时，才会使用Javassist来为目标接口生成其子类的装饰方法。
  • 对于使用@Adaptive标注的子类时，直接返回子类。
  • createAdaptiveExtensionClass()动态生成目标接口的子类字符串，然后通过javassit来编译该子类字符串，从而动态生成目标class。


getExtensionLoader()

    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;
    }
  • 对于ExtensionLoader的获取，其实现过程比较简单，主要是从缓存中获取，如果缓存不存在，则实例化一个并且缓存起来。


ExtensionLoader加载流程图

Dubbo SPI

参考

文章标签：
应用服务中间件
Dubbo
缓存
Java
Ruby
关键词：
Dubbo实现原理
Dubbo spi
Dubbo spi实现原理
晴天哥
目录
相关文章
倪虹升
|
6月前
|
存储 负载均衡 Dubbo
深入理解Dubbo-4.Dubbo扩展SPI
深入理解Dubbo-4.Dubbo扩展SPI
倪虹升
102 1
爱敲代码的小黄
|
6月前
|
缓存 Dubbo Java
趁同事上厕所的时间，看完了 Dubbo SPI 的源码，瞬间觉得 JDK SPI 不香了
趁同事上厕所的时间，看完了 Dubbo SPI 的源码，瞬间觉得 JDK SPI 不香了
爱敲代码的小黄
102 1
挠头小佩顿
|
6月前
|
缓存 Dubbo Java
Dubbo 第三节_ Dubbo的可扩展机制SPI源码解析
Dubbo会对DubboProtocol对象进⾏依赖注⼊（也就是⾃动给属性赋值，属性的类型为⼀个接⼝，记为A接⼝），这个时候，对于Dubbo来说它并不知道该给这个属性赋什么值，换句话说，Dubbo并不知道在进⾏依赖注⼊时该找⼀个什么的的扩展点对象给这个属性，这时就会预先赋值⼀个A接⼝的⾃适应扩展点实例，也就是A接⼝的⼀个代理对象。在调⽤getExtension去获取⼀个扩展点实例后，会对实例进⾏缓存，下次再获取同样名字的扩展点实例时就会从缓存中拿了。Protocol是⼀个接。但是，不是只要在⽅法上加了。
挠头小佩顿
93 0
mikechen的互联网架构
|
4天前
|
负载均衡 监控 Dubbo
Dubbo 实现原理详解，一文吃透！
本文深入解析Dubbo的底层实现原理，涵盖远程方法调用、智能容错和负载均衡、服务注册和发现三大核心功能，详解其架构设计和调用流程。关注【mikechen的互联网架构】，10年+BAT架构经验倾囊相授。
mikechen的互联网架构
20 1
Dubbo 实现原理详解，一文吃透！
服务端技术栈
|
3月前
|
负载均衡 Dubbo Java
Dubbo服务Spi机制和原理
该文章主要介绍了Dubbo中的SPI（Service Provider Interface）机制和原理，包括SPI的基本概念、Dubbo中的SPI分类以及SPI机制的实现细节。
服务端技术栈
77 0
Dubbo服务Spi机制和原理
一只牛博
|
6月前
|
XML 缓存 Dubbo
Dubbo的魔法之门：深入解析SPI扩展机制【八】
Dubbo的魔法之门：深入解析SPI扩展机制【八】
一只牛博
82 0
三友的java日记
|
Dubbo Java 应用服务中间件
阿里一面：说一说Java、Spring、Dubbo三者SPI机制的原理和区别
大家好，我是三友~~ 今天来跟大家聊一聊Java、Spring、Dubbo三者SPI机制的原理和区别。 其实我之前写过一篇类似的文章，但是这篇文章主要是剖析dubbo的SPI机制的源码，中间只是简单地介绍了一下Java、Spring的SPI机制，并没有进行深入，所以本篇就来深入聊一聊这三者的原理和区别。
三友的java日记
141 0
朱季谦
|
缓存 Dubbo Java
Dubbo2.7的Dubbo SPI实现原理细节
Dubbo2.7的Dubbo SPI实现原理细节
朱季谦
49 0
征途黯然。
|
Dubbo Java 应用服务中间件
JDK SPI、Spring SPI、Dubbo SPI三种机制的细节与演化
Java SPI（Service Provider Interface）是JDK提供的一种服务发现机制，用于在运行时动态加载和扩展应用程序中的服务提供者。
征途黯然。
405 0
程序员jet_qi
|
存储 Dubbo Java
Dubbo第三讲：Dubbo的可扩展机制SPI源码解析
Dubbo第三讲：Dubbo的可扩展机制SPI源码解析
程序员jet_qi
81 0

Java技术进阶

热门文章

最新文章

  • 1
    SpringBoot开发案例之整合Dubbo提供者(一)
  • 2
    Spring-boot+Dubbo应用启停源码分析
  • 3
    Dubbo的Zookeeper单机配置和Zookeeper集群配置
  • 4
    Dubbo入门
  • 5
    高并发架构系列：如何从0到1设计一个类Dubbo的RPC框架
  • 6
    SpringBoot开发案例之整合Dubbo消费者
  • 7
    Dubbo架构介绍
  • 8
    学习dubbo（四）： 启动时检查
  • 9
    Dubbo之——改造Dubbo，使其能够兼容Spring 4注解配置
  • 10
    Apache Dubbo 被曝出“高危”远程代码执行漏洞
  • 1
    Dubbo背景和简介
    49
  • 2
    理解java的springboot+mybatisplus+dubbo+nacos+kafka这一套技术栈
    88
  • 3
    Spring Boot 调用 Dubbo 接口与编写 Dubbo 接口实战
    625
  • 4
    分布式系统面试全集通第一篇（dubbo+redis+zookeeper----分布式+CAP+BASE+分布式事务+分布式锁）
    105
  • 5
    Dubbo怎么配置监控中心
    80
  • 6
    dubbo-admin安装(分离版本)
    30
  • 7
    DUBBO--基础篇（二）--监控中心
    52
  • 8
    DUBBO--基础篇（一）--简介（示意Demo）
    67
  • 9
    dubbo面试题收集
    56
  • 10
    dubbo面试题库
    44

    • 相关课程

    更多
  • Dubbo + ZooKeeper 的服务发现最佳实践
  • Dubbo 3.0 服务治理最佳实践
  • Dubbo开源、自研、商业化三位一体战略解读
  • 基于Zookeeper、Dubbo构建互联网分布式基础架构
  • Dubbo分布式服务治理实战
  • 微服务框架 Spring Cloud 快速入门

    • 相关电子书

    更多
  • Dubbo开源现状与2.7规划
  • Dubbo分布式服务治理实战
  • 《Dubbo 3.0 前瞻》

    • 相关实验场景

    更多
  • 快速玩转Dubbo生态之一致性事务篇（Seata）
  • 快速玩转Dubbo生态之限流降级篇（Sentinel）
  • 快速上手使用Dubbo进行远程调用
  • Spring-cloud-bus-rocketmq入门与实践
  • Spring-cloud-stream-binder-rocketmq入门与实践
    • 下一篇
    阿里云OSS设置跨域访问