Dubbo SPI扩展点加载机制深入分析

Dubbo SPI扩展点加载的功能

Dubbo的扩展点加载机制类似于Java的SPI加载机制，但是Java的SPI加载机制在查找具体某个实现的时候，只能通过遍历进行查找并会实例化所有实现类，因此对于实际不需要加载的扩展实现也会实例化，造成一定的内存浪费。Dubbo SPI加载机制可通过扩展点名称进行查找，避免实例化所有实现；同时，增加了对扩展点IoC和AOP的支持，一个扩展点实现可以注入其他扩展点实现并进行Wrapper包装。

Dubbo IoC简介

Dubbo IoC指当加载一个扩展点时，会自动注入这个扩展点所依赖的其他扩展点。比如下面的例子:

interface A: 
	implementation： A1, A2
interface B
	implementation： B1, B2

假设A接口的实现类A1, A2具有setB()方法，当通过Dubbo SPI加载机制加载A的这些实现的时候，会自动注入B的实现，但是此时注入的不是B1和B2，而是一个B的自适应实现类(如B$Adaptive)，这是动态生成的类，可以根据不同的参数，自动选择B1或B2进行调用。

扩展点自适应(Adaptive)

在Dubbo IoC简介中已经说明，一个扩展点注入的其他扩展点是一个自适应的实现类。这是由动态生成的代码编译而成的类创建的实例，这个实例根据具体的URL等信息进行具体实现的查找、选择，即等到运行时候，才根据自适应实现，来调用真正实现。以下是com.alibaba.dubbo.rpc.Protocol自适应实现类动态生成的源码。

package com.alibaba.dubbo.rpc;

import com.alibaba.dubbo.common.extension.ExtensionLoader;
// 类名 Protocol$Adaptive
public class Protocol$Adaptive implements com.alibaba.dubbo.rpc.Protocol {

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

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

扩展点AOP简介

比如com.alibaba.dubbo.rpc.Protocol接口有一个实现类com.alibaba.dubbo.rpc.protocol.ProtocolListenerWrapper，这个实现类有如下的构造器：

public ProtocolListenerWrapper(Protocol protocol) {
	if (protocol == null) {
		throw new IllegalArgumentException("protocol == null");
	}
	this.protocol = protocol;
}

因此，ProtocolListenerWrapper是Protocol的包装类，具有类似AOP的效果，持有Protocol实例，ProtocolListenerWrapper可以对Protocol增加一些额外的功能。当获取Protocol的扩展点实例的时候，得到的是包装类。

Dubbo SPI机制的一些注解和类

@SPI注解

这个注解标识的接口，是一个扩展点接口。@SPI("dubbo")中dubbo表示缺省的扩展点名。

@Adaptive注解

注解在类上或者是注解在方法上。

注解在类上。Dubbo中有AdaptiveExtensionFactory和AdaptiveCompiler。ExtensionLoader的工作过程需要这两个特殊的类。
注解在接口的方法上，如Protocol。除了以上两个类之外，其余这个注解都注解在接口的方法上。Dubbo SPI机制可以根据接口动态地生成自适应类，并实例化这个类。接口上被@Adaptive注解的方法会生成具体的方法实现，没有此注解的方法会抛出”UnsupportedOperationException(不支持的操作)”的异常。被注解的方法在生成的动态类中，会根据URL里的参数信息，来决定实际调用哪个扩展。如扩展点自适应(Adaptive)小节生成的自适应类Protocol$Adaptive所示。

`ExtensionLoader`

是Dubbo SPI扩展点实现查找的工具类，与Java SPI中的ServiceLoader类似。Dubbo约定扩展点配置文件放在classpath下的/META-INF/dubbo，/META-INF/dubbo/internal，/META-INF/services目录下，配置文件名为接口的全限定名，配置文件内容为配置名=扩展实现类的全限定名。

@Activate注解

注解在扩展点实现类或方法上，并注明被激活的条件(group/value等)，ExtensionLoader可根据具体的条件信息进行扩展点实现的选择(激活)。

Dubbo SPI机制源码分析

下面以Protocol扩展点接口为例，分析ExtensionLoader的源码实现。例子如下:

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

public class ExtensionLoaderTest {
    public static void main(String[] args) {

        ExtensionLoader<Protocol> loader = ExtensionLoader.getExtensionLoader(Protocol.class);
        
        Protocol adaptiveExtension = loader.getAdaptiveExtension();

        Protocol dubboProtocol = loader.getExtension("dubbo");
    }
}

Protocol接口说明

import com.alibaba.dubbo.common.URL;
import com.alibaba.dubbo.common.extension.Adaptive;
import com.alibaba.dubbo.common.extension.SPI;

@SPI("dubbo")  // 默认扩展点name=dubbo
public interface Protocol {

