dubbo源码学习(一)之ExtensionLoader

时间 2019-11-08

标签 dubbo 源码学习 extensionloader 栏目 Dubbo 繁體版

原文原文链接

【转载请注明做者和原文连接，欢迎讨论，相互学习。】html

1、前言网络

ExtensionLoader类，主要是根据扩展点名称来对扩展点接口实现进行的一系列操做，若是获取扩展点接口实现实例、适配类实例、更新实现实例等等。app

ExtensionLoader类是dubbo对JDK SPI作了扩展，主要体如今方面：框架

（1）jdk spi仅仅经过接口类名获取全部实现，而ExtensionLoader则经过接口类名和key值获取一个实现；学习

（2）Adaptive实现，就是生成一个代理类，这样就能够根据实际调用时的一些参数动态决定要调用的类了。url

（3）自动包装实现，这种实现的类通常是自动激活的，经常使用于包装类，好比Protocol的两个实现类：ProtocolFilterWrapper、ProtocolListenerWrapper。三、url总线设计 Dubbo为了使得各层解耦，采用了url总线的设计。咱们一般的设计会把层与层之间的交互参数作成Model，这样层与层之间沟通成本比较大，扩展起来也比较麻烦。所以，Dubbo把各层之间的通讯都采用url的形式。好比，注册中心启动时，参数的url为： registry://0.0.0.0:9090?codec=registry&transporter=netty 这就表示当前是注册中心，绑定到全部ip，端口是9090，解析器类型是registry，使用的底层网络通讯框架是netty。spa

2、代码分析设计

这边说明若是获取扩展点接口实现实例步骤流程做为说明重点，其余的相似，套路都差很少。具体流程以下：代理

1.获取ExtensionLoader实例netty

 1     public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
 2         if (type == null)
 3             throw new IllegalArgumentException("Extension type == null");
 4         if(!type.isInterface()) {
 5             throw new IllegalArgumentException("Extension type(" + type + ") is not interface!");
 6         }
 7         if(!withExtensionAnnotation(type)) {
 8             throw new IllegalArgumentException("Extension type(" + type + 
 9                     ") is not extension, because WITHOUT @" + SPI.class.getSimpleName() + " Annotation!");
10         }
11         
12         ExtensionLoader<T> loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
13         if (loader == null) {
14             EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));
15             loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
16         }
17         return loader;
18     }

这个方法有以下几个重点：

1)判断是否为扩展点接口

2)是否带有SPI注解

3)该扩展点若是为null，则新建该扩展实现实例并返回。

2.获取指定扩展点名称对应的实例

 1    /**
 2      * 返回指定名字的扩展。若是指定名字的扩展不存在，则抛异常 {@link IllegalStateException}.
 3      *
 4      * @param name
 5      * @return
 6      */
 7     @SuppressWarnings("unchecked")
 8     public T getExtension(String name) {
 9         if (name == null || name.length() == 0)
10             throw new IllegalArgumentException("Extension name == null");
11         if ("true".equals(name)) {
12             return getDefaultExtension();
13         }
14         Holder<Object> holder = cachedInstances.get(name);
15         if (holder == null) {
16             cachedInstances.putIfAbsent(name, new Holder<Object>());
17             holder = cachedInstances.get(name);
18         }
19         Object instance = holder.get();
20         if (instance == null) {
21             synchronized (holder) {
22                 instance = holder.get();
23                 if (instance == null) {
24                     instance = createExtension(name);
25                     holder.set(instance);
26                 }
27             }
28         }
29         return (T) instance;
30     }

这个步骤稍微复杂，咱们详细分解一下：

1)9～13行，对扩展点名称进行合法性判断，若是是true，返回默认的扩展点接口实现。

2)14～19行，在cachedInstances中put一个存放扩展点接口实现实例的对象。

3)24行是建立扩展点接口实现的关键，方法：createExtension。

 1     private T createExtension(String name) {
 2         Class<?> clazz = getExtensionClasses().get(name);
 3         if (clazz == null) {
 4             throw findException(name);
 5         }
 6         try {
 7             T instance = (T) EXTENSION_INSTANCES.get(clazz);
 8             if (instance == null) {
 9                 EXTENSION_INSTANCES.putIfAbsent(clazz, (T) clazz.newInstance());
10                 instance = (T) EXTENSION_INSTANCES.get(clazz);
11             }
12             injectExtension(instance);
13             Set<Class<?>> wrapperClasses = cachedWrapperClasses;
14             if (wrapperClasses != null && wrapperClasses.size() > 0) {
15                 for (Class<?> wrapperClass : wrapperClasses) {
16                     instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
17                 }
18             }
19             return instance;
20         } catch (Throwable t) {
21             throw new IllegalStateException("Extension instance(name: " + name + ", class: " +
22                     type + ")  could not be instantiated: " + t.getMessage(), t);
23         }
24     }

这个方法的关键在于，也就是咱们须要的实现类了：Class<?> clazz = getExtensionClasses().get(name);

它会从META-INF/services/，META-INF/dubbo/，META-INF/dubbo/internal/这个三个目录下扫描全部的扩展点信息，存放到extensionClasses这个Map<String, Class<?>> 里边，

而后咱们根据扩展点接口名称就能够获取到扩展点接口实现实例了，具体代码以下。

 1     private Map<String, Class<?>> getExtensionClasses() {
 2         Map<String, Class<?>> classes = cachedClasses.get();
 3         if (classes == null) {
 4             synchronized (cachedClasses) {
 5                 classes = cachedClasses.get();
 6                 if (classes == null) {
 7                     classes = loadExtensionClasses();
 8                     cachedClasses.set(classes);
 9                 }
10             }
11         }
12         return classes;
13     }

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