Dubbo扩展的SPI代码研究

最新推荐文章于 2024-04-23 06:58:01 发布
最新推荐文章于 2024-04-23 06:58:01 发布
阅读量2.3k 收藏
点赞数
分类专栏： 中间件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zcswl7961/article/details/100671917
版权

文章目录

一，简介

dubbo对于java原生的SPI技术的扩展，个人认为是一套极其优秀的SPI扩展技术，完全能够将dubbo中的这个源码抽取出来，作为自己的项目中插件化的底层实现

二，源码

使用dubbo的ExtensionLoader示例

ExtensionLoader<Protocol> loader = ExtensionLoader.getExtensionLoader(Protocol.class);
Protocol dubboProtocol = loader.getExtension("dubbo");

通过ExtensionLoader.getExtensionLoader(Class class）获取扩展接口的加载类
通过getExtension（String key）获取指定扩展接口的扩展实现，
运行上面的两行代码之后，会获取到Protocol扩展接口的DubboProtocol的扩展类（实际上他获取的是Protocol的Wrapper的包装类，包装类（Wrap）的定义是只要类中有含有类型Protocol的构造函数存在，就认为是该扩展接口实现的包装类，而且获取的顺序并不由加载时的顺序一致）

SPI扩展文件
dubbo对应SPI的扩展是通过SPI的描述文件进行扩展，存在于/META-INF/dubbo/internal 目录下，源码中/META-INF/services/和/META-INF/dubbo/也是能够进行扫描出来的
在这里插入图片描述

1，获取指定扩展接口的SPI加载类（ExtensionLoader对象）

/**
 * 传入指定类型T的Class对象，返回指定对应的ExtensionLoader类型，其实就是将类型T的class对象作为构造函数传入ExtensionLoader(Class<T> type)
 * @param type
 * @param <T>
 * @return
 */
@SuppressWarnings("unchecked")
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<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;
}

首先是验证type为对应的接口类型，并且，type存在对应@SPI注解，然后从线程安全的EXTENSION_LOADERS Map集合中查询是否存在对应的type对应的spi加载类，存在直接取出，不存在通过ExtensionLoader(Class<?> type）构造函数创建ExtensionLoader对象，并加入到EXTENSION_LOADERS 集合中返回

private ExtensionLoader(Class<?> type) {
    this.type = type;
    /**
     * 获取对应ExtensionFactory类型的ExtensionLoader
     */
    objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
}

构造函数中会再次获取到ExtensionFactory接口的SPI加载类，同时调用getAdaptiveExtension()方法获取对应的ExtensionFactory实现的扩展类中对应的Adptive的实现类【这个代码后面会看到】），最后，通过getExtensionLoader(Class<?> type)方法，我们能够获取到一个接口的SPI加载类（ExtensionLoader)

2，返回指定名称的扩展

/**
    * 返回指定名字的扩展。如果指定名字的扩展不存在，则抛异常 {@link IllegalStateException}.
    *
    * @param name
    * @return
    */
@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<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;
}

首先，会从extensionloader对象中cachedInstances缓存获取到对应name的扩展实现类，如果没有，通过createExtension(name)获取

@SuppressWarnings("unchecked")
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, (T) clazz.newInstance());
            instance = (T) EXTENSION_INSTANCES.get(clazz);
        }
        //此处将要完成注入工作，这跟Spring的Bean创建的过程类似，要完成一些依赖注入工作,在后面也能看到ExtensionFactory的作用
        injectExtension(instance);
        Set<Class<?>> wrapperClasses = cachedWrapperClasses;
        if (wrapperClasses != null && wrapperClasses.size() > 0) {
            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);
    }
}

首先，是从cachedClasses缓存中查询是否已经加载了对应扩展的实现类，

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

如果不存在，再通过loadExtensionClasses()方法获取该type对应的扩展实现类，

/**
 *  此方法已经getExtensionClasses方法同步过。
  */
