Dubbo源码手记-SPI机制之AOP

　　Dubbo作为目前业界首屈一指的RPC框架，其根本之一在于其强大的自适应扩展机制。谈到Dubbo的自适应扩展机制，就离不开一个重要的组件SPI。SPI实现两大重要的架构基础能力。其中之一就是AOP，这个能力为Dubbo的Inverker调用链提供了稳定的生态。来上Demo：

比方说，我们现在有Car这样一个接口：（这里SPI注解是启动DubboSpi机制所必须的）

@SPI
public interface Car {
    void run();
}

对应奥迪、奔驰两个实现类：

public class Audi implements Car {
    @Override
    public void run() {
        System.out.println("Audi Run");
    }
}

public class Benz implements Car {
    @Override
    public void run() {
        System.out.println("Benz Run");
    }
}

对应的/resources/META-INF/dubbo/internal/com.luban.dubbo_spi.Car的配置为：

audi=com.luban.dubbo_spi.car.Audi
benz=com.luban.dubbo_spi.car.Benz

测试类：

ExtensionLoader<Car> carLoader = ExtensionLoader.getExtensionLoader(Car.class);
Car benz = carLoader.getExtension("benz");
benz.run();
Car audi = carLoader.getExtension("audi");
audi.run();

打印结果:

Benz Run
Audi Run

如果说我们现在要对所有的Car实现类进行统一的前置功能增强、后置功能增强。也就是说增加若干个个切面。比方说我们增加，点火/熄火、启动检查/熄火检查 两个切面。

public class CarFireWrapper implements Car {
    private Car car;
    // 这里的构造器是必须的，否则无法加入该切面
    public CarFireWrapper(Car car) {
        this.car = car;
    }
    @Override
    public void run() {
        System.out.println("点火");
        car.run();
        System.out.println("熄火");
    }
}

public class CarCheckWrapper implements Car {
    private Car car;
    public CarCheckWrapper(Car car) {
        this.car = car;
    }
    @Override
    public void run() {
        System.out.println("电子控制系统启动检查");
        car.run();
        System.out.println("电子控制系统关闭检查");
    }
}

并添加到com.luban.dubbo_spi.Car：

audi=com.luban.dubbo_spi.car.Audi
benz=com.luban.dubbo_spi.car.Benz
com.luban.dubbo_spi.car.CarFireWrapper
com.luban.dubbo_spi.car.CarCheckWrapper

重新执行测试方法：

点火
电子控制系统启动检查
Benz Run
电子控制系统关闭检查
熄火
----
点火
电子控制系统启动检查
Audi Run
电子控制系统关闭检查
熄火

如此，切面业务已经加入进来了。关于org.apache.dubbo.common.extension.ExtensionLoader#objectFactory属性的初始化，这里先不讲。来上Dubbo源代码，看下com.luban.dubbo_spi.Car的读取以及对象生成：

以上边的测试用例为例，首先在执行这一行 carLoader..getExtension("benz") 代码的时候，因为首次调用，所以Car接口所有的实现类尚未被Dubbo缓存，所以会调用到getExtension方法的第18行。

public T getExtension(String name) {
        if (StringUtils.isEmpty(name)) {
            throw new IllegalArgumentException("Extension name == null");
        }
        if ("true".equals(name)) {
            return getDefaultExtension();
        }
        Holder<Object> holder = cachedInstances.get(name);
        if (holder == null) {
            cachedInstances.putIfAbsent(name, new Holder<Object>());
            holder = cachedInstances.get(name);
        }
        Object instance = holder.get();
        if (instance == null) {
            synchronized (holder) {
                instance = holder.get();
                if (instance == null) {
                    instance = createExtension(name);
                    holder.set(instance);
                }
            }
        }
        return (T) instance;
    }

即，读取com.luban.dubbo_spi.Car文件来创建Car的实现类。

