Dubbo源码解析-SPI的应用

代码不算复杂，主要就是解析meta-INF/services目录下的以接口全限定名为文件名的文件，解析文件的内容，并创建对应Class的实例

    JDK提供的ServiceLoader技术，有很多广泛的应用。最为大家所熟悉的应该就是DriverManger了。

    DriverManger在加载的时候，就依据ServiceLoader的方式扫描了一下当前有哪些Driver的实现，并主动加载。

public class DriverManager {
 
    static {
        loadInitialDrivers();
        println("JDBC DriverManager initialized");
    }
    
    private static void loadInitialDrivers() {
        String drivers;
        ...
        AccessController.doPrivileged(new PrivilegedAction() {
            public Void run() {
				// 通过ServiceLoader加载
                ServiceLoader loadedDrivers = ServiceLoader.load(Driver.class);
                Iterator driversIterator = loadedDrivers.iterator();

                try{
                    while(driversIterator.hasNext()) {
                        driversIterator.next();
                    }
                } catch(Throwable t) {
                // Do nothing
                }
                return null;
            }
        });
		...
        String[] driversList = drivers.split(":");
        for (String aDriver : driversList) {
            try {
                // 创建对应Driver的实例
                Class.forName(aDriver, true,
                        ClassLoader.getSystemClassLoader());
            } catch (Exception ex) {
            }
        }
    }
}

当我们引入mysql-connection-java.jar包时，会发现

也是按照标准方式来实现的自动添加Driver

    Dubbo也有自己的SPI，我们先来看其实现，然后再总结其优势。

package xw.demo.adaptive;
// 较上文中的不同点就是多加了一个@SPI注解
@SPI
public interface Teacher {
    void say();
}

// 三个实现类与上面示例相同，不再赘述

    在meta-INF/dubbo目录下创建名为xw.demo.adaptive.Teacher的文件，内容如下

注意：也可以将该文件创建在meta-INF/services目录下，Dubbo也是支持的，但是为了与JDK原生的使用方式做一定的区分，特地写在meta-INF/dubbo目录下

ExtensionLoader extensionLoader = ExtensionLoader.getExtensionLoader(Teacher.class);
Teacher teacher = extensionLoader.getExtension("chinese");
teacher.say();
// 结果如下：
chinese

总结：相比较JDK的加载方式而言，Dubbo的这种方式，可以精准的加载对应的实现类，而其他我们不需要的实现类，则不需要被加载。

    Dubbo在SPI的使用中，有很多包装类的实现。不动声色的就将实现类包装了一层，类似于动态代理的模式。

    同3.1，就是多一个Wrap的实现类（共四个实现类，另外三个同上，ChineseTeacher、MathTeacher、EnglishTeacher）

package xw.demo.adaptive;
public class TeacherWrapper implements Teacher {
	// 需要有一个Teacher类型的属性
    private Teacher teacher;
    public TeacherWrapper(Teacher teacher) {
        if (teacher == null) {
            throw new IllegalArgumentException("teacher == null");
        }
        this.teacher = teacher;
    }

    @Override
    public void say() {
        System.out.println("start wrap...");
        teacher.say();
    }
}

    并将该实现类添加到上面的xw.demo.adaptive.Teacher文件中，如下

ExtensionLoader extensionLoader = ExtensionLoader.getExtensionLoader(Teacher.class);
Teacher teacher = extensionLoader.getExtension("chinese");
teacher.say();

// 结果如下：
start wrap...
chinese

与3.3的测试结果有所不同，这里多了TeacherWrapper类的一层封装，所以对ChineseTeacher.say()进行调用时，先打印了封装类的输出语句。

Dubbo有很多关于封装类的使用场景，例如关于Protocol的封装类

ProtocolFilterWrapper、ProtocolListenerWrapper，这两个类在对外提供服务时会用到。

    相较于3这种简单的使用方式，Dubbo源码中更常使用的是Adaptive方式，我们先来看下示例。