    /**
     * 获取缺省端口，当用户没有配置端口时使用。
     *
     * @return 缺省端口
     */
    int getDefaultPort();

    /**
     * 暴露远程服务：<br>
     * 1. 协议在接收请求时，应记录请求来源方地址信息：RpcContext.getContext().setRemoteAddress();<br>
     * 2. export()必须是幂等的，也就是暴露同一个URL的Invoker两次，和暴露一次没有区别。<br>
     * 3. export()传入的Invoker由框架实现并传入，协议不需要关心。<br>
     *
     * @param <T>     服务接口类
     * @param invoker 服务的执行体
     * @return exporter 暴露服务的引用，用于取消暴露
     * @throws RpcException 当暴露服务出错时抛出，比如端口已占用
     */
    @Adaptive // 自适应类动态生成方法体
    <T> Exporter<T> export(Invoker<T> invoker) throws RpcException;

    /**
     * 引用远程服务：<br>
     * 1. 当用户调用refer()所返回的Invoker对象的invoke()方法时，协议需相应执行同URL远端export()传入的Invoker对象的invoke()方法。<br>
     * 2. refer()返回的Invoker由协议实现，协议通常需要在此Invoker中发送远程请求。<br>
     * 3. 当url中有设置check=false时，连接失败不能抛出异常，并内部自动恢复。<br>
     *
     * @param <T>  服务接口类
     * @param type 服务的类型
     * @param url  远程服务的URL地址
     * @return invoker 服务的本地代理
     * @throws RpcException 当连接服务提供方失败时抛出
     */
    @Adaptive // 自适应类动态生成方法体
    <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException;

