dubbo-探索之旅(三)---ExtensionFactory

上一节比较全面的了解了dubbo里面是怎么对JAVA的SPI机制进行扩展的。理解了这个很重要，因为dubbo里面很多的实现都和扩展SPI机制有关。比如今天我看的ExtensionFactory


上一节谈到ExtensionLoader在加载扩展实现的时候内部实现了个简单的ioc机制，来实现对扩展实现所依赖的参数的注入。对扩展实现中公有的set方法且入参个数为一个的方法，尝试从工厂中获取值注入到扩展实现中去。来实现动态注入，这个工厂就是我们的ExtensionFactory对象。

ExtensionFactory类关系如下：

[img]http://dl2.iteye.com/upload/attachment/0120/9274/2b5cbb96-2a18-34f7-9340-4ee549f62527.png[/img]


AdaptiveExtensionFactory类，一个适配类(被@Adaptive修饰)。它包含了ExtensionFactory所有的实现类。dubbo默认：
spring=com.alibaba.dubbo.config.spring.extension.SpringExtensionFactory
adaptive=com.alibaba.dubbo.common.extension.factory.AdaptiveExtensionFactory
spi=com.alibaba.dubbo.common.extension.factory.SpiExtensionFactory

工厂的默认实现类是：SpringExtensionFactory和SpiExtensionFactory

SpiExtensionFactory类
根据Class<T> type参数获取扩展点的适配类。

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().size() > 0) {
                return loader.getAdaptiveExtension();
            }
        }
        return null;
    }

}

SpringExtensionFactory类

public class SpringExtensionFactory implements ExtensionFactory {

    private static final Set<ApplicationContext> contexts = new ConcurrentHashSet<ApplicationContext>();

    public static void addApplicationContext(ApplicationContext context) {
        contexts.add(context);
    }

    public static void removeApplicationContext(ApplicationContext context) {
        contexts.remove(context);
    }

    @SuppressWarnings("unchecked")
    public <T> T getExtension(Class<T> type, String name) {
        for (ApplicationContext context : contexts) {
            if (context.containsBean(name)) {
                Object bean = context.getBean(name);
                if (type.isInstance(bean)) {
                    return (T) bean;
                }
            }
        }
        return null;
    }

}

和Spring结合，在Spring容器中去获取。[color=red]后面专门研究一个dubbo的spring结合[/color]。

AdaptiveExtensionFactory类：
适配类的getExtension(Class<T> type, String name)方法，调用每个Factory类的getExtension方法来获取扩展点对象。

@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的实现
            list.add(loader.getExtension(name));
        }
        factories = Collections.unmodifiableList(list);
    }

    public <T> T getExtension(Class<T> type, String name) {
        // 依次遍历各个ExtensionFactory实现的getExtension方法，一旦获取到Extension即返回
        // 如果遍历完所有的ExtensionFactory实现均无法找到Extension,则返回null
        for (ExtensionFactory factory : factories) {
            T extension = factory.getExtension(type, name);
            if (extension != null) {
                return extension;
            }
        }
        return null;
    }

}

现在回过头来看ExtensionLoader类中的injectExtension方法中的这句代码：
Object object = objectFactory.getExtension(pt, property);获取property对应的实现类。通过： method.invoke(instance, object);实现动态注入。


下一节，我想看看Compiler