private Map<String, Class<?>> loadExtensionClasses() {
    final SPI defaultAnnotation = type.getAnnotation(SPI.class);
    if(defaultAnnotation != null) {
        String value = defaultAnnotation.value();
        if(value != null && (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<?>>();
    loadFile(extensionClasses, DUBBO_INTERNAL_DIRECTORY);
    loadFile(extensionClasses, DUBBO_DIRECTORY);
    loadFile(extensionClasses, SERVICES_DIRECTORY);
    return extensionClasses;
}

重点来了，首先，是获取该extendloader中之前type对应的SPI注解，获取SPI注解中的value值，设为默认的cachedDefaultName（默认获取的扩展名称）然后，下面是精华，调用loadFile方法获取对应的扩展实现类，分别是三个路径/META-INF/dubbo/internal，/META-INF/services，/META-INF/dubbo

/**
 * 根据指定的目录地址，并且根据指定的SPI扩展类的Name信息拼接为完整的目录
 *          META-INF/dubbo/internal/com.alibaba.dubbo.common.extension.ExtensionFactory
 * 通过获取当前类的加载器的ClassLoader，使用getResource()方法获取到当前目录的url信息
 * 读取指定目录文件的信息，将对应的信息封装到extensionClasses的map中
 * key:
 * value:
 * 参考/META-INF/dubbo/internal/com.alibaba.dubbo.common.extension.ExtensionFactory中的内容。根据=进行解析
 * 缓存预处理的结果，
 *      （1）带Adaptive注解的实现类会被缓存在cachedAdaptiveClass上
 *      （2）其他的会被缓存在cachedClasses上
 * @param extensionClasses
 * @param dir
 */
private void loadFile(Map<String, Class<?>> extensionClasses, String dir) {
    /**
     * META-INF/dubbo/internal/com.alibaba.dubbo.common.extension.ExtensionFactory
     *
     *
     */
    String fileName = dir + type.getName();
    try {
        Enumeration<java.net.URL> urls;
        ClassLoader classLoader = findClassLoader();
        if (classLoader != null) {
            /**
             * 根据指定的目录获取对应的url地址，目录映射url
             */
            urls = classLoader.getResources(fileName);
        } else {
            urls = ClassLoader.getSystemResources(fileName);
        }
        if (urls != null) {
            while (urls.hasMoreElements()) {
                java.net.URL url = urls.nextElement();
                try {
                    BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream(), "utf-8"));
                    try {
                        String line = null;
                        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) {
                                        Class<?> clazz = Class.forName(line, true, classLoader);
                                        //缺保每一次读到的类都是SPI接口的实现类
                                        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注解，则将读到的类赋值给ExtensionLoader类的实例属性cachedAdaptiveClass
                                        /**
                                         * AdaptiveExtensionFactory类
                                         */
                                        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 {
                                            try {
                                                /**
                                                 * 如果这个带参的构造函数存在 , 则说明当前的读到的Class是有包装类的
                                                 * 则先将Class的类对象clazz放入ExtensionLoader类的实例属性 cachedWrapperClasses中
                                                 */
                                                clazz.getConstructor(type);
                                                Set<Class<?>> wrappers = cachedWrapperClasses;
                                                if (wrappers == null) {
                                                    cachedWrapperClasses = new ConcurrentHashSet<Class<?>>();
                                                    wrappers = cachedWrapperClasses;
                                                }
                                                wrappers.add(clazz);
                                            } catch (NoSuchMethodException e) {
                                                clazz.getConstructor();
                                                if (name == null || name.length() == 0) { //对应SPI接口的文件的key
                                                    /**
                                                     * 从SPI扩展文件中，如果不存在以key=value形式的配置，name信息获取从对应Class对象中获取注解信息
                                                     * 1，先去判断类是否存在Extension注解信息，如果存在，获取Extension上的信息
                                                     * 2，没有的话，将类名首字母小写，赋值name
                                                     */
                                                    name = findAnnotationName(clazz);
                                                    if (name == null || name.length() == 0) {
                                                        if (clazz.getSimpleName().length() > type.getSimpleName().length()
                                                                && clazz.getSimpleName().endsWith(type.getSimpleName())) {
                                                            name = clazz.getSimpleName().substring(0, clazz.getSimpleName().length() - type.getSimpleName().length()).toLowerCase();
                                                        } else {
                                                            throw new IllegalStateException("No such extension name for the class " + clazz.getName() + " in the config " + url);
                                                        }
                                                    }
                                                }
                                                String[] names = NAME_SEPARATOR.split(name);
                                                if (names != null && names.length > 0) {
                                                    //判断类上是否有Activate注解
                                                    Activate activate = clazz.getAnnotation(Activate.class);
                                                    if (activate != null) {
                                                        //如果Activate注解存在则放入到ExtensionLoader类的实例属性cachedActivates中
                                                        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());
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                } catch (Throwable t) {
                                    IllegalStateException e = new IllegalStateException("Failed to load extension class(interface: " + type + ", class line: " + line + ") in " + url + ", cause: " + t.getMessage(), t);
                                    exceptions.put(line, e);
                                }
                            }
                        } // end of while read lines
                    } finally {
                        reader.close();
                    }
                } catch (Throwable t) {
                    logger.error("Exception when load extension class(interface: " +
                                        type + ", class file: " + url + ") in " + url, t);
                }
            } // end of while urls
        }
    } catch (Throwable t) {
        logger.error("Exception when load extension class(interface: " +
                type + ", description file: " + fileName + ").", t);
    }
}

实际上，就是真正的实际上，DUBBO的SPI的核心也就是通过获取当前运行类的ClassLoader对象，然后再通过getResources（String fileName）获取指定的路径下面的文件，并通过遍历文件内容的方式，通过=的拆分符号
进行拆分获取对应的name（扩展类对应的扩展名称）line(扩展实现类的的全路径)，
如果每一行中不存在key=value的形式，先去判断类是否存在Extension注解信息，如果存在，获取Extension上的信息，没有Extension注解的话，将类名首字母小写，赋值name
最后将对应的name，Class.forName(line) 存入到extensionClasses
最后再根据extensionClasses.get(name)的方式，获取到解析的扩展实现类，完成
这个loadFile方法中，还会针对@Adaptive，@Active注解的SPI进行处理，
如果对应的扩展实现类上存在@Adaptive注解，则认为该class是Adaptive类型的扩展，赋值给cachedAdaptiveClass
如果对应的扩展实现类上存在@Active注解，加入到cachedActivates，

3，getAdaptiveExtension()

/**
 * 动态生成接口的代理类
 * @return
 */
@SuppressWarnings("unchecked")
public T getAdaptiveExtension() {
    Object instance = cachedAdaptiveInstance.get();
    if (instance == null) {
        if(createAdaptiveInstanceError == null) {
            synchronized (cachedAdaptiveInstance) {
                instance = cachedAdaptiveInstance.get();
                if (instance == null) {
                    try {
                        instance = createAdaptiveExtension();
                        cachedAdaptiveInstance.set(instance);
                    } catch (Throwable t) {
                        createAdaptiveInstanceError = t;
                        throw new IllegalStateException("fail to create adaptive instance: " + t.toString(), t);
                    }
                }
            }
        }
        else {
            throw new IllegalStateException("fail to create adaptive instance: " + createAdaptiveInstanceError.toString(), createAdaptiveInstanceError);
        }
    }

    return (T) instance;
}

获取AdaptiveExtension的方法中，首先是判断之前解析的loadFile方法中，是否存在对应的cachedAdaptiveClass，不存在的话，那就再创建

/**
 * (1)只有当相应的SPI接口的所有方法上是否有带Adaptive注解的方法，
 * 如果有就会生成动态类的代码然后进行动态编译（比如使用javassist框架）,如果没有带Adaptive注解的方法 ,
 * 那就说明该SPI接口是没有Adaptive性质的实现类的，就会拋出异常
 * (2)动态类的本质也是在实现相应的SPI接口,它最终也是在调一个现成的SPI实现类来工作，这样就会有这样的疑问，
 * 那为何不直接指定呢，还非得用动态的呢，呵呵，这就是为什么
 * 凡是在方法上出现Adaptive注解的SPI的Adaptive形式都要动态的原因了，
 * 因为dubbo这样一来就可以做到用不同的Adaptive方法，调不同的SPI实现类去处理。
 * @return
 */
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);
}

