dubbo源码学习-核心组件ExtensionLoader

原创不易，转发请表明出处

源码学习版本为 2.6.2-SNAPSHOT，源码注释网址为

ExtensionLoader是dubbo中核心的组件，主要的作用就是

1 根据参数值，自动注入拓展插件

2 包装拓展插件

先上一个源码中使用的例子，在解析dubbo的配置文件时，解析服务有个核心配置类，是ServiceConfig，这个后面会介绍，里面初始化Protocol类的代码如下：

// 获取协议的包装类，默认是 dubbo协议

private static final Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();

Protocol接口定义如下

@SPI("dubbo")

public interface Protocol {

int getDefaultPort();

@Adaptive

Exporter export(Invoker invoker)throws RpcException;

@Adaptive

Invoker refer(Class type, URL url)throws RpcException;

void destroy();

}

之后在下面的 doExportUrlsFor1Protocol()方法是这么用的

Exporter exporter =protocol.export(wrapperInvoker);

这个地方的入参是

调用的其实是protocol 的实现类 RegistryProtocol中的export（final Invoker originInvoker）方法

protocol的实现类有很多，程序怎么知道用哪个实现类呢，这就是ExtensionLoader的强大神奇之处，下面一一道来

万事讲源头，再贴一下刚刚开始举得例子的代码，就是 Protocol初始化的那个地方

private static final Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();

// ExtensionLoader 中的 getExtensionLoader ()方法，已去除校验逻辑，保留核心逻辑

@SuppressWarnings("unchecked")

public static ExtensionLoader getExtensionLoader(Class type) {

// java设计模式，亨元模式，首先从缓存中获取，如果获取不到，初始化并返回

ExtensionLoader loader = (ExtensionLoader)EXTENSION_LOADERS.get(type);

if (loader ==null) {

EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader(type));

loader = (ExtensionLoader)EXTENSION_LOADERS.get(type);

}

return loader;

}

这个地方做的事情就是根据传入接口，初始化ExtensionLoader类，并返回，看来是ExtensionLoader 的 getAdaptiveExtension() 是核心，下面看看核心！

ExtensionLoader 中的getAdaptiveExtension()方法

// 也是保留核心逻辑

instance = createAdaptiveExtension();

return (T) instance;

这个地方就是调用createAdaptiveExtension()方法，创建包装，继续顺藤摸瓜

ExtensionLoader 中的createAdaptiveExtension()方法

return injectExtension((T) getAdaptiveExtensionClass().newInstance());

这个需要分两步去看，首先是 (T) getAdaptiveExtensionClass().newInstance()，其次是 injectExtension(T instance)

首先看 ExtensionLoader 中的getAdaptiveExtensionClass()方法，这个方法是想获取T的字节码class文件，也是用到了亨元模式先从缓存取，如果没有，调用createAdaptiveExtensionClass（）方法创建

private Class createAdaptiveExtensionClass() {

// 动态代理，获取Protocol的包装的代码字符串，具体内容见注1，核心中的核心

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

}

其实 (T) getAdaptiveExtensionClass().newInstance()返回的是动态代理生成的类的实例，动态代理的内容是注1中的内容，动态代理生成的类的核心逻辑就是增强Protocol中的export()方法，根据 Invoker中的url的protocol决定具体的实现类，再去调用具体实现类的export()方法

再看 ExtensionLoader 中的injectExtension(T instance)()方法，保持核心逻辑的源码如下

for (Method method : instance.getClass().getMethods()) {

if (method.getName().startsWith("set")&& method.getParameterTypes().length ==1

&& Modifier.isPublic(method.getModifiers())) {

Class pt = method.getParameterTypes()[0];

try {

String property = method.getName().length() >3 ? method.getName().substring(3, 4).toLowerCase() + method.getName().substring(4) :""; // 获取属性名

Object object =objectFactory.getExtension(pt, property); // 获取属性值

if (object !=null) {

method.invoke(instance, object); // 反射设置属性值

}

}

}

代码主要的逻辑就是从 objectFactory 获取属性值，之后通过反射初始化属性，

在注1中有个方法，也是 ExtensionLoader的核心方法，摘取自注1中的代码如下：

ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.rpc.Protocol.class).getExtension(extName)

