Dubbo SPI源码解析

已于 2022-04-06 17:32:08 修改
阅读量620 收藏
点赞数
分类专栏： alibaba中间件 文章标签： spring cloud
于 2022-04-06 16:37:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shihengli2010/article/details/123991267
版权

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

一、Dubbo SPI实现原理

####TODO

二、Dubbo SPI demo

1.代码如下（示例）

依赖版本：
|springboot |2.1.11.RELEASE |
|spring-cloud-dependencies|Greenwich.SR2|
| spring-cloud-alibaba-dependencies | 2.2.2.RELEASE |

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-dubbo</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
    </dependencies>

-- 定义接口
package com.iflytek.spi;
@SPI
public interface Driver {
    String connect();
}
-- 定义实现
public class MysqlDriver implements Driver{
    @Override
    public String connect() {
        return "连接mysql数据库";
    }
}

-- 配置文件 resource/META-INF/dubbo目录下新建com.iflytek.spi.Driver 
mysqlDriver=com.iflytek.spi.MysqlDriver

-- 测试
@Test
public void testSpi(){
    ExtensionLoader<Driver> extensionLoader = ExtensionLoader.getExtensionLoader(Driver.class);
    Driver driver = extensionLoader.getExtension("mysqlDriver");
    System.out.println(driver.connect());
}

三、Dubbo SPI实现原理

  • getExtensionLoader() : 加载当前接口的子类并且实例化一个ExtensionLoader对象
  • getExtension(String name) : 主要用于获取名称为name的对应的子类的对象

1. getExtensionLoader

public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
        if (type == null)
            throw new IllegalArgumentException("Extension type == null");
        //type非接口类型    
        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
        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 static <T> boolean withExtensionAnnotation(Class<T> type) {
        return type.isAnnotationPresent(SPI.class);
    }

2. getExtension

 /**
     * Find the extension with the given name. If the specified name is not found, then {@link IllegalStateException}
     * will be thrown.
     */
    @SuppressWarnings("unchecked")
    public T getExtension(String name) {
        if (name == null || name.length() == 0)
            throw new IllegalArgumentException("Extension name == null");
        if ("true".equals(name)) {
            return getDefaultExtension();
        }
        // 查看当前是否已经缓存有保存目标对象的实例的Holder对象，缓存了则直接返回，
        // 没缓存则创建一个并缓存起来
        Holder<Object> holder = cachedInstances.get(name);
        if (holder == null) {
            cachedInstances.putIfAbsent(name, new Holder<Object>());
            holder = cachedInstances.get(name);
        }
        Object instance = holder.get();
        if (instance == null) {
            synchronized (holder) {
                instance = holder.get();
                if (instance == null) {
                	//为目标对象创建一个实例
                    instance = createExtension(name);
                    holder.set(instance);
                }
            }
        }
        return (T) instance;
    }

public T getDefaultExtension() {
        getExtensionClasses();
        if (null == cachedDefaultName || cachedDefaultName.length() == 0
                || "true".equals(cachedDefaultName)) {
            return null;
        }
        return getExtension(cachedDefaultName);
    }

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) {
                //创建此 Class 对象所表示的类的一个新实例，并保存到EXTENSION_INSTANCES缓存中
                EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance());
                instance = (T) EXTENSION_INSTANCES.get(clazz);
            }
            injectExtension(instance);
            //通过装饰器来增强扩展类的功能
            Set<Class<?>> wrapperClasses = cachedWrapperClasses;
            //遍历，对instance 进行多次injectExtension
            if (wrapperClasses != null && !wrapperClasses.isEmpty()) {
                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 + ")  could not be instantiated: " + t.getMessage(), t);
        }
    }

3. getExtensionClasses()

//返回对应配置文件中的key和value对应的instance
    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;
    }

// synchronized in getExtensionClasses
    // 加载定义文件，并且将定义的类按照功能缓存在不同的属性中，即：
    // a. 目标class类型缓存在cachedClasses；
    // b. wrapper的class类型缓存在cachedWrapperClasses；
    // c. Adaptive类型缓存在cachedAdaptiveClass；
    private Map<String, Class<?>> loadExtensionClasses() {
        //根据type获取@SPI注解的Value值，并保存到cachedDefaultName中
        final SPI defaultAnnotation = type.getAnnotation(SPI.class);
        if (defaultAnnotation != null) {
            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];
            }
        }

        Map<String, Class<?>> extensionClasses = new HashMap<String, Class<?>>();
        loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY);//META-INF/dubbo/internal/
        loadDirectory(extensionClasses, DUBBO_DIRECTORY);	//META-INF/dubbo/
        loadDirectory(extensionClasses, SERVICES_DIRECTORY);//META-INF/services/
        return extensionClasses;
    }
    