上面的注解是我看一个哥们讲解加上自己的理解
然后他会进入到这个createAdaptiveExtensionClassCode（）方法，首先是获取type的所有非私有的方法，然后所有的方法都不存在@Adaptive注解，那就没的创建，抛出异常，最后，你会返现，这个代码竟然搞了一堆循环，将创建的对象的类的内容什么一点一点的组装，存入codeBuidler这个StringBuilder中，最后再通过dubbo自己的Compiler编译器，生成了Class 对象（真的牛逼）

4，getActivateExtension(URL url, String[] values, String group)

/**
 * Get activate extensions.
 * 获取指定ExtensionLoader的Activate数据
 * 1. 根据loader.getActivateExtension中的group和搜索到此类型的实例进行比较，如果group能匹配到，就是我们选择的，也就是在此条件下需要激活的
 * 2. @Activate中的value是参数是第二层过滤参数（第一层是通过group）
 * 3. 在group校验通过的前提下，如果URL中的参数（k）与值（v）中的参数名同@Activate中的value值一致或者包含，那么才会被选中 ?
 * 4. @Activate的order参数对于同一个类型的多个扩展来说，order值越小，优先级越高。
 * @see com.alibaba.dubbo.common.extension.Activate
 * @param url url
 * @param values extension point names
 * @param group group
 * @return extension list which are activated
 */
