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