    /**
     * 释放协议：<br>
     * 1. 取消该协议所有已经暴露和引用的服务。<br>
     * 2. 释放协议所占用的所有资源，比如连接和端口。<br>
     * 3. 协议在释放后，依然能暴露和引用新的服务。<br>
     */
    void destroy();

}

创建ExtensionLoader

ExtensionLoader<Protocol> loader = ExtensionLoader.getExtensionLoader(Protocol.class);

ExtensionLoader类似于Java中的ServiceLoader，具有如下的静态属性(类属性，所有该类的实例都共享):

// 存放SPI文件的三个目录，"META-INF/services/"这个目录也是Java SPI配置文件存放的目录
private static final String SERVICES_DIRECTORY = "META-INF/services/";
private static final String DUBBO_DIRECTORY = "META-INF/dubbo/";
// jar包中SPI文件最终存放的位置
private static final String DUBBO_INTERNAL_DIRECTORY = DUBBO_DIRECTORY + "internal/";

// 扩展点name匹配、分割模式
private static final Pattern NAME_SEPARATOR = Pattern.compile("\\s*[,]+\\s*");

// <SPI接口Class对象，对应的ExtensionLoader>
private static final ConcurrentMap<Class<?>, ExtensionLoader<?>> EXTENSION_LOADERS = new ConcurrentHashMap<Class<?>, ExtensionLoader<?>>();

// <SPI接口的实现类Class对象, 对应实现类的实例>
private static final ConcurrentMap<Class<?>, Object> EXTENSION_INSTANCES = new ConcurrentHashMap<Class<?>, Object>();

ExtensionLoader的实例属性(ExtensionLoader的每个实例私有的属性):

// 扩展点接口Class对象
private final Class<?> type;

// 扩展点实现实例的创建工厂
private final ExtensionFactory objectFactory;

// <扩展点实现类Class对象，对应的名字name>
private final ConcurrentMap<Class<?>, String> cachedNames = new ConcurrentHashMap<Class<?>, String>();

// Holder的value为Map，<扩展点实现类的name, 对应实现类的Class对象> 存放所有的扩展点实现类
private final Holder<Map<String, Class<?>>> cachedClasses = new Holder<Map<String, Class<?>>>();

// <扩展点实现类的name, 扩展点实现类上标注的@Activate注解对象> 获取激活的扩展点时使用
private final Map<String, Activate> cachedActivates = new ConcurrentHashMap<String, Activate>();

// <扩展点实现类的name, 对应的实例>  缓存已经创建好的扩展点实例
private final ConcurrentMap<String, Holder<Object>> cachedInstances = new ConcurrentHashMap<String, Holder<Object>>();

// 缓存创建好的自适应实现类的实例
private final Holder<Object> cachedAdaptiveInstance = new Holder<Object>();

// 存储自适应实现类的Class对象
private volatile Class<?> cachedAdaptiveClass = null;

// 默认扩展点的名字
private String cachedDefaultName;

// 保存在创建自适应实现类的实例的过程中发生的错误Error
private volatile Throwable createAdaptiveInstanceError;

// 保存包装类Class对象(也是扩展点实现)，具有一个type对应接口类型参数的构造器
private Set<Class<?>> cachedWrapperClasses;

// <扩展点实现类的全限定名, exception>  防止真正的异常被吞掉
private Map<String, IllegalStateException> exceptions = new ConcurrentHashMap<String, IllegalStateException>();

`getExtensionLoader(Class<T> type)`

ExtensionLoader.getExtensionLoader(Class<T> type);的源码实现:

// 获取对应type的ExtensionLoader实例
/**
* 1. type需要非空、接口、带有SPI注解
* 2. 首先从EXTENSION_LOADERS缓存中获取实例，有则返回；无则创建，放入缓存之后返回
*/
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 interface!");
    }
    if (!withExtensionAnnotation(type)) { // 接口带有@SPI注解
        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) { // 不存在，则先创建ExtensionLoader实例，再放入缓存中
        EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));
        loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
    }
    return loader;
}
// 判断Class对象是否具有@SPI注解
private static <T> boolean withExtensionAnnotation(Class<T> type) {
    return type.isAnnotationPresent(SPI.class);
}
// 私有构造器，创建ExtensionLoader实例
private ExtensionLoader(Class<?> type) {
    this.type = type;
    // 扩展点实现类实例的创建工厂的初始化
    objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
}

当前创建的是ExtensionLoader<Protocol>对象，type != ExtensionFactory.class，因此会执行下面的代码，返回objectFactory = AdaptiveExtensionFactory实例。

ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());

接下来先创建ExtensionLoader<ExtensionFactory>实例对象，从ExtensionFactory的源码可以看出，这也是一个SPI接口类，并且无默认的实现，如下所示。

@SPI // 无默认扩展点实现
public interface ExtensionFactory {

    /**
     * Get extension.
     *
     * @param type object type.
     * @param name object name.
     * @return object instance.
     */
    <T> T getExtension(Class<T> type, String name);

}

因此，ExtensionLoader.getExtensionLoader(ExtensionFactory.class)执行之后，会类似的创建一个ExtensionLoader<ExtensionFactory>对象，objectFactory = null，并放入EXTENSION_LOADERS缓存中。

`ExtensionLoader<ExtensionFactory>.getAdaptiveExtension()`

接下来执行ExtensionLoader<ExtensionFactory>.getAdaptiveExtension()方法。

// 先从cachedAdaptiveInstance缓冲中获取自适应实例是否存在，存在直接返回；不存在，则创建自适应实现类实例
// 后放入缓存，再返回
@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;
}

下面是createAdaptiveExtension()创建自适应实现类实例的过程:

// 先获取自适应实现类Class对象，并创建实例，最后完成IOC注入，返回
// 调用栈有两种
/**
createAdaptiveExtension()
	getAdaptiveExtensionClass()
		getExtensionClasses()
			loadExtensionClasses() // 从SPI配置文件中获取扩展点实现和自适应实现(如果有的话)
				loadFile()  
		createAdaptiveExtensionClass() // 不存在自适应扩展点实现类，则动态创建
			createAdaptiveExtensionClassCode() // 创建自适应扩展点实现类的源码
injectExtension()
*/		   		 
@SuppressWarnings("unchecked")
private T createAdaptiveExtension() {
    try {
        return injectExtension((T) getAdaptiveExtensionClass().newInstance());
    } catch (Exception e) {
        throw new IllegalStateException("Can not create adaptive extenstion " + type + ", cause: " + e.getMessage(), e);
    }
}

// 完成IoC注入
// 获取intance Class对象的方法，选出setter方法(public、具有一个参数)，并根据参数类型和参数名获取参数的
// 实例，反射注入
private T injectExtension(T instance) {
    try {
        if (objectFactory != null) {
            for (Method method : instance.getClass().getMethods()) {
                // setter方法、public、具有一个参数
                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); //反射注入
                        }
                    } 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;
}

injectExtension(T)中，因为objectFactory = null(ExtensionLoader<ExtensionFactory>)，所以直接返回了，即createAdaptiveExtension()返回(T) getAdaptiveExtensionClass().newInstance()。

接下来看getAdaptiveExtensionClass()的实现:

// 获取自适应扩展点实现类
private Class<?> getAdaptiveExtensionClass() {
    // 获取所有的扩展点实现类和自适应类。如果自适应类存在，则cachedAdaptiveClass赋值为自适应类的Class
    // 对象
    getExtensionClasses();
    if (cachedAdaptiveClass != null) {
        return cachedAdaptiveClass;
    }
    // 没有，则动态创建一个自适应实现类
    return cachedAdaptiveClass = createAdaptiveExtensionClass();
}

// 获取所有的扩展点实现类和自适应类
// 先从cachedClasses缓存中获取所有的扩展点实现类，如果存在直接返回；不存在，则通过loadExtensionClasses()从配置的SPI文件中读取后，放入缓存中，再返回
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;
}

// 此方法已经在getExtensionClasses方法同步过。
// 1.获取扩展点接口的SPI注解，获取扩展点默认实现name值，并保存到cachedDefaultName。
// 2.从SPI文件中获取扩展点实现类，并保存到extensionClasses中，返回extensionClasses。
private Map<String, Class<?>> loadExtensionClasses() {
    // SPI注解
    final SPI defaultAnnotation = type.getAnnotation(SPI.class);
    if (defaultAnnotation != null) {
        String value = defaultAnnotation.value(); // SPI注解的值
        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));
            }
            // 默认值赋值给cachedDefaultName
            if (names.length == 1) cachedDefaultName = names[0];
        }
    }
	// 从SPI文件获取所有的扩展点实现，放入extensionClasses中
    Map<String, Class<?>> extensionClasses = new HashMap<String, Class<?>>();
    loadFile(extensionClasses, DUBBO_INTERNAL_DIRECTORY);
    loadFile(extensionClasses, DUBBO_DIRECTORY);
    loadFile(extensionClasses, SERVICES_DIRECTORY);
    return extensionClasses;
}

接下里看下loadFile(Map<String, Class<?>> extensionClasses, String dir)的实现:

