Dubbo IOC源码分析

蔚落 2023-02-18 14:20 11阅读 0赞

这里我们先回顾以下之前得dubbo实例化对象的过程：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmd4dWVsZWkwMzY_size_16_color_FFFFFF_t_70][]

Dubbo IOC原理  
  熟悉spring的同学应该清楚，在spring的ioc中，例如A中有B属性，那么要注入B，会通过xml或注解指定B的引用，然后在A实例化时，会通过指定的引用实例化B。但是在上面的例子中，在我们创建bird扩展点时，并没有指定friend属性的类型，而是在运行speak方法时，通过url参数指定了friend的类型，这个动作似乎和上一篇文章介绍的自适应扩展点很相似，没错，dubbo的ioc就是通过自适应扩展点来实现的，在创建bird时，他的friend是一个自适应扩展点，然后在运行扩展方法时，才知道具体类型。

简单看个效果:

package org.alexsotob.dubbo.SPI;
    
    import com.alibaba.dubbo.common.URL;
    import com.alibaba.dubbo.common.extension.Adaptive;
    import com.alibaba.dubbo.common.extension.SPI;
    
    @SPI
    public interface Animal {
    
        @Adaptive("friend")
        String getName(URL url);
    
    
    }

package org.alexsotob.dubbo.SPI.impl;
    
    import com.alibaba.dubbo.common.URL;
    import org.alexsotob.dubbo.SPI.Animal;
    
    public class Dog implements Animal {
        private Animal friend;
    
        public Dog() {
            System.out.println("dog init !!!");
        }
    
        public void setFriend(Animal animal){
            this.friend = animal;
        }
    
        @Override
        public String getName(URL url) {
            System.out.println("friend is "+ friend.getName(url));
            return "I am dog";
        }
    
    }

package org.alexsotob.dubbo.SPI.impl;
    
    import com.alibaba.dubbo.common.URL;
    import org.alexsotob.dubbo.SPI.Animal;
    
    
    public class Cat implements Animal {
        public Cat() {
            System.out.println("cat init !!!");
        }
    
        @Override
        public String getName(URL url) {
            return "I am cat";
        }
    
    }

package org.alexsotob.dubbo.SPI;
    
    import com.alibaba.dubbo.common.URL;
    import com.alibaba.dubbo.common.extension.ExtensionLoader;
    import jdk.internal.org.objectweb.asm.ClassReader;
    import sun.misc.ProxyGenerator;
    
    import java.io.IOException;
    import java.util.HashMap;
    import java.util.Map;
    
    public class DubboSPITest {
    
        public static void main(String[] args) throws IOException {
            System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
            ExtensionLoader<Animal> extensionLoader = ExtensionLoader.getExtensionLoader(Animal.class);        //按需获取实现类对象
            Animal dog = extensionLoader.getExtension("dog");
            Map<String,String> map = new HashMap<String,String>();
            map.put("key","cat");
            URL url = new URL("","",1,map);
            System.out.println(dog.getName(url));
        }
    
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmd4dWVsZWkwMzY_size_16_color_FFFFFF_t_70 1][]

先看下入口代码：

private static final ConcurrentMap<Class<?>, Object> EXTENSION_INSTANCES = new ConcurrentHashMap<Class<?>, Object>();
    
    @SuppressWarnings("unchecked")
        private T createExtension(String name) {
            Class<?> clazz = getExtensionClasses().get(name);
            if (clazz == null) {
                throw findException(name);
            }
            try {
                //尝试从缓存中获取对象，如果没有就实例化一个对象并放入缓存
                T instance = (T) EXTENSION_INSTANCES.get(clazz);
                if (instance == null) {
                    EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance());
                    instance = (T) EXTENSION_INSTANCES.get(clazz);
                }
                //进行依赖注入操作
                injectExtension(instance);
                Set<Class<?>> wrapperClasses = cachedWrapperClasses;
                //包装类，装饰器模式 dubbo AOP的实现
                if (wrapperClasses != null && !wrapperClasses.isEmpty()) {
                    for (Class<?> wrapperClass : wrapperClasses) {
                        instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
                    }
                }
                return instance;
            } catch (Throwable t) {
               ...
            }
        }