private void loadDirectory(Map<String, Class<?>> extensionClasses, String dir) {
        String fileName = dir + type.getName();
        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 when load extension class(interface: " +
                    type + ", description file: " + fileName + ").", t);
        }
    }

4. loadResource()

private void loadResource(Map<String, Class<?>> extensionClasses, ClassLoader classLoader, java.net.URL resourceURL) {
        try {
            //按行读取文件，split获取key和value
            BufferedReader reader = new BufferedReader(new InputStreamReader(resourceURL.openStream(), "utf-8"));
            try {
                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);
                        }
                    }
                }
            } finally {
                reader.close();
            }
        } catch (Throwable t) {
            logger.error("Exception when load extension class(interface: " +
                    type + ", class file: " + resourceURL + ") in " + resourceURL, t);
        }
    }

5. loadClass()

	// a. 目标class类型缓存在cachedClasses；
    // b. wrapper的class类型缓存在cachedWrapperClasses；
    // c. Adaptive类型缓存在cachedAdaptiveClass；
private void loadClass(Map<String, Class<?>> extensionClasses, java.net.URL resourceURL, Class<?> clazz, String name) throws NoSuchMethodException {
        //isAssignableFrom方法，这个方法是用来判断两个类的之间的关联关系，也可以说是一个类是否可以被强制转换为另外一个实例对象.
        // 通俗说 clazz是否是type的实现类
        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.");
        }
        // 如果子类上标注有@Adaptive注解，说明其是一个装饰类，则将其缓存在cachedAdaptiveClass中，
        // 需要注意的是，一个接口只能为其定义一个装饰类
        if (clazz.isAnnotationPresent(Adaptive.class)) {
            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)) {
            Set<Class<?>> wrappers = cachedWrapperClasses;
            if (wrappers == null) {
                cachedWrapperClasses = new ConcurrentHashSet<Class<?>>();
                wrappers = cachedWrapperClasses;
            }
            wrappers.add(clazz);
        } else {
            // 空构造函数。进入else逻辑的代码表明为实现类
            clazz.getConstructor();
            if (name == null || name.length() == 0) {
                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 (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());
                    }
                }
            }
        }
    }

// 判断子类是否是一个wrapper类，判断方式就是检查其是否有只含一个目标接口类型参数的构造函数
// 有则说明其是一个AOP的wrapper类
private boolean isWrapperClass(Class<?> clazz) {
    try {
        clazz.getConstructor(type);
        return true;
    } catch (NoSuchMethodException e) {
        return false;
    }
}

5. createAdaptiveExtension

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

    private Class<?> getAdaptiveExtensionClass() {
        //通过getExtensionClasses()方法加载当前传入类型的所有扩展点，并缓存。其中@Adaptive类型会缓存到cachedAdaptiveClass中
        getExtensionClasses();
        if (cachedAdaptiveClass != null) {
            return cachedAdaptiveClass;
        }
        //如果缓存为空，则创建并缓存到cachedAdaptiveClass
        return cachedAdaptiveClass = createAdaptiveExtensionClass();
    }

    //涉及到动态字节码的生成和加载
    private Class<?> createAdaptiveExtensionClass() {
        //返回一个动态拼接的类
        String code = createAdaptiveExtensionClassCode();
        ClassLoader classLoader = findClassLoader();
        //通过Compiler进行动态编译
        com.alibaba.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
        return compiler.compile(code, classLoader);
    }