// 从dir目录获取扩展点实现类到extensionClasses中
// 具体实现逻辑：
/**
1.加载dir目录下的指定type全限定名的文件(例如:META-INF/dubbo/internal/com.alibaba.dubbo.common.extension.ExtensionFactory)
2.遍历该文件中的每一行
	(1)获取实现类key和value, 例如 name=spi, line=com.alibaba.dubbo.common.extension.factory.SpiExtensionFactory
	(2)根据line创建Class对象
	(3)将具有@Adaptive注解的实现类的Class对象放在cachedAdaptiveClass缓存中, 注意该缓存只能存放一个具有@Adaptive注解的实现类的Class对象,如果有两个满足条件,则抛异常
	下面都是对不含@Adaptive注解的实现类的Class对象的处理:
	(4)查看是否具有含有一个type入参的构造器, 如果有（就是wrapper类）, 将当前的Class对象放置到cachedWrapperClasses缓存中
	(5)如果没有含有一个type入参的构造器, 获取无参构造器. 如果Class对象具有@Active注解, 将该对象以<实现类的key(name), Active>存储起来
	(6)最后,将<Class对象, 实现类的key(name)>存入cachedNames缓存,并将这些Class存入extensionClasses中。
*/
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;  // 所有SPI配置文件的URL
        ClassLoader classLoader = findClassLoader(); // 类加载器，获取SPI配置文件的资源
        if (classLoader != null) {
            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('#'); //去除评论 ci: comment index
                            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/key，如spi、spring、dubbo
                                        name = line.substring(0, i).trim(); 
                                        // 扩展点实现类的全限定名
                                        line = line.substring(i + 1).trim(); 
                                    }
                                    if (line.length() > 0) {
                                        // 加载初始化Class
                                        Class<?> clazz = Class.forName(line, true, classLoader);	
                                        // 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.");
                                        }
                                        // clazz带有@Adaptive注解，是个自适应实现
                                        if (clazz.isAnnotationPresent(Adaptive.class)) {
                                            if (cachedAdaptiveClass == null) {
                                                // 缓存自适应实现类的Class到cachedAdaptiveClass
                                                cachedAdaptiveClass = clazz;
                                            } else if (!cachedAdaptiveClass.equals(clazz)) {
                                                // 自适应实现只能有一个
                                                throw new IllegalStateException("More than 1 adaptive class found: " 
                                                                                + cachedAdaptiveClass.getClass().getName()
                                                                                + ", " + clazz.getClass().getName());
                                            }
                                        } else {
                                            try {
                                                // 尝试获取具有单个type对应接口类型参数的构造器，获取成功，表示具有该构造器，是个Wrapper包装类
                                                clazz.getConstructor(type);
                                                // 拿到cachedWrapperClasses缓存
                                                Set<Class<?>> wrappers = cachedWrapperClasses;
                                                if (wrappers == null) {
                                                    cachedWrapperClasses = new ConcurrentHashSet<Class<?>>();
                                                    wrappers = cachedWrapperClasses;
                                                }
                                                wrappers.add(clazz); // 该clazz加入缓存
                                            } catch (NoSuchMethodException e) {
                                                // 没有上述的带参构造器，只有无参构造器
                                                clazz.getConstructor();
                                                // 获取该扩展点实现类clazz的name
                                                if (name == null || name.length() == 0) {
                                                    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);
                                                        }
                                                    }
                                                }
                                                // 所有的名字name
                                                String[] names = NAME_SEPARATOR.split(name);
                                                if (names != null && names.length > 0) {
                                                   // 判断该clazz是否具有@Activate注解
                                                    Activate activate = clazz.getAnnotation(Activate.class);
                                                    if (activate != null) {
                                                        // 如果存在@Activate注解，在cachedActivates中缓存<第一个name和Activate对象>
                                                        cachedActivates.put(names[0], activate);
                                                    }
                                                    for (String n : names) {
                                                        // cachedNames中还未缓存clazz，则缓存<clazz和第一个name>
                                                        if (!cachedNames.containsKey(clazz)) {
                                                            cachedNames.put(clazz, n);
                                                        }
                                                        // 将各个name和clazz保存到extensionClasses中，可能多个name对应单个clazz(扩展点实现类Class对象)
                                                        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);
    }
}

loadFile()方法从三个目录下获取所有扩展点实现，但只有META-INF/dubbo/internal/com.alibaba.dubbo.common.extension.ExtensionFactory中有数据，即

spring=com.alibaba.dubbo.config.spring.extension.SpringExtensionFactory
adaptive=com.alibaba.dubbo.common.extension.factory.AdaptiveExtensionFactory
spi=com.alibaba.dubbo.common.extension.factory.SpiExtensionFactory

AdaptiveExtensionFactory类带有@Adaptive注解，是ExtensionFactory的自适应扩展实现类。

