概述

ExtensionLoader 是dubbo项目的核心组件,正是有了它,使得dubbo的可扩展性得到了极大的提升.dubbo设计之精良,从这点可见一斑.
dubbo的扩展机制,类似于jdk所提供的spi机制. 但是dubbo的更加强大,体现在:

• jdk的spi默认会加载并实例化所有扩展点类，如果对应扩展点没用到且实例化消耗大，则是个耗资源的点。
• 不支持依赖注入，即如果在扩展点类a中，有b扩展点属性实例，则在加载扩展点类a时不会自动注入b。但是dubbo支持依赖注入(根据目标类的setter方法注入
• 加载扩展点失败会吞掉异常，比如加载一个扩展类a，如果其所依赖的jar找不到，不会报这个错误，反而会报不支持。

首先,先手写一个demo利用dubbo的扩展机制,实现一个自己的服务.初步体验一下ExtensionLoader的用法.

首先定义一个(SPI)接口

//必须有 @spi注解 没有就报错
@SPI
public interface BaseExt {
    @Adaptive
    String echo(String str, URL url);
}

然后定义2个实现类

@Adaptive
public class ExtOne implements BaseExt {
    @Override
    public String echo(String str, URL url) {
        System.out.println("one ... " + str);
        return null;
    }
}

public class ExtTwo implements BaseExt {
    @Override
    public String echo(String str, URL url) {
        System.out.println("two ... " + str);
        return null;
    }
}

最后要在 classpath(src/main/resources)下创建一个META-INF/dubbo/internal的目录,创建一个名字为spi接口全路径(com.xx.BaseExt)的文件里面写入一下内容(key=value)

one=com.xx.ExtOne
two=com.xx.ExtTwo

搞定,最后写一个测试类

public class Main {
    public static void main(String[] args) {
        //
        ExtensionLoader<BaseExt> loader = ExtensionLoader.getExtensionLoader(BaseExt.class);
        BaseExt adaptiveExtension = loader.getAdaptiveExtension();
        URL url = URL.valueOf("test://localhost/test");
        adaptiveExtension.echo("d", url);
    }

得到以下输出

one ... d

入门非常简单,例子更简单.从上面能得到一下总结: 用法其实和jdk的ServiceLoader 一个思想, (接口+实现类+配置文件) . 其实dubbo的扩展一直要遵守一下的约定

• Dubbo约定，需要通过SPI加载的接口，在接口上必须添加注解@SPI。
• Dubbo自己实现了加载器（ExtensionLoader）而非使用JDK自带的（ServiceLoader）。
• 实现类的配置文件名称还是以接口全路径命名约定不变，但是内容以key=value格式存在，key表示实现类的别名，value表示实现类全路径（JDK自带的SPI约定内容是实现类全路径）。
• ExtensionLoader分别从依赖的JAR包中的，META－INF/dubbo/internal/目录、META－INF/dubbo/目录、META－INF/services/目录，这个3个目录中扫描寻找实现类配置文件。
• 所有SPI接口，都会有一个要求有一个适配类（即在实现类打上@Adaptive注解就被认定为适配类，如果扫描后所有实现类都没有该注解，系统会生成一个）。在系统里面使用时，一般都先获取接口的适配类实例，然后再由入参配置来决定选择哪个具体实现类调用。实现了可配置动态切换实现类。
• 在实现类里面，可以通过提供setter方法来达到依赖注入。

其实dubbo一个spi服务一般会有多种实现 ,具体使用哪一个实现呢? 这个是忧优先级的 .

• 首先,在实现类(方法上无效)上面加 @Adaptive 注解,优先级会最高
• 如果所有实现类都没有这个注解(接口方法上的不算),回去寻找url路径中的指明的那个注解 ,比如上面mian函数中的 ,spi接口的分段形式(XxxYyy类的分段形式 : xxxx.yyy)作为key,配置文件中的key作为value, 根据这个value也可以找到具体实现类,比如上面如果URL中这样写:
  URL url = URL.valueOf("test://localhost/test?base.ext=one");
  就表示 spi接口BaseExt 要求使用OneExt作为实现类
• 如果URL中也没有指定 ,还有次次优先级的方式: spi注解中加入默认值
  比如 BaseExt的spi注解中这样写: @SPI("two")此时,TwoExt 就作为默认实现类提供服务了 .注意这个优先级哦

知道了上面的用法和各种玩法. 下面是时候再探究竟了 .我们看下源代码吧 .

ExtensionLoader<BaseExt> loader = ExtensionLoader.getExtensionLoader(BaseExt.class);
引出

 @SuppressWarnings("unchecked")
    public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
        if (type == null)
            throw new IllegalArgumentException("Extension type == null");
        //说明SPI获取的必须是接口类型
        if(!type.isInterface()) {
            throw new IllegalArgumentException("Extension type(" + type + ") is not interface!");
        }
        // 说明SPI服务的接口必须有`@SPI`这个注解
        if(!withExtensionAnnotation(type)) {
            throw new IllegalArgumentException("Extension type(" + type + 
                    ") is not extension, because WITHOUT @" + SPI.class.getSimpleName() + " Annotation!");
        }
        //第一次获取必定拿到null
        ExtensionLoader<T> loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
        if (loader == null) {
            //new一个扩展器处理这个type,new操作的特别之处在于会创建一个factory来获取目标type,从而得到扩展工厂,
            EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));
            loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
        }
        return loader;
    }

