摘要：屬性上篇文章中，提到在獲取擴展點接口對應的的時候，會執行私有構造函數。因為此時是，即當為時，即我們可以看出，所有非擴展點接口都會執行對應的實例的方法返回一個實例，即對象。

拿到applicationContext，就可以調用getBean方法來獲得Spring的bean對象了

public class SpringContextUtil implements ApplicationContextAware {  
    // Spring應用上下文環境  
    private static ApplicationContext applicationContext;  
    /** 
     * 實現ApplicationContextAware接口的回調方法，設置上下文環境 
     *  
     * @param applicationContext 
     */  
    public void setApplicationContext(ApplicationContext applicationContext) {  
        SpringContextUtil.applicationContext = applicationContext;  
    }  
    /** 
     * @return ApplicationContext 
     */  
    public static ApplicationContext getApplicationContext() {  
        return applicationContext;  
    }  
    /** 
     * 獲取對象 
     *  
     * @param name 
     * @return Object
     * @throws BeansException 
     */  
    public static Object getBean(String name) throws BeansException {  
        return applicationContext.getBean(name);  
    }  
}

第一點 在講解ExtensionLoader源碼的構造函數的時候，我們說過，每一個ExtensionLoader實例都有一個 objectFactory 屬性，他是實現Ioc的關鍵；

第二點 相比較于JDK的SPI機制，dubbo的SPI機制支持擴展通過setter的方式來注入其他擴展點。

第三點 在調用ExtensionLoader的getExtension方法時，在獲取了相應的class并創建了instance之后，通過injectExtension(intance)方法來通過setter的方式來注入其他擴展點。

第四點 loadFile函數解析SPI配置時，假如這個類帶@Adaptive注解，緩存到cachedAdaptiveClass。

關鍵說明，

獲取instance的所有方法，并解析以set方法開頭的方法,例如setXxyy(Xxyy xxyy)。

拿到set方法的入參類型Xxyy、屬性名xxyy。

執行objectFactory.getExtension(pt, property)拿到Xxyy對應的實例。

通過反射執行set方法，注入Xxyy對象。

    private T injectExtension(T instance) {
        try {
            if (objectFactory != null) {
                for (Method method : instance.getClass().getMethods()) {
                    if (method.getName().startsWith("set")
                            && method.getParameterTypes().length == 1
                            && Modifier.isPublic(method.getModifiers())) {
                        Class pt = method.getParameterTypes()[0];
                        try {
                            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) {
                                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;
    }

通過上面的方法，就可以將屬性注入到instance中，實現自動裝配(IOC)。下面我們來看一下 objectFactory.getExtension(pt, property)是如何工作的。

上篇文章中，提到在獲取Container擴展點接口對應的ExtensionLoader的時候，會執行私有ExtensionLoader構造函數。

    private ExtensionLoader(Class type) {
        this.type = type;
        objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
    }

因為此時type是Container.class，即objectFactory = ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension();
當type為ExtensionFactory.class時，即 objectFactory = null.
我們可以看出，所有非ExtensionFactory.class擴展點接口都會執行ExtensionFactory對應的ExtensionLoader實例的getAdaptiveExtension()方法返回一個ExtensionFactory實例，即objectFactory對象。否則，objectFactory對象為null。

getAdaptiveExtension 獲取帶有Adaptive注解的擴展實現類

createAdaptiveExtension()創建實例

injectExtension() 自動注入IOC

getAdaptiveExtensionClass() ---執行cachedAdaptiveClass對象的構造函數

getExtensionClasses() ---解析所有的擴展點實現

loadExtensionClasses() ---加載擴展類

loadFile() --- 從固定的文件路徑，解析加載對應的擴展點實現【上一篇已經說過，這個地方會加載幾種情形的擴展實現類，包括拿到cachedAdaptiveClass對象】

返回cachedAdaptiveClass --- 返回loadFile()方法中構造的cachedAdaptiveClass對象

執行 cachedAdaptiveClass.newInstance() ---執行AdaptiveExtensionFactory的構造函數

ExtensionFactory的實現類AdaptiveExtensionFactory帶有Adaptive標簽，另外兩個實現類SpiExtensionFactory、SpringExtensionFactory就是正常的實現類，也是我們見的最多的那種擴展點實現類。

### AdaptiveExtensionFactory源碼
關鍵說明，
1. factories屬性，所有的非@Adaptive類的ExtensionFactory實例的集合，以后所有與ExtensionFactory打交道的操作都交給AdaptiveExtensionFactory，
2. injectExtension方法中，調用的 Object object = objectFactory.getExtension(pt, property);分別調用SpiExtensionFactory、SpringExtensionFactory兩個實際的實現類。
/**
 * AdaptiveExtensionFactory
 *
 * @author william.liangf
 */
@Adaptive
public class AdaptiveExtensionFactory implements ExtensionFactory {

    //所有的非@Adaptive類的ExtensionFactory實例的集合
    private final List factories;

    //因為ExtensionFactory對應的ExtensionLoader實例中緩存字段已經初始化好了，所以的ExtensionLoader的操作大都是從緩存中獲取的數據
    public AdaptiveExtensionFactory() {
        //從緩存的static變量EXTENSION_LOADERS中拿到ExtensionFactory對應的ExtensionLoader實例
        ExtensionLoader loader = ExtensionLoader.getExtensionLoader(ExtensionFactory.class);
        List list = new ArrayList();
        //拿到loader中加載的普通的SPI擴展接口實現類的名稱，spring與spi
        // adaptive=com.alibaba.dubbo.common.extension.factory.AdaptiveExtensionFactory
        // spi=com.alibaba.dubbo.common.extension.factory.SpiExtensionFactory
        for (String name : loader.getSupportedExtensions()) {
            //根據名稱創建對應的ExtensionFactory實例
            list.add(loader.getExtension(name));
        }
        factories = Collections.unmodifiableList(list);
    }

    public  T getExtension(Class type, String name) {
        for (ExtensionFactory factory : factories) {
            T extension = factory.getExtension(type, name);
            if (extension != null) {
                return extension;
            }
        }
        return null;
    }

}

public class SpringExtensionFactory implements ExtensionFactory {

    private static final Set contexts = new ConcurrentHashSet();

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

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

    @SuppressWarnings("unchecked")
    public  T getExtension(Class 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;
    }

}

是不是有一點熟悉的味道了啊，這也算是一個首尾呼應吧~

這一篇到時很快就寫完了~ 下篇文章會講解擴展點是如何實現AOP的。