public List<T> getActivateExtension(URL url, String[] values, String group) {。。。。。}

三 总结

ExtensionLoader这个代码写的很不错（牛逼），很适合实际的项目中对于插件类的应用

四 源码路径

路径地址阅读说明
https://github.com/zcswl7961/dubbox/blob/master/dubbo-common/src/main/java/com/alibaba/dubbo/common/extension/ExtensionLoader.javadubbox
zcswl7961
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入剖析 dubbo spi 机制（一）——扩展点加载
cltcl的专栏
04-16 4334
spi机制是什么 Service Provider Interface 机制并不是新鲜的东西，而是 java 的一种服务发现机制。我的理解就是：我定义了一个接口，但是我并不关心实现。自有人按照我的接口去实现内容。当我需要接入别人的实现时，需要一种机制来保证他的内容被正确的加载运行，这就是 spi。 dubbo 的 spi 机制有什么不同 dubbo spi 也具有同样的功能，但是它更加的...
dubbo spi可扩展机制源码解析
12-24
Dubbo SPI（Service Provider Interface）是阿里巴巴开源的Dubbo框架中的一个重要特性，它提供了一种动态发现服务提供者和加载实现类的机制...通过深入研究Dubbo SPI的源码，我们可以更好地理解和利用这一强大的特性。
Linux的SPI应用（四）----访问Nor Flash（MT25QL01GBBB）
CLL的博客
03-14 5366
SPI FLASH的一些主要的命令的时序：读，写，擦除，写使能，读寄存器等。 Flash的特性是，写数据只能将1写为0，0不能写为1。擦除数据是将所有数据都写为1，因此如果想在已经数据的Flash上写入新的数据，则必须先擦除。 以MT25为例来讲解QSPI FLASH的一些主要的命令的时序。这里只讨论Extended SPI，Dual SPI和Qual SPI就不讨论了,这三种模式的差异仅仅体...
【Dubbo】JAVA SPI 及 SPI 在Dubbo框架中的应用
xianqi_h的专栏
06-29 799
Java SPI机制简介（重点阅读）Java的SPI机制Java之SPI机制dubbo之SPI解析 （重点阅读）Dubbo原理解析-Dubbo内核实现之基于SPI思想Dubbo内核实现 （重点阅读）java spi与dubbo spi区别...
JDK的标准SPI对比dubbo的SPI
glowd的专栏
03-05 765
转载 http://blog.csdn.net/xiaoxufox/article/details/75117992#jdk%E7%9A%84%E6%A0%87%E5%87%86spi%E5%AF%B9%E6%AF%94dubbo%E7%9A%84spiJDK的标准SPI对比dubbo的SPI 源码解析 getAdaptiveExtension getAdaptiveExtensionClas
Dubbo：SPI扩展机制
Ramboy's Blogs
11-06 267
SPI 的全名为 Service Provider Interface，在面向对象的设计里面，模块之间推荐基于接口编程，而不是实现类进行硬编码，这样做也是为了模块设计的可插拔原则。为了在模块装配的时候不在程序里指明是哪个实现，就需要一种服务发现的机制，JDK 的 SPI 就是为某个接口寻找服务实现的。
Dubbo-SPI机制
TheOne的博客
10-12 632
SPI的全称是Service Provider Interface，是JDK内置的动态加载实现扩展点的机制，通过SPI可以动态获取接口的实现类，属于一种设计理念。系统设计的各个抽象，往往有很多不同的实现方案，在面向的对象的设计里，一般推荐模块之间基于接口编程，模块之间不对实现类进行硬编码。如果代码中引用了特定的实现类，那么就违反了可插拔的原则。为了进行实现的替换，需要对代码进行修改。需要一种服务发现机制，以实现在模块装配时无需在程序中动态指定。最常见的使用案例有JDBC、Dubbo和Spring。笔者在代码
Dubbo—SPI及自适应扩展原理
最新发布
2401_84048034的博客
04-23 734
看到这么多扩展类（每一个配置文件中都有很多），我们首先应该思考一个问题：Dubbo一启动，就加载所有的扩展类么？作为一个优秀的RPC框架，肯定不会耗时耗力做这样的无用功，所以肯定会通过一种方式拿到指定的扩展才对。我们可以看到大多是以键值对方式（表示为extName-value）配置的扩展，那么不难猜测，这里的extName就是用来实现上面所说的功能的。那到底是不是呢？以上纯属猜测，下面就到源码中去验证。
dubbo源码实践-SPI扩展
Alf的专栏
12-31 1038
想要看Dubbo的源码，SPI机制必须搞明白。dubbo提供通用的处理逻辑，具体的处理细节都是使用SPI机制提供扩展和实现的。比如dubbo的服务发现，通过SPI共有6种实现(file、zookeeper、consul、etcd3、eureka、nacos)。
Dubbo源码分析之SPI
01-31
2. **AdaptiveExtension**：适应性扩展是Dubbo SPI的一大特色，它能根据当前环境动态生成适配的代码，实现服务调用的自动适配。这极大地提高了代码的可维护性和可扩展性。 3. **MetadataReport**：元数据报告接口，...
dubbo-spiDemo:精神病
05-16
通过学习和实践"Dubbo-spiDemo"项目，开发者不仅可以掌握JDK SPI的基本用法，还能深入理解Dubbo框架的扩展机制，这对于开发和维护大型分布式系统是非常有帮助的。此外，了解SPI还可以帮助开发者更好地理解和使用其他...
Dubbo源代码（2.5.4）
10-27
5. **SPI机制**：Dubbo使用了扩展点注入（SPI）机制，使得开发者可以方便地扩展其功能。这部分源码展示了如何通过`META-INF/services`目录下的配置文件来实现服务扩展。 6. **Maven构建**：Dubbo的构建依赖于Maven...
shican-spi:参考 dubbo spi
04-27
SPI（Service Provider Interface）是Java平台提供的一种服务发现机制，全称为Java...通过对`shican-spi-master`源码的学习和研究，我们可以深入了解如何在Java项目中有效利用SPI技术，实现更加灵活和强大的服务扩展。
Dubbo的SPI扩展机制剖析
xiajie的专栏
09-04 505
我们都是知道一个合格的开源框架对于扩展的支持都要是相当弹性的，Dubbo 也不例外。Dubbo采用微内核+插件体系，使得设计优雅，扩展性强。Dubbo的扩展机制是基于SPI思想来实现的，但是并没有采用JDK中原生的SPI机制。 1.什么是SPI java spi的具体约定为:当服务的提供者，提供了服务接口的一种实现之后，在jar包的META-INF/services/目录里同时创建一个以服务接...
zookeeper原理及apache zookeeper源码阅读
zcswl7961的博客
06-03 9586
文章目录一 简介二 zookeeper原理1，zookeeper集群中的各个节点是如何进行信息交换的？2，zookeeper集群中各个节点中的zoo.conf配置3，zookeeper集群节点的个数为什么最好为奇数？4，什么是脑裂现象（其实这个现象在好多的中间件都会存在）5，zookeeper的选主算法三 apache zookeeper源码阅读 一 简介 zookeeper是一个开源的分布式协...
Disruptor原理分析
zcswl7961的博客
09-11 4935
文章目录一 简介二 原理剖析三 代码 一 简介 Disruptor是一个性能极强的异步消息处理框架，可以认为它是线程间通信高效低延时的内存消息组件，它最大的特点是高性能，其LMAX架构可以获得每秒6百万订单，用1微秒的延迟获得吞吐量为100K+。实际上它是拿内存换取处理高性能的低延迟的处理熟速度， （实际上这个框架在log4j，以及activeMQ源码扩展中有使用） 二 原理剖析 并发编程网上有...
常见的Proxy源码分析
zcswl7961的博客
09-10 3497
文章目录一 描述二 源码三 dubbo的Proxy 一 描述 dubbo的源码中，还有两个关于javassist技术和jdk proxy的扩展， javassist：动态编程，通过jdk中的JavaCompiler接口，能够直接对一个已经存在java class文件进行编译，也可以在内存中动态生成java代码，动态编译执行 jdk proxy：jdk动态代理，通过Proxy类动态的根据指定的接口...
Dubbo框架扩展解析与优化
在Dubbo框架中，扩展机制是其核心特性之一，它允许开发者通过Service Provider Interface (SPI)来扩展和定制框架的行为。SPI使得Dubbo能够灵活地插入新的实现，如监控、安全、控制、转换等，从而满足特定的业务需求...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值