在loadFile()执行之后，cachedAdaptiveClass=com.alibaba.dubbo.common.extension.factory.AdaptiveExtensionFactory，extensionClasses=[{"spring","class com.alibaba.dubbo.config.spring.extension.SpringExtensionFactory"}, {"spi", "class com.alibaba.dubbo.common.extension.factory.SpiExtensionFactory"}]，extensionClasses中获取的实现类最终会缓存到cachedClasses中。

上面讲解了getAdaptiveExtensionClass()方法中获取自适应类时，加载SPI文件的情况，得到AdaptiveExtensionFactory类。则接下来会调用getAdaptiveExtensionClass().newInstance()中的newInstance()方法，即创建AdaptiveExtensionFactory实例，调用该类的无参构造器，如下所示：

@Adaptive
public class AdaptiveExtensionFactory implements ExtensionFactory {

    private final List<ExtensionFactory> factories;

    public AdaptiveExtensionFactory() {
        ExtensionLoader<ExtensionFactory> loader = ExtensionLoader.getExtensionLoader(ExtensionFactory.class);
        List<ExtensionFactory> list = new ArrayList<ExtensionFactory>();
        // getSupportedExtensions()方法从cachedClasses缓存中获取扩展点实现类的name集合
        for (String name : loader.getSupportedExtensions()) {
            // 实例化各个扩展点，加入EXTENSION_INSTANCES缓存，并放入list中
            list.add(loader.getExtension(name));
        }
        factories = Collections.unmodifiableList(list);
    }

    // 遍历各个工厂，根据type和name获取扩展点实例和其他实例
    public <T> T getExtension(Class<T> type, String name) {
        for (ExtensionFactory factory : factories) {
            T extension = factory.getExtension(type, name);
            if (extension != null) {
                return extension;
            }
        }
        return null;
    }

}

可以看出，在AdaptiveExtensionFactory初始化的过程中，实例化了ExtensionFactory扩展点的各个具体实现(SpringExtensionFactory/SpiExtensionFactory)。具体扩展点实例和其他实例的获取是由这些实现类工厂完成的。

`getExtension(String name)`

这个方法是扩展点具体实现类实例的获取函数。

// 根据name获取扩展点实现的实例
// 先从cachedInstances缓存中查看是否已创建了实例，如果有，直接返回；无则创建后，放入缓存，然后返回。
/*
getExtension() --> createExtension() --> injectExtension()
*/
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;
}

// 创建实例
private T createExtension(String name) {
    // 从cachedClasses缓存中获取实现类Class对象
    Class<?> clazz = getExtensionClasses().get(name);
    if (clazz == null) {
        // 这个时候还没有Class，说明真的没有，直接抛出异常
        throw findException(name);
    }
    try {
        // 查看EXTENSION_INSTANCES缓存是否已经创建了该实例
        T instance = (T) EXTENSION_INSTANCES.get(clazz);
        if (instance == null) {
            // 无，则实例化
            EXTENSION_INSTANCES.putIfAbsent(clazz, (T) clazz.newInstance());
            instance = (T) EXTENSION_INSTANCES.get(clazz);
        }
        injectExtension(instance); // IoC注入
        Set<Class<?>> wrapperClasses = cachedWrapperClasses; // Wrapper包装 
        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);
    }
}

这里体现出来了dubbo-SPI比JDK-SPI的好处：dubbo-SPI不需要遍历所有的实现类来获取想要的实现类，可以直接通过name来获取。

####总结

到这里，ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());已经分析完毕。因此，ExtensionLoader<Protocol>实例化时的objectFactory字段也赋值完成，ExtensionLoader<Protocol>实例化完成。

因此，下面这段代码执行完成。

ExtensionLoader<Protocol> loader = ExtensionLoader.getExtensionLoader(Protocol.class);

ExtensionLoader<Protocol>实例的字段如下所示:

类变量

ConcurrentMap<Class<?>, ExtensionLoader<?» EXTENSION_LOADERS

“interface com.alibaba.dubbo.rpc.Protocol” -> “com.alibaba.dubbo.common.extension.ExtensionLoader[com.alibaba.dubbo.rpc.Protocol]”

