dubbo源码之-ExtensionInjector

org.apache.dubbo.common.extension.ExtensionLoader#injectExtension

private T injectExtension(T instance) {
        if (injector == null) {
            return instance;
        }

        try {
            //获取当前对象的当前类的所有方法
            for (Method method : instance.getClass().getMethods()) {
                //是否为set方法 不是的话则跳过,在这里合法的set方法满足3个条件:
                //set开头,参数只有一个,public修饰
                if (!isSetter(method)) {
                    continue;
                }
                /**
                 * Check {@link DisableInject} to see if we need auto-injection for this property
                 */
                //方法上面是否有注解DisableInject修饰,这种情况也直接跳过
                if (method.isAnnotationPresent(DisableInject.class)) {
                    continue;
                }

                // When spiXXX implements ScopeModelAware, ExtensionAccessorAware,
                // the setXXX of ScopeModelAware and ExtensionAccessorAware does not need to be injected
                if (method.getDeclaringClass() == ScopeModelAware.class) {
                    continue;
                }
                if (instance instanceof ScopeModelAware || instance instanceof ExtensionAccessorAware) {
                    if (ignoredInjectMethodsDesc.contains(ReflectUtils.getDesc(method))) {
                        continue;
                    }
                }

                Class> pt = method.getParameterTypes()[0];
                //方法的参数如果是原生类型也跳过
                if (ReflectUtils.isPrimitives(pt)) {
                    continue;
                }

                try {
                    //获取set方法对应的成员变量如setProtocol 属性为protocol
                    String property = getSetterProperty(method);
                    //根据参数类型如Protocol和属性名字如protocol获取应该注入的对象
                    Object object = injector.getInstance(pt, property);
                    if (object != null) {
                        //执行对应对象和对应参数的这个方法
                        method.invoke(instance, object);
                    }
                } catch (Exception e) {
                    logger.error(COMMON_ERROR_LOAD_EXTENSION, "", "",
                        "Failed to inject via method " + method.getName() + " of interface " + type.getName() + ": " + e.getMessage(),
                        e);
                }
            }
        } catch (Exception e) {
            logger.error(COMMON_ERROR_LOAD_EXTENSION, "", "", e.getMessage(), e);
        }
        return instance;
    }

Object object = injector.getInstance(pt, property);

//如果当前扩展类型为扩展注入器类型则设置当前注入器变量为空,否则的话获取一个扩展注入器扩展对象
        //1)这里有个type为空的判断,普通的扩展类型肯定不是ExtensionInjector类型 这里必定会为每个非扩展注入ExtensionInjector类型创建一个ExtensionInjector类型的扩展对象,
//2) 这里代码会走extensionDirector.getExtensionLoader(ExtensionInjector.class),这个代码会创建一个为ExtensionInjector扩展对象的加载器对象ExtensionLoader
//3) getAdaptiveExtension() 这个方法就是通过扩展加载器获取具体的扩展对象的方法我们会详细说
this.injector = (type == ExtensionInjector.class ?null : extensionDirector.getExtensionLoader(ExtensionInjector.class).getAdaptiveExtension());

@Override
    public void initialize() throws IllegalStateException {
        ExtensionLoader loader = extensionAccessor.getExtensionLoader(ExtensionInjector.class);
        injectors = loader.getSupportedExtensions().stream()
            .map(loader::getExtension)
            .collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));
        //collectingAndThen 去重操作
    }

//可以看到上面代码按扩展注入器顺序来遍历的第一个找到的对象就直接返回了,
    //这个AdaptiveExtensionInjector在初始化的时候会获取所有的ExtensionInjector的扩展,非自适应的,它本身自适应的扩展,
    // 这里会获取非自适应的扩展列表一共有3个按顺序为:
    //ScopeBeanExtensionInjector
    //SpiExtensionInjector
    //SpringExtensionInjector
    @Override
    public  T getInstance(final Class type, final String name) {
        //遍历所有的扩展注入器,如果可以获取到扩展对象则直接返回
        return injectors.stream()
            .map(injector -> injector.getInstance(type, name))
            .filter(Objects::nonNull)
            .findFirst()
            .orElse(null);
    }

@Override
    public  T getInstance(final Class type, final String name) {
        //如果是一个标准的被@SPI注解修饰的扩展接口则满足条件
        if (!type.isInterface() || !type.isAnnotationPresent(SPI.class)) {
            return null;
        }
        //使用扩展访问器来获取对应类型的扩展加载器
        ExtensionLoader loader = extensionAccessor.getExtensionLoader(type);
        if (loader == null) {
            return null;
        }
        //使用对应类型的扩展加载器来加载自适应扩展 这个加载的扩展可以参考4.4.6小节
        if (!loader.getSupportedExtensions().isEmpty()) {
            return loader.getAdaptiveExtension();
        }
        return null;
    }