dubbo是如何实现可扩展的？

dubbo如何实现可扩展的，援引官网描述：

Dubbo 的扩展点加载从 JDK 标准的 SPI (Service Provider Interface) 扩展点发现机制加强而来。

Dubbo 改进了 JDK 标准的 SPI 的以下问题：

JDK 标准的 SPI 会一次性实例化扩展点所有实现，如果有扩展实现初始化很耗时，但如果没用上也加载，会很浪费资源。
如果扩展点加载失败，连扩展点的名称都拿不到了。比如：JDK 标准的 ScriptEngine，通过 getName() 获取脚本类型的名称，但如果 RubyScriptEngine 因为所依赖的 jruby.jar 不存在，导致 RubyScriptEngine 类加载失败，这个失败原因被吃掉了，和 ruby 对应不起来，当用户执行 ruby 脚本时，会报不支持 ruby，而不是真正失败的原因。
增加了对扩展点 IoC 和 AOP 的支持，一个扩展点可以直接 setter 注入其它扩展点。

定义个接口：

public interface HelloService {
    String  sayHello();
}

定义两个实现类：

public class DogHelloService  implements HelloService {
    @Override
    public String sayHello() {
        return "wang";
    }
}

public class HumanHelloService   implements HelloService {
    @Override
    public String sayHello() {
        return "hello 你好";
    }
}

1.JDK标准的SPI是怎么回事？

ServiceLoader.load方法会加载META-INF/services/目录下定义的接口全限定名文件，内容为实现类。

com.exm.service.impl.DogHelloService
com.exm.service.impl.HumanHelloService

核心为ServiceLoader.LazyIterator迭代器，在load方法被调用时，会初始化该迭代器，如下：

 public void reload() {
        providers.clear();
        lookupIterator = new LazyIterator(service, loader);
    }

LazyIterator会读取配置实现类，并通过反射进行实例化（前提要求实现类需要具备无参构造）。

其中hasNextService方法会加载META-INF/services接口文件，并加载到Enumeration<URL> configs中，源码如下：

private boolean hasNextService() {
            if (nextName != null) {
                return true;
            }
            if (configs == null) {
                try {
                      //获取配置全路径名。如：META-INF/services/com.exm.service.HelloService
                    String fullName = PREFIX + service.getName();
                    if (loader == null)
                        configs = ClassLoader.getSystemResources(fullName);
                    else
                      //并加载到Enumeration<URL> configs中
                        configs = loader.getResources(fullName);
                } catch (IOException x) {
                    fail(service, "Error locating configuration files", x);
                }
            }
            while ((pending == null) || !pending.hasNext()) {
                if (!configs.hasMoreElements()) {
                    return false;
                }
                pending = parse(service, configs.nextElement());
            }
            nextName = pending.next();
            return true;
        }

迭代器通过nextService获取下一个实现类对象，源码如下，其中包含反射拿到Class对象，并实例化。

private S nextService() {
            if (!hasNextService())
                throw new NoSuchElementException();
            String cn = nextName;
            nextName = null;
            Class<?> c = null;
            try {
              //反射实例化
                c = Class.forName(cn, false, loader);
            } catch (ClassNotFoundException x) {
                fail(service,
                     "Provider " + cn + " not found");
            }
            if (!service.isAssignableFrom(c)) {
                fail(service,
                     "Provider " + cn  + " not a subtype");
            }
            try {
              //转强制化为接口，并放入LinkedHashMap<String,S> providers中
                S p = service.cast(c.newInstance());
                providers.put(cn, p);
                return p;
            } catch (Throwable x) {
                fail(service,
                     "Provider " + cn + " could not be instantiated",
                     x);
            }
            throw new Error();          // This cannot happen
        }

为什么说JDK的SPI会一次性加载并实例化所有的扩展呢？

因为在调load时，实际构造了ServiceLoader.LazyIterator，如果想找到某个扩展实现，需要迭代器遍历所有的实现才可以。

️如果其中有一个实例化或cast时异常，后边所有都将无法遍历。

️如果某个类的实例化耗时很长，并没用到，会造成资源浪费

编写一个测试方法：

public static void main(String[] args) {
        final ServiceLoader<HelloService> helloServices  = ServiceLoader.load(HelloService.class);
        for (HelloService helloService : helloServices){
            System.out.println(helloService.getClass().getName() + ":" + helloService.sayHello());
        }
    }

测试输出：

com.exm.service.impl.DogHelloService:wang
com.exm.service.impl.HumanHelloService:hello 你好

2.Dubbo是怎么进行改进的呢？

dubbo时如何进行改进的呢？

（1）dubbo定义的SPi文件包含了key，即每个实现类对应一个不同的key，在加载class的时候，会将key和class放入一个map中。

这样在使用者想使用哪个类的实例时，只需要实例化对应的类，无需实例化所有类

（2）Adaptive功能：实现动态的使用扩展点。通过 getAdaptiveExtension方法统一对指定接口对应的所有扩展点进行封装，通过URL的方式对扩展点来进行动态选择。

