第三章 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的时候来说。