/**
     * 返回一个动态拼接的类
     * @return
     */
    private String createAdaptiveExtensionClassCode() {
        StringBuilder codeBuilder = new StringBuilder();
        Method[] methods = type.getMethods();
        boolean hasAdaptiveAnnotation = false;
        for (Method m : methods) {
            if (m.isAnnotationPresent(Adaptive.class)) {
                hasAdaptiveAnnotation = true;
                break;
            }
        }
        // no need to generate adaptive class since there's no adaptive method found.
        if (!hasAdaptiveAnnotation)
            throw new IllegalStateException("No adaptive method on extension " + type.getName() + ", refuse to create the adaptive class!");

        codeBuilder.append("package ").append(type.getPackage().getName()).append(";");
        codeBuilder.append("\nimport ").append(ExtensionLoader.class.getName()).append(";");
        codeBuilder.append("\npublic class ").append(type.getSimpleName()).append("$Adaptive").append(" implements ").append(type.getCanonicalName()).append(" {");

        for (Method method : methods) {
            Class<?> rt = method.getReturnType();
            Class<?>[] pts = method.getParameterTypes();
            Class<?>[] ets = method.getExceptionTypes();

            Adaptive adaptiveAnnotation = method.getAnnotation(Adaptive.class);
            StringBuilder code = new StringBuilder(512);
            //method如果未标注@Adaptive，则抛出异常
            if (adaptiveAnnotation == null) {
                code.append("throw new UnsupportedOperationException(\"method ")
                        .append(method.toString()).append(" of interface ")
                        .append(type.getName()).append(" is not adaptive method!\");");
            } else {
                int urlTypeIndex = -1; // urlTypeIndex记录url类型的参数index
                for (int i = 0; i < pts.length; ++i) {
                    if (pts[i].equals(URL.class)) {
                        urlTypeIndex = i;
                        break;
                    }
                }
                // found parameter in URL type
                if (urlTypeIndex != -1) {
                    // Null Point check
                    String s = String.format("\nif (arg%d == null) throw new IllegalArgumentException(\"url == null\");",
                            urlTypeIndex);
                    code.append(s);

                    s = String.format("\n%s url = arg%d;", URL.class.getName(), urlTypeIndex);
                    code.append(s);
                }
                // did not find parameter in URL type
                else {
                    String attribMethod = null;

                    //Java中的标签只适合与嵌套循环中使用。break+标签 直接把内外层循环一起停掉了。而如果我们单独使用break的话就起不了这种效果，那样只是跳出内层循环。
                    // find URL getter method
                    LBL_PTS:
                    for (int i = 0; i < pts.length; ++i) {
                        Method[] ms = pts[i].getMethods();
                        for (Method m : ms) {
                            String name = m.getName();
                            if ((name.startsWith("get") || name.length() > 3)
                                    && Modifier.isPublic(m.getModifiers())
                                    && !Modifier.isStatic(m.getModifiers())
                                    && m.getParameterTypes().length == 0
                                    && m.getReturnType() == URL.class) {
                                urlTypeIndex = i;
                                attribMethod = name;
                                break LBL_PTS;
                            }
                        }
                    }
                    .......

6. injectExtension

 /**
     * 创建了instance后，给instance的属性（获取所有的set方法，赋值）赋值.
     * 1. 遍历该instance的所有方法，找到以set开头的方法，准备进行注入。
     * 2. 调用objectFactory.getExtension()方式获取要注入的实例。
     * 3. 调用method.invoke进行注入。
     */
    private T injectExtension(T instance) {
        try {
            if (objectFactory != null) {
                //遍历所有set方法
                for (Method method : instance.getClass().getMethods()) {
                    if (method.getName().startsWith("set")
                            && method.getParameterTypes().length == 1
                            && Modifier.isPublic(method.getModifiers())) {
                        /**
                         * Check {@link DisableInject} to see if we need auto injection for this property
                         */
                        if (method.getAnnotation(DisableInject.class) != null) {
                            continue;
                        }
                        //获取set方法，并获取set方法参数
                        Class<?> pt = method.getParameterTypes()[0];
                        try {
                            //获取set方法的属性名称: setProtocol --> protocol
                            String property = method.getName().length() > 3 ? method.getName().substring(3, 4).toLowerCase() + method.getName().substring(4) : "";
                            //根据class和name，使用自适应扩展点加载并且通过set方法进行赋值
                            Object object = objectFactory.getExtension(pt, property); //从objectFactory获取要注入的扩展点
                            if (object != null) {
                                //注入到具体的类中
                                method.invoke(instance, object);
                            }
                        } catch (Exception e) {
                            logger.error("fail to inject via method " + method.getName()
                                    + " of interface " + type.getName() + ": " + e.getMessage(), e);
                        }
                    }
                }
            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
        return instance;
    }












---



# 总结
shihengli2010
关注
专栏目录
Dubbo SPI 源码解析
牙刷冰冰的博客
04-25 301
Dubbo SPI 基于Java的SPI机制，Dubbo在其思想的基础上自己实现了一套SPI机制，弥补了Java SPI的缺点，并进行了相应的扩展。 1. Dubbo SPI 改进了 Java SPI 的以下问题： Java SPI是一次性加载、实例化所有的扩展点实现，不支持根据key值去加载、实例化指定的扩展点实现。 Java SPI不支持IOC、AOP，Dubbo SPI则通过自动包装、自动装配等特性实现了IOC、AOP。 ServerLoader在加载类的过程中如果出现异常无法加载没有相关的异常
Dubbo SPI源码分析
Charge8的博客
07-10 312
Dubbo SPI源码分析
dubbo SPI源码详解
qq_36706941的博客
02-08 254
1 jdk spi spi全名Service Provider Interface，是一种服务发现机制，即为接口寻找服务实现的机制。 jdk spi 约定提供方只需制定接口规范，提供给外部实现，通过读取jar包META-INF/services/目录以接口名命令的文件来加载该接口的实现，文件里就是该接口的具体实现。 下面是一个简单的例子: 提供一个接口JdkSpiService public interface JdkSpiService { public void hello(); } 提供
Dubbo源码(1)-SPI机制源码解析
BoringError的博客
05-03 581
文章目录一、什么是SPI二、基本使用2.1、核心注解和URL类2.2、单元测试三、SPI机制源码解析3.1、ExtensionLoader3.1.1、属性3.1.2、拓展类资源加载1）getExtensionClasses2）loadExtensionClasses3）loadFile3.1.3、获取指定Extension2）createExtension3）injectExtension3.1....
从Java SPI机制实现到Dubbo SPI扩展
java界的小学生
01-20 2199
SPI扩展 SPI 全称为 Service Provider Interface，是一种服务发现机制。SPI 的本质是将接口实现类的全限定名配置在文件中，并由服务加载器读取配置文件，加载实现类。这样可以在运行时，动态为接口替换实现类。正因此特性，我们可以很容易的通过 SPI 机制为我们的程序提供拓展功能。SPI 机制在第三方框架中也有所应用，比如 Dubbo 就是通过 SPI 机制加载所有的组件。...
dubbo spi可扩展机制源码解析
12-24
下面我们将深入剖析Dubbo SPI的源码，了解其实现原理。 首先，我们要理解SPI的核心概念：接口、实现类和服务发现。在Java世界中，SPI允许开发者定义一个接口，然后提供多个实现该接口的类，系统在运行时会自动发现...
dubbo源码解析
03-14
本文对dubbo源码进行了深入的解析，涵盖了dubbo的架构、核心机制分析、扩展点加载流程、代理机制、远程调用流程、集群和容错处理、监控机制等多个方面。通过阅读和理解这些内容，可以更好地掌握dubbo的内部工作机制...
dubbo源码解析2
05-14
### Dubbo源码解析2 #### 一、源码阅读路径 在开始深入解析Dubbo源码之前，首先需要明确的是，Dubbo虽然代码量不算庞大，但是它涉及的技术领域非常广泛，对于初学者来说，可能需要具备一定的前置知识才能更好地...
一 、dubbo 源码分析之 dubbo spi
qq_27061805的博客
01-11 246
dubbo spi JDK SPI spi全称英文是service provider Interface，翻译成中文也就是服务提供接口，在jdk 1.6开始,就已经提供了SPI.它的使用比较简单。即在项目的类路径下提供一个META/services/xx文件，配置一个文件，文件名为接口的全路径的名称，内容为具体的实现类全路径名。jdk将会使用ServiceLoader.load（）方法去解析和加载接口和其中的实现类,按需执行不同的方法。 缺点： 1.无法按需加载。虽然 ServiceLoader 做了延迟载
dubbo源码分析2 之 内核SPI实现
carl.zhao的专栏
09-09 2490
在之前的文章中我们分析了Java 中的SPI – Java 规范 SPI，其实它为了实现在模块装配的时候能不在程序里动态指明，这就需要一种服务发现机制。Java SPI就是提供这样的一个机制：为某个接口寻找服务实现的机制。有点类似IOC的思想，就是将装配的控制权移到程序之外，在模块化设计中这个机制尤其重要。
dubbo源码解析（一） dubbo spi实现
chaoyuehu的博客
03-09 1734
一、jdk spi实现 SPI的全名为Service Provider Interface。我们系统里抽象的各个模块，往往有很多不同的实现方案，比如日志模块的方案，xml解析模块、jdbc模块的方案等。面向的对象的设计里，我们一般推荐模块之间基于接口编程，模块之间不对实现类进行硬编码。一旦代码里涉及具体的实现类，就违反了可拔插的原则，如果需要替换一种实现，就需要修改代码。为了实现在...
Dubbo中的SPI机制源码解析
思考的力量
06-14 260
Dubbo中的SPI机制源码解析SPI机制简介自适应拓展机制介绍扩展点源码阅读1.获取扩展的方法 SPI机制简介 SPI 全称为 Service Provider Interface，是一种服务发现机制。SPI 的本质是将接口实现类的全限定名配置在文件中，并由服务加载器读取配置文件，加载实现类。Dubbo 并未使用 Java 原生的 SPI 机制，而是对其进行了增强，使其能够更好的满足需求。 在源码阅读之前必须要理解的SPI机制中的注解。 @SPI 这个注解标识这是spi的一个扩展点，实现这个接口可以增加一
【Dubbo源码】SPI机制源码解析
石臻臻的杂货铺(szzdzhp001)
12-01 4469
文章目录一、什么是SPI机制二、SPI机制源码分析ExtensionLoader静态类和静态方法new ExtensionLoader(type) 实例化扩展加载器如何创建自适应扩展实例如何获取自适应扩展的`Class`？如何自动创建`自适应扩展类`实例化之后,如何依赖注入？依赖注入的属性从哪里来加载当前`Type`中所有的扩展类加载文件中的具体实现类@Activate 注解的作用总结 先去看Du...
二、dubbo spi 源码分析
qq_27061805的博客
01-14 269
二、dubbo spi 源码分析 1、ExtensionLoader ExtensionLoader 是dubbo spi 主要实现类，从字面意思可以看出是扩展加载器，是将配置文件与java的对应关系进行组装处理，从而得到我们需要的实际扩展处理类 ExtensionLoader 类中有两个静态属性 EXTENSION_LOADERS （缓存所有的ExtensionLoader） 和 EXTENSION_INSTANCES （缓存扩展实现） private static final Concurren
【dubbo系列】SPI机制源码解析
叁滴水 的博客
05-28 1635
​ SPI 全称为 Service Provider Interface，是一种服务发现机制。此机制在dubbo中大量使用。以至于dubbo框架的及其灵活。 ​ dubbo SPI 源码地址：http://dubbo.apache.org/zh-cn/docs/source_code_guide/dubbo-spi.html 1.java SPI源码解析 1.1 SPI使用场景 ​ dubbo官方中有java SPI的示例，但是初始并不是特别的理解。或者根本不理解这种设计的好处。直到看到mysql驱动包
dubbo源码分析--dubbo spi解析
weixin_30480651的博客
01-08 146
1. 什么叫SPI？ 简单总结就是一种使用类名字符串来动态实例化java类的方式，也就是反射。 2. java SPI与Dubbo SPI有什么区别 (此图来自网上，我没有刻意去截图) 然后在这个文件里面写入实现类 com.blueskykong.javaspi.serializer.KryoSerializer com.blueskykong.javaspi.serializ...
Dubbo 源码分析 – SPI 机制
最新发布
qq_33291299的博客
01-27 278
SpringExtensionFactory 则是到 Spring 的 IOC 容器中获取所需拓展，该类的实现并不复杂，大家自行分析源码，这里就不多说了。以上代码的写法是典型的双重检查锁，前面所分析的 getExtension 方法中有相似的代码。Dubbo 首先会通过反射获取到实例的所有方法，然后再遍历方法列表，检测方法名是否具有 setter 方法特征。除此之外，该方法没有其他什么逻辑了，就不多说了。整个过程没什么特别复杂的地方，大家按部就班的分析就行了，不懂的地方可以调试一下。
Dubbo源码-SPI
hzqf的博客
07-27 289
上一篇我们讲了Dubbo的快速指南,今天就开始我们的源码之旅.这里先给大家介绍一下spi机制. SPI(JDK)   SPI的设计目标: SPI的全名为Service Provider Interface.在面想对象的设计里,模块之间是基于接口编程,模块之间不对实现类进行硬编码.一旦代码涉及具体的实现类,那么久违反了可拔插的原则,如果需要替换一种实现类,就需要修改代码. 为了实现在模块装配...
Dubbo SPI源码深度解析：打造高效分布式服务
"深度解析Dubbo的可扩展机制SPI源码：从理论到实践，打造高效、稳定的分布式服务框架" Dubbo的可扩展性是通过其Service Provider Interface (SPI) 实现的，这是一种允许用户自定义扩展点并动态加载的机制。SPI的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值