private T createExtension(String name) {
        Class<?> clazz = getExtensionClasses().get(name);
...

我们直接取看createExtension方法的第二行，

private Map<String, Class<?>> loadExtensionClasses() {
        final SPI defaultAnnotation = type.getAnnotation(SPI.class);
        // SPI后面的值就是默认的实现的类，只能指定一个实现类
        if (defaultAnnotation != null) {
            String value = defaultAnnotation.value();
            if ((value = value.trim()).length() > 0) {
                String[] names = NAME_SEPARATOR.split(value);
                if (names.length > 1) {
                    throw new IllegalStateException("more than 1 default extension name on extension " + type.getName()
                            + ": " + Arrays.toString(names));
                }
                if (names.length == 1) {
                    cachedDefaultName = names[0];
                }
            }
        }

        // 是一个map，key是别名，value是具体的实现类
        // 会从不同的地方寻找接口的所有实现类，这就是扩展的实现
        // 主要会从三个地方找，1. dubbo内部提供的
        // META-INF/dubbo/
        // META-INF/dubbo/internal/
        // META-INF/services/
        Map<String, Class<?>> extensionClasses = new HashMap<String, Class<?>>();
        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;
}

从loadExtentsionClasses方法的第二行看一看出，Car接口的SPI注解支持设定一个默认的实现，用字符串标识。同com.luban.dubbo_spi.Car文件的key值。从上边的逻辑来看，第25行到第30行就是将不同位置的配置文件读取成Car的实现类，或者切面类。而且放到一个Map里边，自然而然能想到，这里是存在不同位置配置文件的覆盖关系的，即配置文件的位置具有优先级。即：

META-INF/services/ > META-INF/dubbo/internal/ > META-INF/dubbo/

上边的方法进一步会通过反射创建Car的实现类以及切面类，进而进入下边逻辑：

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 when load extension class(interface: " +
                    type + ", class line: " + clazz.getName() + "), class "
                    + clazz.getName() + "is not subtype of interface.");
        }
        // 实现类上是否有Adaptive注解，这段代码的意思就是一个接口的实现类中只有一个Adaptive
        if (clazz.isAnnotationPresent(Adaptive.class)) {
            if (cachedAdaptiveClass == null) {
                cachedAdaptiveClass = clazz;
            } else if (!cachedAdaptiveClass.equals(clazz)) {
                throw new IllegalStateException("More than 1 adaptive class found: "
                        + cachedAdaptiveClass.getClass().getName()
                        + ", " + clazz.getClass().getName());
            }
        } else if (isWrapperClass(clazz)) { // 实现类是不是wrapper类，判断逻辑是这个实现类的构造方法的参数是不是有且仅有一个参数，且参数类型是接口类型
            // wrapper类可以有多个
            Set<Class<?>> wrappers = cachedWrapperClasses;
            if (wrappers == null) {
                cachedWrapperClasses = new ConcurrentHashSet<Class<?>>();
                wrappers = cachedWrapperClasses;
            }
            wrappers.add(clazz);
        } else {
            clazz.getConstructor();
            if (StringUtils.isEmpty(name)) {
                // 如果在文件里没有配名字，可以去看实现类上是否有Extension注解，可以取这个注解的值作为名字
                // 如果没有Extension这个注解，则取实现类的simple名，并进行简化，比如接口为CarService, 实现类为RedCarService, 那么名字则为red
                name = findAnnotationName(clazz);
                if (name.length() == 0) {
                    throw new IllegalStateException("No such extension name for the class " + clazz.getName() + " in the config " + resourceURL);
                }
            }
            // 如果配置的名字使用逗号隔开的
            String[] names = NAME_SEPARATOR.split(name);
            if (names != null && names.length > 0) {
                // 这里找的是Activate注解，不是Adaptive
                // Activate表示激活，如果实现类上配置了Activate注解，这里会先缓存，getActivateExtension（）方法
                Activate activate = clazz.getAnnotation(Activate.class);
                if (activate != null) {
                    cachedActivates.put(names[0], activate);
                } else {
                    // support com.alibaba.dubbo.common.extension.Activate
                    com.alibaba.dubbo.common.extension.Activate oldActivate = clazz.getAnnotation(com.alibaba.dubbo.common.extension.Activate.class);
                    if (oldActivate != null) {
                        cachedActivates.put(names[0], oldActivate);
                    }
                }
                for (String n : names) {
                    // 配了多个名字cachedName也只会缓存一个
                    if (!cachedNames.containsKey(clazz)) {
                        cachedNames.put(clazz, n);
                    }
                    // 多个名字会产生多条记录
                    Class<?> c = extensionClasses.get(n);
                    if (c == null) {
                        extensionClasses.put(n, clazz);
                    } else if (c != clazz) {
                        throw new IllegalStateException("Duplicate extension " + type.getName() + " name " + n + " on " + c.getName() + " and " + clazz.getName());
                    }
                }
            }
        }
    }

上边的第17行判断逻辑，就是是否有特定的构造器：

private boolean isWrapperClass(Class<?> clazz) {
        try {
            clazz.getConstructor(type);
            return true;
        } catch (NoSuchMethodException e) {
            return false;
        }
    }

上边的代码就是将实现类与切面类进行缓存，供下一步切面组装：

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

这段逻辑的第一行会拿到Car的实现类，然后循环切面类wrapperClasses，将实现类注入切面的构造器，并返回切面，如果还有切面，则将上一次返回的切面继续注入下一个切面，并返回下一个切面。知道循环完所有切面。那么，很明显，第8行将会返回最外层的一个切面对象，而非Car的业务实现类。

 因为点火切面在com.luban.dubbo_spi.Car文件的第一个放着，所以 就对应最外层的切面，一次类推。

今天的Dubbo的SPI的AOP实现就记录到这里，不难发现，Dubbo实现的AOP非常轻量级，并且精巧，下一节，将会探讨Dubbo SPI的IOC实现。