2.1 加载所有扩展点，选择性实例化

public class Main {
    public static void main(String[] args) {
        // 获取扩展加载器
        ExtensionLoader<HelloService>  extensionLoader  = ExtensionLoader.getExtensionLoader(HelloService.class);
        // 遍历所有的支持的扩展点，并将key与实现类进行关联
        Set<String>  extensions = extensionLoader.getSupportedExtensions();
        for (String extension : extensions){
            String result = extensionLoader.getExtension(extension).sayHello();
            System.out.println(result);
        }
    }
}

ExtensionLoader.getSupportedExtensions会加载所有扩展类（但没有实例化）。然后通过extensionLoader.getExtension对指定key进行实例化，这一点是与JDK不同的。

我们看下具体是怎么加载的，getSupportedExtensions为入口，最终会通过loadDirectory进行加载

Set<String> getSupportedExtensions()
    Map<String, Class<?>> getExtensionClasses()
        Map<String, Class<?>> loadExtensionClasses()
            void loadDirectory(Map<String, Class<?>> extensionClasses, String dir, String type, boolean extensionLoaderClassLoaderFirst)

（1）getSupportedExtensions方法会返回所有扩展点的key，供用户使用。

public Set<String> getSupportedExtensions() {
        Map<String, Class<?>> clazzes = this.getExtensionClasses();
              //获取到所有扩展点后，将key放入TreeSet中（按字符串排序）
        return Collections.unmodifiableSet(new TreeSet(clazzes.keySet()));
    }

loadDirectory加载文件的来源为以下6个部分，兼容了JDK路径。

同时加载有顺序，越靠前越优先加载

private Map<String, Class<?>> loadExtensionClasses() {
        this.cacheDefaultExtensionName();
        Map<String, Class<?>> extensionClasses = new HashMap();
        this.loadDirectory(extensionClasses, "META-INF/dubbo/internal/", this.type.getName(), true);
        this.loadDirectory(extensionClasses, "META-INF/dubbo/internal/", this.type.getName().replace("org.apache", "com.alibaba"), true);
        this.loadDirectory(extensionClasses, "META-INF/dubbo/", this.type.getName());
        this.loadDirectory(extensionClasses, "META-INF/dubbo/", this.type.getName().replace("org.apache", "com.alibaba"));
        this.loadDirectory(extensionClasses, "META-INF/services/", this.type.getName());
        this.loadDirectory(extensionClasses, "META-INF/services/", this.type.getName().replace("org.apache", "com.alibaba"));
        return extensionClasses;
    }

（2）在Set中获取到扩点类对应的key，通过getExtension获取对应class的实例（包含通过setter进行依赖注入）

public T getExtension(String name) {
        if (StringUtils.isEmpty(name)) {
            throw new IllegalArgumentException("Extension name == null");
        } else if ("true".equals(name)) {
            return this.getDefaultExtension();
        } else {
            Holder<Object> holder = this.getOrCreateHolder(name);
            Object instance = holder.get();
            if (instance == null) {
                synchronized(holder) {
                    instance = holder.get();
                    if (instance == null) {
                          //创建对应class的实例，完成依赖注入
                        instance = this.createExtension(name);
                        holder.set(instance);
                    }
                }
            }
 
            return instance;
        }
    }

createExtension方法是实例化的核心，实现了IOC和AOP，注释如下：

private T createExtension(String name) {
         //获取name对应的class
        Class<?> clazz = getExtensionClasses().get(name);
        if (clazz == null) {
            throw findException(name);
        }
        try {
            T instance = (T) EXTENSION_INSTANCES.get(clazz);
            if (instance == null) {
                  //实例化
                EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance());
                instance = (T) EXTENSION_INSTANCES.get(clazz);
            }
              //依赖注入（IOC）
            injectExtension(instance);
              //包装器（AOP）
            Set<Class<?>> wrapperClasses = cachedWrapperClasses;
            if (CollectionUtils.isNotEmpty(wrapperClasses)) {
                for (Class<?> wrapperClass : wrapperClasses) {
                    instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
                }
            }
            initExtension(instance);
            return instance;
        } catch (Throwable t) {
            throw new IllegalStateException("Extension instance (name: " + name + ", class: " +
                    type + ") couldn't be instantiated: " + t.getMessage(), t);
        }
    }

2.2 getAdaptiveExtension根据URL参数动态获取相应的扩展点

public class AdaptiveMain {
    public static void main(String[] args) {
        URL   url  = URL.valueOf("test://localhost/hello?hello.service=dog");
        HelloService  adaptiveExtension = ExtensionLoader.getExtensionLoader(HelloService.class).getAdaptiveExtension();
        String  msg = adaptiveExtension.sayHello(url);
        System.out.println(msg);
    }
}

（1）核心代码为ExtensionLoader.getAdaptiveExtension方法

