dubbo中自己实现了不同于java的SPI插件化机制，使得Dubbo可以在对多个指定的目录中加载扩展实现，同时与Java SPI不同的是可以实现按需加载。
Dubbo的扩展SPI有如下特点：
1. 单例，对于某个类型扩展，只会有一个ExtensionLoader；
2. 延迟加载，可以一次只获取想要的扩展点，一次获取想要的扩展点实现；
3. 对于扩展点的Ioc和Aop，就是一个扩展可以注入到另一个扩展中，也可以对一个扩展做wrap包装实现aop的功能；
4. 对于扩展点的调用，真正调用的时候才能确认具体使用的是那个实现。
源码实现
在Dubbo加载扩展点会代码示例如下，具体实现在ExtensionLoader中。接下来会详细介绍。
private static final Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();
private static final Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getExtension("dubbo");
getExtensionLoader方法中先从缓存中拿ExtensionLoader，如果没有就new一个，new的过程如下：
private ExtensionLoader(Class<?> type) { this.type = type; //也是利用扩展实现，后面会看到在注入其他扩展点或bean到当前扩展时使用 objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension()); }
objectFactory就是为了获取其他扩展点而设计的，其本身也是使用ExtensionLoader来获取。具体实现看下面的TODO1
1）ExtensionLoader#getAdaptiveExtension
DCL初始化一个默认的自适应扩展实现，如果没有则创建一个createAdaptiveExtension。
2）ExtensionLoader#createAdaptiveExtension
private T createAdaptiveExtension() { try { /** * 1. getAdaptiveExtensionClass：获取适配器类； * 2. injectExtension：为适配器类的setter方法插入其他扩展点或实现bean。 */ return injectExtension((T) getAdaptiveExtensionClass().newInstance()); } catch (Exception e) { throw new IllegalStateException("Can't create adaptive extension " + type + ", cause: " + e.getMessage(), e); } }
接下来讲解一下如何获取到扩展点的，TODO1 最后再详细解释如何在扩展点上注入其他的扩展点
3）ExtensionLoader#getAdaptiveExtensionClass
private Class<?> getAdaptiveExtensionClass() { getExtensionClasses(); if (cachedAdaptiveClass != null) { return cachedAdaptiveClass; } return cachedAdaptiveClass = createAdaptiveExtensionClass(); }
这边会类加载所有的实现class，但是只会实例化一个cachedAdaptiveClass， TODO2 如果找不到，则dubbo通过代码生成一个自适应了扩展实现。
4）ExtensionLoader#getExtensionClasses
初始化该类型下所有扩展点实现class，并缓存在cachedClasses中
5） ExtensionLoader # loadExtensionClasses
// synchronized in getExtensionClasses private Map<String, Class<?>> loadExtensionClasses() { // SPI注解中会指定一个默认的实现 列如 interface Cluster 上 @SPI(FailoverCluster.NAME) // 则cachedDefaultName = FailoverCluster.NAME cacheDefaultExtensionName(); // 将类型中的所有实现存放在extensionClasses中 Map<String, Class<?>> extensionClasses = new HashMap<>(); loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY, type.getName()); //META-INF/dubbo/internal/ loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY, type.getName().replace("org.apache", "com.alibaba")); loadDirectory(extensionClasses, DUBBO_DIRECTORY, type.getName()); // //META-INF/dubbo/ loadDirectory(extensionClasses, DUBBO_DIRECTORY, type.getName().replace("org.apache", "com.alibaba")); loadDirectory(extensionClasses, SERVICES_DIRECTORY, type.getName()); // //META-INF/services/ loadDirectory(extensionClasses, SERVICES_DIRECTORY, type.getName().replace("org.apache", "com.alibaba")); return extensionClasses; }
6 ExtensionLoader#loadDirectory -> ExtensionLoader#loadResource -> ExtensionLoader#loadClass
主要是找到加载器，然后读取文件，忽略注释，通过class.forName来类加载具体实现。最后保存在extensionClasses。其中自适应的实现和包装类的实现class，单独赋值。
private void loadClass(Map<String, Class<?>> extensionClasses, java.net.URL resourceURL, Class<?> clazz, String name) throws NoSuchMethodException { //必须是该扩展点的实现 if (!type.isAssignableFrom(clazz)) { throw new IllegalStateException("Error occurred when loading extension class (interface: " + type + ", class line: " + clazz.getName() + "), class " + clazz.getName() + " is not subtype of interface."); } //这里判断是否有自定义的适配器类，如果有，后面获取适配器的时候，就可以直接用这个创建返回，不用dubbo动态创建 if (clazz.isAnnotationPresent(Adaptive.class)) { cacheAdaptiveClass(clazz); } else if (isWrapperClass(clazz)) { // 包装类会有一个参数为type的构造器 cacheWrapperClass(clazz); } else { //处理不是包裹类的情况 且 又不带有Adaptive注解 clazz.getConstructor(); if (StringUtils.isEmpty(name)) { // 计算出实现类的name 列如 // clazz = org.apache.dubbo.common.compiler.support.JdkCompiler.class // type = org.apache.dubbo.common.compiler.Compiler.class // 则 name = JdkCompiler - Compiler = jdk name = findAnnotationName(clazz); if (name.length() == 0) { throw new IllegalStateException("No such extension name for the class " + clazz.getName() + " in the config " + resourceURL); } } String[] names = NAME_SEPARATOR.split(name); if (ArrayUtils.isNotEmpty(names)) { //判断下Activate注解，后面讲，这里只需要知道，会缓存Activate注解的实现 cacheActivateClass(clazz, names[0]); for (String n : names) { cacheName(clazz, n); //缓存扩展实现 saveInExtensionClass(extensionClasses, clazz, name); } } } }
这边不得不强调一下，关于Adaptive注解。这个注解可以修饰具体的扩展实现类，也可以修饰具体扩展的实现类中的方法。
当修饰的是类的时候，将作为默认的扩展点，如果是修饰SPI的方法的时候，将会生成类的Methed$Adaptive中重新该方法，即上面的TODO2的内容。
另外还缓存了Activate类，关于Activate类将会后续介绍 TODO3
整个ExtensionLoader的流程相对是比较简单的，无非就是使用到@SPI注解的值或者是@Adaptive自定义的扩展。接下来具体讲解下上面流程中提到的TODO。
TODO1
实现IOC，一个扩展中初始化另一个扩展, ExtensionLoader#injectExtension
/** 插入该扩展需要其他扩展或bean */ private T injectExtension(T instance) { try { if (objectFactory != null) { // 默认objectFactory = AdaptiveExtensionFactory for (Method method : instance.getClass().getMethods()) { if (isSetter(method)) { /** * Check {@link DisableInject} to see if we need auto injection for this property */ if (method.getAnnotation(DisableInject.class) != null) { continue; } Class<?> pt = method.getParameterTypes()[0]; // 过滤掉基础类型 if (ReflectUtils.isPrimitives(pt)) { continue; } try { // for instance: setVersion, return "version" String property = getSetterProperty(method); // 根据参数类型class， 以及方法名中获取的property，通过具体的ExtensionFactory来获取到具体的扩展点 Object object = objectFactory.getExtension(pt, property); if (object != null) { // 将扩展实现作为setter方法的参数，来实现注入 method.invoke(instance, object); } } catch (Exception e) { logger.error("Failed to inject via method " + method.getName() + " of interface " + type.getName() + ": " + e.getMessage(), e); } } } } } catch (Exception e) { logger.error(e.getMessage(), e); } return instance; }
其中AdaptiveExtensionFactory实际上就是加载所有的非Adaptive的扩展点,然后将其实例保存在List<ExtensionFactory> factories中，当需要获取指定name和type的Extension上的时候，实际上就是遍历所有的ExtensionFactory，直到加载到对应的扩展点。列如需要注入的扩展，即setter方法的参数类型也是注解了SPI，那么就会默认使用到SPIExtensionFactory，即自适应加载。
@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>(); // 获取到可以支持的哪些具体实现 for (String name : loader.getSupportedExtensions()) { // 对所有的ExtensionFactory扩展点 实例化， 实际上就一个SpiExtensionFactory list.add(loader.getExtension(name)); } factories = Collections.unmodifiableList(list); } @Override 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; }
TODO2
如果所有的SPI扩展实现都没有找到@Adaptive的扩展，那么dubbo就会生成自适应扩展的代码。根据SPI接口会重写@Adaptive注解的方法，方法参数一定是能够获取到URL的。如果在URL获取不到扩展名，则默认取SPI注解指定的值，然后用这个扩展名，通过ExtensionLoad加载对应的扩展点。最后通过编译器来编译code，加载到$Adaptive结尾的class，编译器也有多种实现，也是通过ExtensionLoad加载
/** Dubbo生成适配类 */ private Class<?> createAdaptiveExtensionClass() { //动态生成适配器代码 String code = new AdaptiveClassCodeGenerator(type, cachedDefaultName).generate(); ClassLoader classLoader = findClassLoader(); org.apache.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(org.apache.dubbo.common.compiler.Compiler.class).getAdaptiveExtension(); return compiler.compile(code, classLoader); }
这边我们做一个简单的测试，看一下自动生成自适应代码是什么样的。
public interface Compiler { /** * Compile java source code. * * @param code Java source code * @param classLoader classloader * @return Compiled class */ Class<?> compile(String code, ClassLoader classLoader); @Adaptive({"p1", "p2"}) Validator getValidator(URL url); } public static void main(String[] args) { String c = new AdaptiveClassCodeGenerator(org.apache.dubbo.common.extension.ExtensionLoader.Compiler.class, "jdk").generate(); System.out.println(c); }
这个测试做的事情就是加载一个org.apache.dubbo.common.extension.ExtensionLoader.Compiler.class的实现，但是由于没有找到任何的扩展点，所以就采用自动生成code，编译的方式。
其结果如下：
package org.apache.dubbo.common.extension; import org.apache.dubbo.common.extension.ExtensionLoader; public class Compiler$Adaptive implements org.apache.dubbo.common.extension.ExtensionLoader.Compiler { public java.lang.Class compile(java.lang.String arg0, java.lang.ClassLoader arg1) { throw new UnsupportedOperationException("The method public abstract java.lang.Class org.apache.dubbo.common.extension.ExtensionLoader$Compiler.compile(java.lang.String,java.lang.ClassLoader) of interface org.apache.dubbo.common.extension.ExtensionLoader$Compiler is not adaptive method!"); } public javax.xml.validation.Validator getValidator(org.apache.dubbo.common.URL arg0) { if (arg0 == null) throw new IllegalArgumentException("url == null"); org.apache.dubbo.common.URL url = arg0; String extName = url.getParameter("p1", url.getParameter("p2", "jdk")); if (extName == null) throw new IllegalStateException("Failed to get extension (org.apache.dubbo.common.extension.ExtensionLoader$Compiler) name from url (" + url.toString() + ") use keys([p1, p2])"); org.apache.dubbo.common.extension.ExtensionLoader$Compiler extension = (org.apache.dubbo.common.extension.ExtensionLoader$Compiler) ExtensionLoader.getExtensionLoader(org.apache.dubbo.common.extension.ExtensionLoader$Compiler.class).getExtension(extName); return extension.getValidator(arg0); } }
其特点如下：
1） 生成一个$Adaptive后缀的class
2) 如果没有@Adaptive注解的方法，则throw一个UnsupportedOperationException
3）对于使用的Adaptive注解的方法，其参数列表一定需要一个URL类型的参数，根据上面的配置，从URL中获取P1是值，如果获取不到则获取P2的值，如果再获取不到，则使用默认的值
4）根据第三步获取的值，从ExtensionLoader加载指定的扩展点实现。
TODO3
先来看一下@Activate注解
@Documented @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.TYPE, ElementType.METHOD}) public @interface Activate { /** * Group过滤条件。 * <br /> * 包含{@link ExtensionLoader#getActivateExtension}的group参数给的值，则返回扩展。 * <br /> * 如没有Group设置，则不过滤。 */ String[] group() default {}; /** * Key过滤条件。包含{@link ExtensionLoader#getActivateExtension}的URL的参数Key中有，则返回扩展。 * <p /> * 示例：<br/> * 注解的值 <code>@Activate("cache,validatioin")</code>， * 则{@link ExtensionLoader#getActivateExtension}的URL的参数有<code>cache</code>Key，或是<code>validatioin</code>则返回扩展。 * <br/> * 如没有设置，则不过滤。 */ String[] value() default {}; /** * 排序信息，可以不提供。 */ String[] before() default {}; /** * 排序信息，可以不提供。 */ String[] after() default {}; /** * 排序信息，可以不提供。 */ int order() default 0; }
group基本表示用在服务端还是消费端，value表示激活这个扩展点的条件，before、after、order用于排序。为了加深理解，我们拿一个UT例子看一下，
getActivateExtension方法基本都会传入url作为参数，用法是获取激活条件的所有扩展点实现类。
@Test public void testLoadDefaultActivateExtension() throws Exception { // test default URL url = URL.valueOf("test://localhost/test?ext=order1,default"); List<ActivateExt1> list = ExtensionLoader.getExtensionLoader(ActivateExt1.class) .getActivateExtension(url, "ext", "default_group"); Assertions.assertEquals(2, list.size()); Assertions.assertTrue(list.get(0).getClass() == OrderActivateExtImpl1.class); Assertions.assertTrue(list.get(1).getClass() == ActivateExt1Impl1.class); url = URL.valueOf("test://localhost/test?ext=default,order1"); list = ExtensionLoader.getExtensionLoader(ActivateExt1.class) .getActivateExtension(url, "ext", "default_group"); Assertions.assertEquals(2, list.size()); Assertions.assertTrue(list.get(0).getClass() == ActivateExt1Impl1.class); Assertions.assertTrue(list.get(1).getClass() == OrderActivateExtImpl1.class); } 扩展配置如下： group=org.apache.dubbo.common.extension.activate.impl.GroupActivateExtImpl value=org.apache.dubbo.common.extension.activate.impl.ValueActivateExtImpl order1=org.apache.dubbo.common.extension.activate.impl.OrderActivateExtImpl1 order2=org.apache.dubbo.common.extension.activate.impl.OrderActivateExtImpl2 old1=org.apache.dubbo.common.extension.activate.impl.OldActivateExt1Impl2 old2=org.apache.dubbo.common.extension.activate.impl.OldActivateExt1Impl3
接下里看一下ExtensionLoader#getActivateExtension
//获取满足激活条件的扩展实现 public List<T> getActivateExtension(URL url, String[] values, String group) { List<T> exts = new ArrayList<T>(); List<String> names = values == null ? new ArrayList<String>(0) : Arrays.asList(values); if (! names.contains(Constants.REMOVE_VALUE_PREFIX + Constants.DEFAULT_KEY)) { //加载扩展 getExtensionClasses(); //上一步会缓存所有Active注解的实现类到cachedActivates for (Map.Entry<String, Activate> entry : cachedActivates.entrySet()) { String name = entry.getKey(); Activate activate = entry.getValue(); //匹配group，provider还是consumer
// activateGroup = activate扩展点注解activate配置的Group
// group URL中的group
if (isMatchGroup(group, activate.group())) { //获取扩展实现类 T ext = getExtension(name); //isActive匹配激活条件 if (! names.contains(name) && ! names.contains(Constants.REMOVE_VALUE_PREFIX + name) && isActive(activate, url)) { exts.add(ext); } } } //这里会重新排序，用到Active里面before、after和order Collections.sort(exts, ActivateComparator.COMPARATOR); } .... .... return exts; }
就是说根据URL，会把需要的扩展都会收集起来，并排好序。