package xw.demo.adaptive;
@SPI("chinese")
public interface Teacher {

    void say();

    
    @Adaptive
    void teach(URL url);
}

// 实现类
public class ChineseTeacher implements Teacher {
    @Override
    public void say() {
        System.out.println("chinese");
    }

    @Override
    public void teach(URL url) {
        System.out.println("teach chinese");
    }
}

public class MathTeacher implements Teacher {
    @Override
    public void say() {
        System.out.println("math");
    }

    @Override
    public void teach(URL url) {
        System.out.println("teach math");
    }
}

public class EnglishTeacher implements Teacher {
    @Override
    public void say() {
        System.out.println("english");
    }

    @Override
    public void teach(URL url) {
        System.out.println("teach english");
    }
}

    同3.2，不再赘述

5.3.1 测试情况一

Teacher teacher = ExtensionLoader.getExtensionLoader(Teacher.class).getAdaptiveExtension();
URL url = URL.valueOf("test://localhost/test");
teacher.teach(url);

// 结果为
teach chinese

5.3.2 测试情况二

Teacher teacher = ExtensionLoader.getExtensionLoader(Teacher.class).getAdaptiveExtension();
// url有所不同
URL url = URL.valueOf("test://localhost/test?teacher=english");
teacher.teach(url);

// 结果为
teach english

5.3.3 测试情况三

// 给MathTeacher添加@Adaptive注解
@Adaptive
public class MathTeacher implements Teacher {
    @Override
    public void say() {
        System.out.println("math");
    }

    @Override
    public void teach(URL url) {
        System.out.println("teach math");
    }
}

// 测试代码
Teacher teacher = ExtensionLoader.getExtensionLoader(Teacher.class).getAdaptiveExtension();
// 两种url都可以
URL url = URL.valueOf("test://localhost/test?teacher=english");
// URL url = URL.valueOf("test://localhost/test");
teacher.teach(url);

// 结果为
teach math

总结：Adaptive的这种方式在Dubbo中使用较为频繁。通过这三种测试结果我们可以总结出：

1.当在实现类上指定了@Adaptive时，其级别最高，ExtensionLoader.getAdaptiveExtension()默认就返回该实现类

2.当在URL中指定了条件（本例中为teacher=english），则ExtensionLoader.getAdaptiveExtension()会返回条件中指定的实现类

3.当没有任何指定时，则使用默认值，也就是在接口的@SPI注解中指定的（本例为chinese）

注意：总结2中的条件，这个teacher是怎么来的呢？实际就是我们接口的小写之后的字母（slow(Teacher)）。

如果接口是多字母组成的会怎么办呢？例如ExtAdaptive，那么不同字母之间就用.来分割，最终变成ext.adaptive

    Dubbo的SPI实现了这么多层次的使用，源码也是比较有意思的，我们一起来看下

public class ExtensionLoader {
    private static final ConcurrentMap, ExtensionLoader> EXTENSION_LOADERS = new ConcurrentHashMap<>(64);
    private static final ConcurrentMap, Object> EXTENSION_INSTANCES = new ConcurrentHashMap<>(64);
    // 当前关注的类型
    private final Class type;

	public static  ExtensionLoader getExtensionLoader(Class type) {
        ...
        ExtensionLoader loader = (ExtensionLoader) EXTENSION_LOADERS.get(type);
        if (loader == null) {
            // 直接创建对应类型的ExtensionLoader
            EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader(type));
            loader = (ExtensionLoader) EXTENSION_LOADERS.get(type);
        }
        return loader;
    }
    // 构造方法
    private ExtensionLoader(Class type) {
        // type即为本例中的SpiDemoService
        this.type = type;
        objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
    }
}

ExtensionLoader.getExtensionLoader()没有太多花哨的东西，就是设置了ExtensionLoader的基本属性

public class ExtensionLoader {
	// extensionLoader.getExtension(name) 方法分析
    public T getExtension(String name) {
        ...
        final Holder