public T getAdaptiveExtension() {
        Object instance = cachedAdaptiveInstance.get();
        if (instance == null) {
            if (createAdaptiveInstanceError != null) {
                throw new IllegalStateException("Failed to create adaptive instance: " +
                        createAdaptiveInstanceError.toString(),
                        createAdaptiveInstanceError);
            }
 
            synchronized (cachedAdaptiveInstance) {
                instance = cachedAdaptiveInstance.get();
                if (instance == null) {
                    try {
                          //创建自适应扩展
                        instance = createAdaptiveExtension();
                        cachedAdaptiveInstance.set(instance);
                    } catch (Throwable t) {
                        createAdaptiveInstanceError = t;
                        throw new IllegalStateException("Failed to create adaptive instance: " + t.toString(), t);
                    }
                }
            }
        }
 
        return (T) instance;
    }

（2）创建自适应扩展类实例

private T createAdaptiveExtension() {
        try {
              //获取自适应扩展类，并实例化，然后通过setter注入依赖
            return injectExtension((T) getAdaptiveExtensionClass().newInstance());
        } catch (Exception e) {
            throw new IllegalStateException("Can't create adaptive extension " + type + ", cause: " + e.getMessage(), e);
        }
    }

（3）生成自适应扩展类class

private Class<?> getAdaptiveExtensionClass() {
        getExtensionClasses();
        if (cachedAdaptiveClass != null) {
            return cachedAdaptiveClass;
        }
        return cachedAdaptiveClass = createAdaptiveExtensionClass();
    }

（4）加载类扩展点（与上文相同）

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

（5）创建自适应扩展class，动态生成代码，并进行编译

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

得到如下class：

package com.exm.service;
import org.apache.dubbo.common.extension.ExtensionLoader;
public class HelloService$Adaptive implements com.exm.service.HelloService {
public java.lang.String sayHello()  {
throw new UnsupportedOperationException("The method public abstract java.lang.String com.exm.service.HelloService.sayHello() of interface com.exm.service.HelloService is not adaptive method!");
}
public java.lang.String sayHello(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("hello.service", "human");
if(extName == null) throw new IllegalStateException("Failed to get extension (com.exm.service.HelloService) name from url (" + url.toString() + ") use keys([hello.service])");
com.exm.service.HelloService extension = (com.exm.service.HelloService)ExtensionLoader.getExtensionLoader(com.exm.service.HelloService.class).getExtension(extName);
return extension.sayHello(arg0);
}
}

可以看到自适应只支持具有adaptive注解的方法，并且参数汇总需要有URL参数。

具体逻辑，是通过获取URL参数中的变量，ExtensionLoader.getExtensionLoader().getExtension(name)获取具体的class实例，完成调用。

（6）通过setter注入依赖

private T injectExtension(T instance) {
 
    if (objectFactory == null) {
        return instance;
    }
 
    try {
        for (Method method : instance.getClass().getMethods()) {
            if (!isSetter(method)) {
                continue;
            }
            /**
             * 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 {
                String property = getSetterProperty(method);
                  //获取到Adaptive对象
                Object object = objectFactory.getExtension(pt, property);
                if (object != null) {
                    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;
}

（7）上文中的objectFactory是ExtensionFactory实例，其实现类包含SpiExtensionFactory和SpringExtensionFactory，一个是dubbo的扩展工厂，一个是Spring的工厂；前者只支持type是SPI的接口，并生成自适应类；后者从Spring容器中获取。

在依赖注入时，会在两个容器中遍历，如下：

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

（8）另外，还有一个实现类是AdaptiveExtensionFactory是默认的@Adaptive类，即被该注解修饰的类是自适应类，就不会动态生成了。

在getExtensionClasses()加载ExtensionFactory扩展class时，如果扩点类被Adaptive注解修饰，则将缓存在ExtensionLoader.cachedAdaptiveClass中；

在getAdaptiveExtensionClass方法中，直接返回，不需要生成自适应类。

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.");
    }
      //判断类事都是Adaptive类，是的话就缓存，在getAdaptiveExtensionClass时直接返回
    if (clazz.isAnnotationPresent(Adaptive.class)) {
        cacheAdaptiveClass(clazz);
    } else if (isWrapperClass(clazz)) {
        cacheWrapperClass(clazz);
    } else {
        clazz.getConstructor();
        if (StringUtils.isEmpty(name)) {
            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)) {
            cacheActivateClass(clazz, names[0]);
            for (String n : names) {
                cacheName(clazz, n);
                saveInExtensionClass(extensionClasses, clazz, n);
            }
        }
    }
}

综上，dubbo加载class扩展与实例化是分开的，可以通过指定key实例化某一个class；

dubbo支持IOC和AOP；

同时，dubbo结合SPI与Adaptive注解，可以实现对所有扩展class封装，然后根据URL参数动态获取指定的class。

3.在注入依赖的时候是否有循环依赖的问题？

在dubbo创建扩展class实例时，会通过setter进行依赖注入，如果存在循环依赖，怎么处理？

在dubbo依赖注入时，除了Spring容器外，从SPI容器中获取，获取的是SPI接口的自适应实现，是新创建的类，所以不存在循环依赖的问题。

牛逼的框架，就是让你一眼看不懂它在干什么 ---me