“interface com.alibaba.dubbo.common.extension.ExtensionFactory” -> “com.alibaba.dubbo.common.extension.ExtensionLoader[com.alibaba.dubbo.common.extension.ExtensionFactory]”

ConcurrentMap<Class<?>, Object> EXTENSION_INSTANCES

“class com.alibaba.dubbo.config.spring.extension.SpringExtensionFactory” -> SpringExtensionFactory实例

“class com.alibaba.dubbo.common.extension.factory.SpiExtensionFactory” -> SpiExtensionFactory实例

实例变量：

Class<?> type = interface com.alibaba.dubbo.rpc.Protocol

ExtensionFactory objectFactory = AdaptiveExtensionFactory（适配类）

factories = [SpringExtensionFactory实例, SpiExtensionFactory实例]

要点

ExtensionLoader loader = ExtensionLoader.getExtensionLoader(Class type)最终得到的实例变量是：
- Class<?> type = interface T
- ExtensionFactory objectFactory = AdaptiveExtensionFactory（适配类）
  - factories = [SpringExtensionFactory实例, SpiExtensionFactory实例]
ExtensionLoader.getAdaptiveExtension()的调用层级

ExtensionLoader.getAdaptiveExtension() --createAdaptiveExtension() ----injectExtension(getAdaptiveExtensionClass()) ------getAdaptiveExtensionClass() --------getExtensionClasses() // 从spi文件中查找实现类上具有@Adaptive注解的类 ----------loadExtensionClasses() ------------loadFile(Map<String, Class<?>> extensionClasses, String dir) --------createAdaptiveExtensionClass() // 如果从spi文件中没有找到实现类上具有@Adaptive注解的类，则动态创建类

最终返回的是创建好的Adaptive类，例如AdaptiveExtensionFactory实例。
ExtensionLoader.getExtension(String name)的调用层级

ExtensionLoader.getExtension(String name)

–createExtension(String name)

—-getExtensionClasses().get(name) // 获取扩展类

—–injectExtension(instance); // IoC

——Wrapper包装; // AOP

最终返回的是创建好的具体实现类，例如SpringExtensionFactory实例。

得到扩展点实现类实例之后的使用

ExtensionLoader<Protocol> loader = ExtensionLoader.getExtensionLoader(Protocol.class);
Protocol adaptiveExtension = loader.getAdaptiveExtension();

ExtensionLoader<Protocol>.getAdaptiveExtension()的调用过程类似于上述ExtensionLoader<ExtensionFactory>.getAdaptiveExtension()的调用过程，但ExtensionLoader<Protocol>.getAdaptiveExtension()涉及到动态创建自适应扩展点实现类的过程，这个后面再详述。

最终ExtensionLoader<Protocol>.getAdaptiveExtension()获取到的是Protocol$Adaptive实例。在扩展点自适应(Adaptive)这一小节已经给出了Protocol$Adaptive的代码，其中refer(Class, URL)方法的代码如下：

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

如果要调用refer(Class, URL)方法，可以看到refer(Class, URL)方法首先是根据URL中的参数获取扩展点实现类的name，如果没有就是用默认的扩展点名，然后根据扩展点名去获取具体的实现类实例。获取的扩展点实例是经过层层包装的扩展实现，然后就是调用经过包装的refer方法了，就到了具体的实现中的方法了。

关于扩展点IoC、AOP以及Activate注解的分析在后续详述。

Dubbo SPI扩展点加载机制深入分析

ServiceLoader源码分析

Dubbo SPI扩展点加载机制深入分析

Dubbo SPI扩展点加载的功能

Dubbo IoC简介

扩展点自适应(Adaptive)

扩展点AOP简介

Dubbo SPI机制的一些注解和类

@SPI注解

@Adaptive注解

`ExtensionLoader`

@Activate注解

Dubbo SPI机制源码分析

Protocol接口说明

创建ExtensionLoader

`getExtensionLoader(Class<T> type)`

`ExtensionLoader<ExtensionFactory>.getAdaptiveExtension()`

`getExtension(String name)`

要点

得到扩展点实现类实例之后的使用

Reference

CATALOG

FEATURED TAGS

FRIENDS