05-dubbo SPI机制源码分析

开头

上节主要写了dubbo spi的基本和高级应用，核心功能是实现了类似spring的依赖注入和AOP功能，这节将结合dubbo spi源码来分析实现原理

总流程

image.png

调用代码

ExtensionLoader<Person> extensionLoader = ExtensionLoader.getExtensionLoader(Person.class);
        Person person = extensionLoader.getExtension("black");  // BlackPerson

        URL url = new URL("x", "localhost", 8080);
        url = url.addParameter("car", "black");
        Car car = person.getCar();
        String carName = car.getCarName(url);
        System.out.println(carName);  // 代理逻辑

1.初始化扩展点加载器

总入口为ExtensionLoader.getExtensionLoader，这个方法其实没什么，就是初始化dubbo的扩展点加载器

 public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
        if (type == null) {
            throw new IllegalArgumentException("Extension type == null");
        }
        if (!type.isInterface()) {
            throw new IllegalArgumentException("Extension type (" + type + ") is not an interface!");
        }
        if (!withExtensionAnnotation(type)) {
            throw new IllegalArgumentException("Extension type (" + type +
                    ") is not an extension, because it is NOT annotated with @" + SPI.class.getSimpleName() + "!");
        }

        ExtensionLoader<T> loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
        if (loader == null) {
            EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));
            loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
        }
        return loader;
    }

2.通过key获取对象

 Person person = extensionLoader.getExtension("black");  // BlackPerson

这个方法很重要，直接进入到createExtension方法

public T getExtension(String name) {
        if (StringUtils.isEmpty(name)) {
            throw new IllegalArgumentException("Extension name == null");
        }
        // 获取默认扩展类
        if ("true".equals(name)) {
            return getDefaultExtension();
        }

        final Holder<Object> holder = getOrCreateHolder(name);
        Object instance = holder.get();

        // 如果有两个线程同时来获取同一个name的扩展点对象，那只会有一个线程会进行创建
        if (instance == null) {
            synchronized (holder) { // 一个name对应一把锁
                instance = holder.get();
                if (instance == null) {
                    // 创建扩展点实例对象
                    instance = createExtension(name);   // 创建扩展点对象
                    holder.set(instance);
                }
            }
        }
        return (T) instance;
    }

3.获取资源文件，加载成extensionClasses

在createExtension.getExtensionClasses().loadExtensionClasses()中，将符合格式要求目录下的配置文件都加载为extensionClasses的map中

private Map<String, Class<?>> loadExtensionClasses() {
        // cache接口默认的扩展类
        cacheDefaultExtensionName();

        Map<String, Class<?>> extensionClasses = new HashMap<>();
        loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY, type.getName());
        loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));
        loadDirectory(extensionClasses, DUBBO_DIRECTORY, type.getName());
        loadDirectory(extensionClasses, DUBBO_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));
        loadDirectory(extensionClasses, SERVICES_DIRECTORY, type.getName());
        loadDirectory(extensionClasses, SERVICES_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));
        return extensionClasses;
    }

1.如果当前接口手动指定了Adaptive类，加载
2.如果是一个Wrapper类，加到全局的warpper map中，为第4步AOP做准备

private void loadClass(Map<String, Class<?>> extensionClasses, java.net.URL resourceURL, Class<?> clazz, String name) throws NoSuchMethodException {
        if (!type.isAssignableFrom(clazz)) {
            throw new IllegalStateException("Error occurred when loading extension class (interface: " +
                    type + ", class line: " + clazz.getName() + "), class "
                    + clazz.getName() + " is not subtype of interface.");
        }
        // 当前接口手动指定了Adaptive类
        if (clazz.isAnnotationPresent(Adaptive.class)) {
            cacheAdaptiveClass(clazz);
        } else if (isWrapperClass(clazz)) {
            // 是一个Wrapper类
            cacheWrapperClass(clazz);
        } else {
            ...
    }

4.创建扩展点对象-依赖注入

在3步骤中，将配置文件转换成了clazz,调用injectExtension(instance);开始依赖注入，这个方法很重要，主要是做了下面几件事

1.如果当前的bean中依赖其他对象，比如person对象依赖car接口，会遍历person的set方法，利用setter方法注入，比如得到setCar中的car
2.调用AdaptiveExtensionFactory.getExtension("car")
3.判断接口是否存在@SPI注解，调用SpiExtensionFactory.getExtension("car")，
4.初始化依赖对象扩展点加载器，调用ExtensionLoader.getExtensionLoader(type)
5.调用4步骤加载器loader.getAdaptiveExtension()，先生成接口的AdaptiveCompiler类（代理对象），至于具体是哪个实现类，这里还不知道，后面由开发者指定url，就可以获取具体的对象实现类

5.创建代理对象-AOP

这里是AOP生成代理对象，cachedWrapperClasses就是在3步骤中获取的，根据代理的对象key生成一个代理对象
通过生成代码code，生成代理对象执行AdaptiveCompiler.compile方法，最终生成一个Car$Adaptive对象，对象的代码如下图
所以最终返回的实例实际是一个carWrapper对象

 // AOP
            Set<Class<?>> wrapperClasses = cachedWrapperClasses;
            if (CollectionUtils.isNotEmpty(wrapperClasses)) {
                for (Class<?> wrapperClass : wrapperClasses) {
                    instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
                }
            }

image.png

6.最终执行总结

person.getCar=blacpersion.CarAdaptive-执行上面的代理方法，该方法传入black后，执行AOP逻辑，最终返回了carWrapper实例，所以最终执行的是CarWrapper.getName方法