第三章 dubbo內核之ioc源碼解析

dubbo的IOC具體實現在：T injectExtension(T instance)方法中。該方法只在三個地方被使用：

createAdaptiveExtension()
--injectExtension((T) getAdaptiveExtensionClass().newInstance()) //為創建好的AdaptiveExtensionClass實例進行屬性注入

createExtension(String name)
--injectExtension(instance) //為創建好的Extension實例進行屬性注入
--injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance)) //為創建好的wrapperClass實例進行屬性注入

來看一下源碼：

    /**
     * dubbo-IOC的核心
     */
    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())) {//一個參數的public的setXXX(T param)方法.例如,setName(String name)
                        Class<?> pt = method.getParameterTypes()[0];//參數param的類型T,eg.String
                        try {
                            String property = method.getName().length() > 3
                                ? method.getName().substring(3, 4).toLowerCase() + method.getName().substring(4) : "";//獲取屬性名XXX, eg.name
                            Object object = objectFactory.getExtension(pt, property);//實例化參數
                            if (object != null) {
                                //執行instance.method(object)方法,這里就是執行instance的setter方法,進行setter注入
                                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對象實例的setter方法為instance的屬性賦值，完成setter注入，即IOC的最經典的注入方式。

詳細步驟：

• 獲取instance的setter方法，通過setter方法獲取屬性名稱property和屬性類型pt（即paramType的簡寫）
• 使用objectFactory創建一個property名稱（類型為pt）的對象實例
• 執行instance的setter方法，注入property實例

其中，比較重要的就是：Object object = objectFactory.getExtension(pt, property);這個方法。其中的objectFactory=AdaptiveExtensionFactory實例，其屬性factories = [SpringExtensionFactory實例, SpiExtensionFactory實例]。

看一下源碼：

    private final List<ExtensionFactory> factories;

    public <T> T getExtension(Class<T> type, String name) {
        /**
         * 先調用SpiExtensionFactory來實例化;
         * 如果不行,再使用SpringExtensionFactory來實例化
         */
        for (ExtensionFactory factory : factories) {
            T extension = factory.getExtension(type, name);
            if (extension != null) {
                return extension;
            }
        }
        return null;
    }

看一下SpiExtensionFactory的源碼：

public class SpiExtensionFactory implements ExtensionFactory {
    public <T> T getExtension(Class<T> type, String name) {
        if (type.isInterface() && type.isAnnotationPresent(SPI.class)) {//type是接口且必須具有@SPI注解
            ExtensionLoader<T> loader = ExtensionLoader.getExtensionLoader(type);
            if (loader.getSupportedExtensions().size() > 0) {//獲取type的所有ExtensionClasses實現的key
                return loader.getAdaptiveExtension();//獲取type的裝飾類,如果有@Adaptive注解的類,則返回該類的實例,否則返回一個動態代理類的實例(例如Protocol$Adpative的實例)
            }
        }
        return null;
    }
}

從這里我們可以看出dubbo-SPI的另外一個好處：可以為SPI實現類注入SPI的裝飾類或動態代理類。

看一下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)) {//該context是否包含name的bean
                Object bean = context.getBean(name);//獲取name的bean,如果是懶加載或多例的bean,此時會實例化name的bean
                if (type.isInstance(bean)) {//如果obj的類型是type或其子類,與instanceof相同
                    return (T) bean;
                }
            }
        }
        return null;
    }
}

至此，IOC就干完了。但是有一個遺留問題，ApplicationContext是什么時候加入到contexts中呢？當講解ServiceBean的時候來說。