创建扩展工厂需要ExtensionFactory

  private ExtensionLoader(Class<?> type) {
        this.type = type;
        objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
    }

从上面可以看到 ,拿到 ExtensionFactory之后,会放入 ExtensionLoader的内部类变量 private static final ConcurrentMap<Class<?>, ExtensionLoader<?>> EXTENSION_LOADERS = new ConcurrentHashMap<Class<?>, ExtensionLoader<?>>(); 里面 .这个玩意就是缓存着了. 所有获取过的扩展对象都会在这里存下来. 后面再拿就走这个缓存了. 我们再来看main中下一句引子BaseExt adaptiveExtension = loader.getAdaptiveExtension();

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

调用创建扩展类函数 ExtensionLoader.createAdaptiveExtension

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

继续看获取的逻辑 getAdaptiveExtensionClass

// 开始获取扩展
   private Class<?> getAdaptiveExtensionClass() {
        //这里如果获取下面步骤
        getExtensionClasses();
        if (cachedAdaptiveClass != null) {
            return cachedAdaptiveClass;
        }
        return cachedAdaptiveClass = createAdaptiveExtensionClass();
    }
//下面先沿着 getExtensionClasses 这条线 ,尝试获取扩展实现类
//下面是获取扩展的
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方法同步过。
    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<?>>();
        //从 META-INF/dubbo/internal 目录读取
        loadFile(extensionClasses, DUBBO_INTERNAL_DIRECTORY);
        // 从 META-INF/dubbo/ 目录读取
        loadFile(extensionClasses, DUBBO_DIRECTORY);
        // 从 META-INF/services/ 目录读取
        loadFile(extensionClasses, SERVICES_DIRECTORY);
        return extensionClasses;
    }
//读取逻辑不在贴代码了 ,就是获取文件 按照key=value的配置文件的形式解析服务配置文件
//但是有一段代码贴下 ,就是在解析的过程中,发现实现类头上有 @Adaptive注解的 ,就把他设置到当前的 cachedAdaptiveClass 属性中去.(摘自方法 loadFile)
  //
 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());
    }
} 
// ..................

到此为止,这条线已经走完,完成之后(看下面),如果在load的过程中 找到了自动适配的类(@adaptive注解的实现类) ,则直接返回cachedAdaptiveClass完成任务 .否则开始走另一条线createAdaptiveExtensionClass

// 这块代码是上面开始的时候代码,
  private Class<?> getAdaptiveExtensionClass() {
        //这里如果获取下面步骤
        getExtensionClasses();
        if (cachedAdaptiveClass != null) {
            return cachedAdaptiveClass;
        }
        return cachedAdaptiveClass = createAdaptiveExtensionClass();
    }

接下来看看另一条线吧.

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

//不全部粘贴了 ,详细的自己看源码了 ,篇幅有限
private String createAdaptiveExtensionClassCode() {
        StringBuilder codeBuidler = new StringBuilder();
        Method[] methods = type.getMethods();
        boolean hasAdaptiveAnnotation = false;
        for(Method m : methods) {
            if(m.isAnnotationPresent(Adaptive.class)) {
                hasAdaptiveAnnotation = true;
                break;
            }
        }
        // 完全没有Adaptive方法，则不需要生成Adaptive类
        if(! hasAdaptiveAnnotation)
            throw new IllegalStateException("No adaptive method on extension " + type.getName() + ", refuse to create the adaptive class!");
        
        codeBuidler.append("package " + type.getPackage().getName() + ";");
        codeBuidler.append("\nimport " + ExtensionLoader.class.getName() + ";");
        codeBuidler.append("\npublic class " + type.getSimpleName() + "$Adpative" + " implements " + type.getCanonicalName() + " {");
        
        for (Method method : methods) {
            Class<?> rt = method.getReturnType();
            Class<?>[] pts = method.getParameterTypes();
            Class<?>[] ets = method.getExceptionTypes();
//.......................省略 ,

可以看出,上面就是要通过代码创建一个java文件,并用compile进行编译
下面是一个通过编译得到的例子 (可读性比较差,但是能看出大概意思),

package com.xxx.dubbo;
import com.alibaba.dubbo.common.extension.ExtensionLoader;
public class BaseExt$Adpative implements com.zuosh.dts2018.dubbo.BaseExt {
public java.lang.String echo(java.lang.String arg0, com.alibaba.dubbo.common.URL arg1) {
if (arg1 == null) throw new IllegalArgumentException("url == null");
com.alibaba.dubbo.common.URL url = arg1;
String extName = url.getParameter("base.ext");
if(extName == null) throw new IllegalStateException("Fail to get extension(com.xxx.dubbo.BaseExt) name from url(" + url.toString() + ") use keys([base.ext])");
com.xxx.dubbo.BaseExt extension = (com.xxx.dubbo.BaseExt)ExtensionLoader.getExtensionLoader(com.xxx.dubbo.BaseExt.class).getExtension(extName);
return extension.echo(arg0, arg1);
}
}

上面就是获取自适应扩展实现类的全部过程. 我们从一个方法逐渐深入,看了扩展器的其中一个功能 (获取自适应扩展类) ,其他各种五花八门的获取实现类的方式(如下图)都是差不多同样的道理.都值得我们一一学习和参考.

image.png

后面的其他扩展原理都是大同小异,但是重载的很多方法给我们日常编码提供了很好的例子,让我们知道怎么样写一个好的扩展,而不是仅仅实现功能.