dubbo源码解析（3） dubbo的ioc和aop

前两篇文章我们分析了dubbo的spi，这一篇文章我们将分析dubbo另外两个内核，ioc和aop

dubbo的ioc主要是Extensionloader#injectExtension(T instance)

private T injectExtension(T instance) {
    try {
        if (objectFactory != null) {
            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 {
                        String property = getSetterProperty(method);
                        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;
}

首先会判断objectfactory是不是为空，我们在第一篇就说过只要Extensionloader不是ExtensionFactory类型的，那么这个objectfactory就是adaptiveFactory，adaptiveFactory有一个属性List<ExtensionFactory> 这里面装的是

SpiExtensionFactory和SpringExtensionFactory

for (Method method : instance.getClass().getMethods())会遍历instance中的所有的方法，找到public的并且参数是一个的set方法 

获取参数类型和set的属性名称调用adptiveExtensionFactory#getExtension方法

public <T> T getExtension(Class<T> type, String name) {
    Iterator i$ = this.factories.iterator();

    Object extension;
    do {
        if (!i$.hasNext()) {
            return null;
        }

        ExtensionFactory factory = (ExtensionFactory)i$.next();
        extension = factory.getExtension(type, name);
    } while(extension == null);

    return extension;
}

这个方法就是遍历adptiveExtensionFactory中的List<ExtensionFactory>

我们首先看SpiExtensionFactory

public class SpiExtensionFactory implements ExtensionFactory {

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

}

首先判断type有没有SPI注解，然后获取一个Extensionloader.然后判断条件如果符合就会返回一个AdaptiveExtension

至于这个adaptiveExtension，我们再回顾下上一篇

Extensionloader#getAdaptiveExtension();

如果扩展点的实现类上有@Adaptive注解就直接返回这个实现类（最多是一个），如果没有就动态创建一个xxxx$Adaptive

再看SpringExtensionFactory

public <T> T getExtension(Class<T> type, String name) {
    Iterator i$ = contexts.iterator();

    while(i$.hasNext()) {
        ApplicationContext context = (ApplicationContext)i$.next();
        if (context.containsBean(name)) {
            Object bean = context.getBean(name);
            if (type.isInstance(bean)) {
                return bean;
            }
        }
    }

    return null;
}

这个代码非常熟悉，就是从spring的上下文中获取到这个bean，然后返回

总结来说，adaptiveExtensionFactyory#getExtension就是从dubbo的spi或者spring的ioc容器中获取第一个不为0的bean

回到injectExtension方法

method.invoke(instance, object);就是利用反射调用instance的set方法

以上就是dubbo的ioc

接下去说dubbo的aop

Set<Class<?>> wrapperClasses = this.cachedWrapperClasses;
Class wrapperClass;
if (wrapperClasses != null && wrapperClasses.size() > 0) {
    for(Iterator i$ = wrapperClasses.iterator(); i$.hasNext(); instance = this.injectExtension(wrapperClass.getConstructor(this.type).newInstance(instance))) {
        wrapperClass = (Class)i$.next();
    }
}

在Extensionloader#createExtension中

Set<Class<?>> wrapperClasses = this.cachedWrapperClasses;

cachedWrapperClasses中装的是没有@Adaptive注解，并且构造函数只有一个type参数的类，比如

ProtocolFilterWrapper 和ProtocolListenerWrapper

代码在Extensionloader#loadFile中

instance = this.injectExtension(wrapperClass.getConstructor(this.type).newInstance(instance))

这句话就用利用反射创建instance的一个代理类，这就是dubbo的aop，是不是非常简单，因为injectExtension我们在ioc中已经分析过了，这边就不再分析了。

本篇结束，下一篇我们将分析dubbo的最后一个内核，compiler