Dubbo SPI 补充知识点-IOC

在上篇文章中我们提到了创建适配器类的过程

    private T createAdaptiveExtension() {        try {            return injectExtension((T) getAdaptiveExtensionClass().newInstance());
        } catch (Exception e) {            throw new IllegalStateException("Can not create adaptive extension " + type + ", cause: " + e.getMessage(), e);
        }
    }

(T) getAdaptiveExtensionClass().newInstance() 是获取适配器类，然后利用反射进行实例化。他的最外层injectExtension方法，所做的就是Dubbo的IOC,将扩展中的属性进行赋值。接下来我们看一下他的实现

    private T injectExtension(T instance) {        try {            if (objectFactory != null) {                /**
                 * 寻找实例中的所有的方法
                 */
                for (Method method : instance.getClass().getMethods()) {                    /**
                     * 将属性的set方法找出来
                     */
                    if (method.getName().startsWith("set")
                            && method.getParameterTypes().length == 1
                            && Modifier.isPublic(method.getModifiers())) {                        /**
                         * set方法一个参数，所以找到第一个参数
                         *
                         * 例如： public void setPeople(People p){
                         *     this.p=p
                         * }
                         */
                        Class<?> pt = method.getParameterTypes()[0];                        try {                            /**
                             * 获取属性名称 ：people
                             */
                            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) {                                /**
                                 * 利用反射添加进实例中，完成ioc
                                 */
                                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;
    }

所做的操作和我们想的是一直的，遍历出类中所有的方法，寻找其中的set方法，根据方法命名获取到需要从容器内搜索的对象的名称，如果能搜索到，就利用反射进行注入。逻辑很清晰，唯一的疑惑点就是，根据名称和类型搜索相应的对象的逻辑，也就是Object object = objectFactory.getExtension(pt, property);首先我们得知道objectFactory是怎么来的。我们在根据type创建ExtensionLoader时，进行的创建，我们再回顾下

    private ExtensionLoader(Class<?> type) {
        this.type = type;        /**
         * type如果是ExtensionFactory类型，那么objectFactory是null,否则是ExtensionFactory类型的适配器类型
         */
        objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
    }

我们要寻找ExtensionFactory的扩展，发现他的扩展中有个类AdaptiveExtensionFactory上面有@Adaptive的注解，那么最后就是它作为扩展类，也就是objectFactory的实例对象。所以当调用objectFactory.getExtension时其实就是这段代码

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

factories是一个变量，他的填充处就是AdaptiveExtensionFactory的构造方法

 public AdaptiveExtensionFactory() {        /**
         * 找到ExtensionFactory的ExtensionLoader
         */
        ExtensionLoader<ExtensionFactory> loader = ExtensionLoader.getExtensionLoader(ExtensionFactory.class);
        List<ExtensionFactory> list = new ArrayList<ExtensionFactory>();        for (String name : loader.getSupportedExtensions()) {            /**
             * 根据name获取具体的扩展，放到list中
             */
            list.add(loader.getExtension(name));
        }        /**
         * 赋值给factories
         */
        factories = Collections.unmodifiableList(list);
    }

获取ExtensionFactory类型的扩展，出了ExtensionFactory有两个，一个是SpiExtensionFactory，另外一个是SpringExtensionFactory。我们看下他再SPI文件中的声明

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

所以使用的是spi的扩展会起作用，使用的就是SpiExtensionFactory来搜索具体的对象用来依赖注入。下面我们看下SpiExtensionFactory是怎么搜索的。

public class SpiExtensionFactory implements ExtensionFactory {    public <T> T getExtension(Class<T> type, String name) {        if (type.isInterface() && type.isAnnotationPresent(SPI.class)) {
            ExtensionLoader<T> loader = ExtensionLoader.getExtensionLoader(type);            if (!loader.getSupportedExtensions().isEmpty()) {                return loader.getAdaptiveExtension();
            }
        }        return null;
    }

}

判断传入的类型是否加上了@SPI的注解并且是否是个接口，如果是的话，获取此类型的Adaptive扩展。

大家对这个流程是否通畅了呢？

作者：数齐
链接：https://www.jianshu.com/p/0941f0054be9