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

1 createAdaptiveExtension()
2 --injectExtension((T) getAdaptiveExtensionClass().newInstance()) //為創建好的AdaptiveExtensionClass實例進行屬性註入
3 
4 createExtension(String name)
5 --injectExtension(instance) //為創建好的Extension實例進行屬性註入
6 --injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance)) //
 
為創建好的wrapperClass實例進行屬性註入

來看一下源碼：

 1     /**
 2      * dubbo-IOC的核心
 3      */
 4     private T injectExtension(T instance) {
 5         try {
 6             if (objectFactory != null) {
 7                 for (Method method : instance.getClass().getMethods()) {
 8                     if (method.getName().startsWith("set") && method.getParameterTypes().length == 1
 9
 
                         && Modifier.isPublic(method.getModifiers())) {//一個參數的public的setXXX(T param)方法.例如,setName(String name)
10                         Class<?> pt = method.getParameterTypes()[0];//參數param的類型T,eg.String
11                         try {
12                             String property = method.getName().length() > 3
13
 
                                 ? method.getName().substring(3, 4).toLowerCase() + method.getName().substring(4) : "";//獲取屬性名XXX, eg.name
14                             Object object = objectFactory.getExtension(pt, property);//實例化參數
15                             if (object != null) {
16                                 //執行instance.method(object)方法,這裏就是執行instance的setter方法,進行setter註入
17                                 method.invoke(instance, object);
18                             }
19                         } catch (Exception e) {
20                             logger.error("fail to inject via method " + method.getName() + " of interface "
21                                          + type.getName() + ": " + e.getMessage(),
22                                 e);
23                         }
24                     }
25                 }
26             }
27         } catch (Exception e) {
28             logger.error(e.getMessage(), e);
29         }
30         return instance;
31     }

整個方法的作用就是通過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實例]。

看一下源碼：

 1     private final List<ExtensionFactory> factories;
 2 
 3     public <T> T getExtension(Class<T> type, String name) {
 4         /**
 5          * 先調用SpiExtensionFactory來實例化;
 6          * 如果不行,再使用SpringExtensionFactory來實例化
 7          */
 8         for (ExtensionFactory factory : factories) {
 9             T extension = factory.getExtension(type, name);
10             if (extension != null) {
11                 return extension;
12             }
13         }
14         return null;
15     }

看一下SpiExtensionFactory的源碼：

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

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

看一下SpringExtensionFactory的源碼：

 1 public class SpringExtensionFactory implements ExtensionFactory {
 2     private static final Set<ApplicationContext> contexts = new ConcurrentHashSet<ApplicationContext>();
 3     
 4     public static void addApplicationContext(ApplicationContext context) {
 5         contexts.add(context);
 6     }
 7 
 8     public static void removeApplicationContext(ApplicationContext context) {
 9         contexts.remove(context);
10     }
11 
12     @SuppressWarnings("unchecked")
13     public <T> T getExtension(Class<T> type, String name) {
14         for (ApplicationContext context : contexts) {
15             if (context.containsBean(name)) {//該context是否包含name的bean
16                 Object bean = context.getBean(name);//獲取name的bean,如果是懶加載或多例的bean,此時會實例化name的bean
17                 if (type.isInstance(bean)) {//如果obj的類型是type或其子類,與instanceof相同
18                     return (T) bean;
19                 }
20             }
21         }
22         return null;
23     }
24 }

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

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