ExtensionLoader类中getExtension（String name）方法，保留核心逻辑代码如下：

instance = createExtension(name);

ExtensionLoader类的 createExtension（String name）方法，这其中的核心逻辑是调用 getExtensionClasses（），之后调用

loadExtensionClasses（）方法，之后核心逻辑如下：

loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY);

loadDirectory(extensionClasses, DUBBO_DIRECTORY);

loadDirectory(extensionClasses, SERVICES_DIRECTORY);

会从"META-INF/services/"和"META-INF/dubbo/" 和 "META-INF/dubbo/internal/"路径下，读取配置文件，加载到ExtensionLoader的cachedClasses字段中，

Protocol接口的配置文件名字是com.alibaba.dubbo.rpc.Protocol，这个文件有可能分散在不同模块下，内容如下

filter=com.alibaba.dubbo.rpc.protocol.ProtocolFilterWrapper

listener=com.alibaba.dubbo.rpc.protocol.ProtocolListenerWrapper

mock=com.alibaba.dubbo.rpc.support.MockProtocol

不加载后缀是 Wrapper的

至此，总结如下

ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();其实就是动态代理获取Protocol的代理包装类，类的内容见注1，之后根据代理类的逻辑执行具体逻辑。

注1：根据createAdaptiveExtensionClassCode()方法生成的字符串类型的class文件，核心逻辑是根据传入的泛型T以及其中方法上的@Adaptive注解，创建动态代理，创建的内容如下

package com.alibaba.dubbo.rpc;

import com.alibaba.dubbo.common.extension.ExtensionLoader;

public class Protocol$Adaptive implements com.alibaba.dubbo.rpc.Protocol { // 生成的为 Protocol 的内部类 Adaptive

public void destroy() {

throw new UnsupportedOperationException("method public abstract void com.alibaba.dubbo.rpc.Protocol.destroy() of interface com.alibaba.dubbo.rpc.Protocol is not adaptive method!");

}

public int getDefaultPort() {

throw new UnsupportedOperationException("method public abstract int com.alibaba.dubbo.rpc.Protocol.getDefaultPort() of interface com.alibaba.dubbo.rpc.Protocol is not adaptive method!");

}

// 核心方法

public com.alibaba.dubbo.rpc.Exporter export(com.alibaba.dubbo.rpc.Invoker arg0) throws com.alibaba.dubbo.rpc.RpcException {

if (arg0 == null) throw new IllegalArgumentException("com.alibaba.dubbo.rpc.Invoker argument == null");

if (arg0.getUrl() == null) throw new IllegalArgumentException("com.alibaba.dubbo.rpc.Invoker argument getUrl() == null");com.alibaba.dubbo.common.URL url = arg0.getUrl();

String extName = ( url.getProtocol() == null ? "dubbo" : url.getProtocol() ); //获取当前协议

if(extName == null) throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.rpc.Protocol) name from url(" + url.toString() + ") use keys([protocol])");

com.alibaba.dubbo.rpc.Protocol extension = (com.alibaba.dubbo.rpc.Protocol)ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.rpc.Protocol.class).getExtension(extName); // 根据当前协议名获取实际的实现类

return extension.export(arg0);

}

// 下面是引用远程服务的方法

public com.alibaba.dubbo.rpc.Invoker refer(java.lang.Class arg0, com.alibaba.dubbo.common.URL arg1) throws com.alibaba.dubbo.rpc.RpcException {

if (arg1 == null) throw new IllegalArgumentException("url == null");

com.alibaba.dubbo.common.URL url = arg1;

String extName = ( url.getProtocol() == null ? "dubbo" : url.getProtocol() );

if(extName == null) throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.rpc.Protocol) name from url(" + url.toString() + ") use keys([protocol])");

com.alibaba.dubbo.rpc.Protocol extension = (com.alibaba.dubbo.rpc.Protocol)ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.rpc.Protocol.class).getExtension(extName);

return extension.refer(arg0, arg1);

}

}