这里先是通过getExtensionClasses().get(name)拿到一个class对象，getExtensionClasses()方法它最终所赋值的是type扩展的所有实现中，既没有@Adaptive注解，也不包含type类型的构造器(这一类扩展实现我们称之为包装类)的那些实现类，并且被缓存在cachedClasses map中，map的key即为实现类在dubbo spi配置文件中的类名，这里提一个细节，如果在cachedClasses中没有拿到key为name对应的value，这里就会抛出异常，那也就是说，getExtension(name)这种方式，只能用来获取既非@Adaptive注解，又非包装类的那些类的实现，因为只有这样的类才会被缓存在cachedClasses中。这里拿到这个类并实例化一个Instance，然后调用了方法**injectExtension(instance)**，这个方法看名字就知道了，inject既就是注射的意思，这里就将实现dubbo的依赖注入，现在来看这个方法的实现，

private final ExtensionFactory objectFactory;
    ...
    private T injectExtension(T instance) {
            try {
                if (objectFactory != null) {
                    //遍历代码中的所有方法
                    for (Method method : instance.getClass().getMethods()) {
                        //set 开头  入参只有一个 public修饰的代码
                        if (method.getName().startsWith("set")
                                && method.getParameterTypes().length == 1
                                && Modifier.isPublic(method.getModifiers())) {
                            /**
                             * Check {@link DisableInject} to see if we need auto injection for this property
                             */
                            //是否被DisableInject 注解修饰(标识不用注入)
                            if (method.getAnnotation(DisableInject.class) != null) {
                                continue;
                            }
                            //获取入参的class对象
                            Class<?> pt = method.getParameterTypes()[0];
                            try {
                                //截取方法set 后的字符串并将开头进行小写
                                String property = method.getName().length() > 3 ? method.getName().substring(3, 4).toLowerCase() + method.getName().substring(4) : "";
                                //获取扩展类，ExtentionFactory也是dubbo中的一个扩展点
                                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;
        }

把这个class的所有方法都提取出来，然后做了一系列的判断，这就是要通过setter方法为对象注入属性了。被注入的object是通过objectFactory.getExtension(...)得到的，每个extension对象都会有一个objectFactory，objectFactory就是一个AdaptiveExtensionFactory，它的作用是：为dubbo的Ioc提供所有对象。所以这里我们看到，setter方法要注入的属性值，是通过这个扩展的objectFactory拿到的，我们跟进去看一下它的实现，

@Adaptive
    public class AdaptiveExtensionFactory implements ExtensionFactory {
    
        private final List<ExtensionFactory> factories;
    
        ...
        @Override
        public <T> T getExtension(Class<T> type, String name) {
            for (ExtensionFactory factory : factories) {
                T extension = factory.getExtension(type, name);
                if (extension != null) {
                    return extension;
                }
            }
            return null;
        }
    
    }

这里会遍历factories，每个元素都是ExtensionFactory的一个非Adaptive实现，我们在上一篇已经看到了，ExtensionFactory的非Adpative实现，最终被放入factories中的，是SpiExtensionFactory，不过实际上在另外的包里还有一个ExtensionFactory的非Adaptive实现类：SpringExtensionFactory，这里我们不妨把SpiExtensionFactory和SpringExtensionFactory同时拿来分析，可以看到只要这里getExtension(type，name)返回非空，就直接返回所获取的这个值，我们依次看下这两个实现分别是怎么做的，先看SpiExtensionFactory：

/**
     * SpiExtensionFactory
     */
    public class SpiExtensionFactory implements ExtensionFactory {
    
        @Override
        public <T> T getExtension(Class<T> type, String name) {
            if (type.isInterface() && type.isAnnotationPresent(SPI.class)) {
                ExtensionLoader<T> loader = ExtensionLoader.getExtensionLoader(type);
                if (!loader.getSupportedExtensions().isEmpty()) {
                    return loader.getAdaptiveExtension();
                }
            }
            return null;
        }
    
    }

这里判断type是不是@SPI标注的注解，如果是，说明这个type是一个dubbo spi扩展，那么就返回它的一个AdaptiveExtension，它为什么叫SpiExtensionFactory呢？就是获取Spi扩展的一个factory，获取spi扩展的adaptive实现的做法在上一篇里已经讨论过了。也就是说，如果一个扩展实现类中需要注入另一个spi扩展的实现，那就是通过它的objectFactory里的SpiExtensionFactory来获取需要注入的这个扩展的Adaptive实现。

那么如果要注入的对象不是dubbo spi扩展呢，这里不会进入if，就会返回null，我们接下来看SpringExtensionFactory，

public class SpringExtensionFactory implements ExtensionFactory {
        private static final Set<ApplicationContext> contexts = new ConcurrentHashSet<ApplicationContext>();
    
        .....
        @Override
        @SuppressWarnings("unchecked")
        public <T> T getExtension(Class<T> type, String name) {
            //尝试通过名字获取
            for (ApplicationContext context : contexts) {
                if (context.containsBean(name)) {
                    Object bean = context.getBean(name);
                    if (type.isInstance(bean)) {
                        return (T) bean;
                    }
                }
            }
            ......
    
            if (Object.class == type) {
                return null;
            }
            //尝试通过类型获取
            for (ApplicationContext context : contexts) {
                try {
                    return context.getBean(type);
                } catch (...){
                    ...
                }
            }
            ...
            return null;
        }
        ....
    
    }

SpringExtensionFactory就很简单了，直接从spring的ApplicationContext中尝试获取bean，先尝试通过name获取，如果by name失败，再尝试通过by type来获取。也就是说，如果一个扩展实现类中需要注入一个普通对象(非Spi注解的dubbo扩展)，那就通过它的objectFactory里的SpringExtensionFactory来获取这个要被注入的类对象，当然前提是spring容器中已经注入了这个对象。

ok，通过objectFactory提供的对象，我们完成了extension属性的注入，不过createExtension方法所做的并不止这些，我们回到injectExtension的调用处，即createExtension方法的第五行，接着往下看，代码中取了缓存cachedWrapperClasses，这个变量缓存了所有非@Adaptive注解同时包含了带有本扩展类型的构造器方法的那些扩展实现类。实际上从这个缓存的名字里就能看出来，Wrapper意指包装，就是说这里所包含的类都是包装类。

回顾一下代码:

private static final ConcurrentMap<Class<?>, Object> EXTENSION_INSTANCES = new ConcurrentHashMap<Class<?>, Object>();
    
    private Set<Class<?>> cachedWrapperClasses;
    
    @SuppressWarnings("unchecked")
        private T createExtension(String name) {
            Class<?> clazz = getExtensionClasses().get(name);
            if (clazz == null) {
                throw findException(name);
            }
            try {
                //尝试从缓存中获取对象，如果没有就实例化一个对象并放入缓存
                T instance = (T) EXTENSION_INSTANCES.get(clazz);
                if (instance == null) {
                    EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance());
                    instance = (T) EXTENSION_INSTANCES.get(clazz);
                }
                //进行依赖注入操作
                injectExtension(instance);
                Set<Class<?>> wrapperClasses = cachedWrapperClasses;
                //包装类，装饰器模式 dubbo AOP的实现
                if (wrapperClasses != null && !wrapperClasses.isEmpty()) {
                    for (Class<?> wrapperClass : wrapperClasses) {
                        instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
                    }
                }
                return instance;
            } catch (Throwable t) {
               ...
            }
        }

为了解释这行代码，这里必须举一个例子：我们看接口Protocol，

import com.alibaba.dubbo.common.URL;
    import com.alibaba.dubbo.common.extension.Adaptive;
    import com.alibaba.dubbo.common.extension.SPI;
    
    @SPI
    public interface Animal {
    
        String getName();
    
        @Adaptive("type")
        void say(URL url);
    
    }

import com.alibaba.dubbo.common.URL;
    import org.alexsotob.dubbo.SPI.Animal;
    
    public class Dog implements Animal {
        public Dog() {
            System.out.println("dog init !!!");
        }
    
        @Override
        public String getName() {
            return "I am dog";
        }
        @Override
        public void say(URL url) {
            System.out.println("汪汪汪~~~");
        }
    }

import com.alibaba.dubbo.common.URL;
    import org.alexsotob.dubbo.SPI.Animal;
    
    public class AnimalWrapper implements Animal {
        private Animal animal;
    
        public AnimalWrapper(Animal animal) {
            this.animal = animal;
        }
    
        @Override
        public String getName() {
            System.out.println("数据校验");
            String result = animal.getName();
            System.out.println("日志记录");
            return result;
        }
    
        @Override
        public void say(URL url) {
            System.out.println("URL 校验");
            animal.say(url);
            System.out.println("URL 记录");
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmd4dWVsZWkwMzY_size_16_color_FFFFFF_t_70 2][] 注意看wrapper 的构造方法和配置文件中的内容

可以看到，这Dog和AnimalWrapper  两个实现类 都没有被@Adaptive注解，其中AnimalWrapper 有一个私有属性Animal，同时有一个Animal类型作为入参的构造器，所以在类加载之后，这个类都会被放入cachedWrapperClasses缓存中，而Dog 类则既不被@Adaptive注解，也不包含Animal作为入参的构造器，它在类加载之后会被放入cachedClasses中，所以它是可以被通过第二种获取扩展对象的方式获取的

ok，当Animal被注入了属性之后，代码获取了cachedWrapperClasses的值，然后依次取出其中缓存的类，初始化它们，并将当前Dog作为参数传入构造器，同时将返回的Animal 对象 赋值给当前instance。所以，那么执行完上述代码之后，在createExtension方法的最后一行，我们最终获取到的instance将不再是Dog的实例，而是AnimalWrapper的实例，它里面拥有一个animal属性

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmd4dWVsZWkwMzY_size_16_color_FFFFFF_t_70 3][]

最后方法的调用会从包装类向内一步步调用，这也是dubbo实现AOP的方式，基本思想就是 装饰器模式 ，这里把AOP也顺带讲了一些

回顾一下

dubbo IOC 实现机制:

（1）遍历类所有方法，根据判断(①set开头，入参一个，public修饰②没被@disableInject修饰)，找到需要调用注入的方法

（2）获取入参的Class 对象

（3）调用<T> T getExtension(Class<T> type, String name); 获取对象

（4）利用反射机制 方法调用 进行对象注入

对象的加载

*  getExtensionClasses()方法会加载配置文件中配置的该接口的所有实现，并赋值给相应的缓存：
    
     *  接口的所有实现中，要么存在唯一的一个类被@Adaptive注解，要么就动态生成一个Adaptive代理类。这个类被缓存在cachedAdaptiveClass中，我们称之为第一种实现类。
     *  接口的所有实现中，如果存在一些实现，没有被@Adaptive注解，但是包含一个以该接口类型为参数的构造器，称这种类为第二种实现类或包装类，它们被缓存在cachedWrapperClasses中。
     *  剩下的实现类，既不被@Adaptive注解，也不包含特殊的构造器，我们称之为第三种实现类，它们被缓存在cachedClasses中。
 *  getAdaptiveExtension()方法将获得扩展接口的装饰模式的实现类，这个类有且只有一个。
 *  getExtension(name)方法根据配置文件中的类的name来获取扩展实现类，只有第三种实现类能通过这种方式被获取，但是如果该接口有包装类存在，那么此方法获取的永远是被包装的类。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmd4dWVsZWkwMzY_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200618120615770.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmd4dWVsZWkwMzY=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmd4dWVsZWkwMzY_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200619112110301.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmd4dWVsZWkwMzY=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmd4dWVsZWkwMzY_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/2020061910361821.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmd4dWVsZWkwMzY=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmd4dWVsZWkwMzY_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200619104419736.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmd4dWVsZWkwMzY=,size_16,color_FFFFFF,t_70