dubbo-探索之旅(3)-ExtensionFactory

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

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

ExtensionFactory类关系如下：

dubbo-探索之旅(3)-ExtensionFactory

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容器中去获取。后面专门研究一个dubbo的spring结合。

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

dubbo-探索之旅(3)-ExtensionFactory

相关推荐