Dubbo的核心之SPI

1 Java SPI扩展点实现

SPI(Service Provider Interface):原本是jdk内置的服务提供发现机制，主要用来做服务的扩展实现。SPI机制在很多场景。都有用到，比如数据库连接，JDK提供了java.sql.Driver接口，而驱动类由不同的厂商来实现，比如MySQL、Oracle等，所有的数据库驱动包会实现这个接口，然后jdk利用SPI机制从classpath下的resources/META-INF/services扫描属性文件。

1.1 Java SPI示例演示

1.创建一个接口

public interface Driver {
    String connect();
}

2.创建接口实现类，实现Driver接口

public class MyDriver implements Driver{
    @Override
    public String connect() {
        return "连接数据库";
    }
}

3.在resources/META-INF/services文件夹下创建以Driver 接口全路径命名的文件，里面内容填写MyDriver 的全路径

4.创建测试类测试结果

public class TestSPIMain {
    public static void main(String[] args) {
        ServiceLoader<Driver> serviceLoader = ServiceLoader.load(Driver.class);
        serviceLoader.forEach(driver -> System.out.println(driver.connect()));
    }
}

2 Dubbo SPI

Dubbo并没有使用JDK内置的SPI机制，只是利用了SPI的思想，根据实际情况做了优化和调整。Dubbo SPI的相关业务逻辑封装在ExtensionLoader类中。通过ExtensionLoader可以加载指定的实现类

2.1 示例代码

1、创建接口，使用@SPI注解

@SPI
public interface Driver {
    String connect();
}

2 、创建接口实现类，实现Driver

public class MySqlDriver implements Driver{
    @Override
    public String connect() {
        return "连接mysql数据库";
    }
}

3、在resources/META-INF/dubbo文件下创建以接口命名的全类名 com.example.springcloud.nacos.demo.spi.Driver
文件内容和JDK内置SPI不同，需要以key value的形式填写.key是字符串，value是扩展类的全路径

mysqlDriver=com.example.springcloud.nacos.demo.spi.MySqlDriver

4、创建测试类,使用ExtensionLoader.getExtensionLoader()获取扩展类，再通过 extensionLoader.getExtension获取指定名称的扩展点。

public class TestSPIMain {
    public static void main(String[] args) {
        ExtensionLoader<Driver> extensionLoader = ExtensionLoader.getExtensionLoader(Driver.class);
        Driver mysqlDriver = extensionLoader.getExtension("mysqlDriver");
        System.out.println(mysqlDriver.connect());

    }
}

2.2 源码分析

分析源码要先找到入口:通过测试类可以发现通过ExtensionLoader.getExtensionLoader()获得ExtensionLoader实例，再通过getExtension()方法获得指定名称的扩展点，基于这两个方法来分析源码。

2.2.1 ExtensionLoader.getExtensionLoader

public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
       // 省略代码
       //先从缓存中获取与扩展类对用的ExtensionLoader，type就是自己定义的接口
        ExtensionLoader<T> loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
        //如果缓存中没有，则创建一个实例，并保存到EXTENSION_LOADERS集合中并缓存起来
        if (loader == null) {
            EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));
            loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
        }
        return loader;
    }

2.2.2 getExtension

getExtension():根据指定名称获得对应的扩展点并返回，根据测试案例name就是我们传入的mysqlDriver，返回的实现类就是MySqlDriver。
getExtension()

public T getExtension(String name, boolean wrap) {
        if (StringUtils.isEmpty(name)) {
            throw new IllegalArgumentException("Extension name == null");
        }
        if ("true".equals(name)) {
            return getDefaultExtension();
        }
        //创建Holder对象，用于缓存实例
        final Holder<Object> holder = getOrCreateHolder(name);
        Object instance = holder.get();
        //如果缓存中不存在，则创建一个实例
        if (instance == null) {
            synchronized (holder) {
                instance = holder.get();
                if (instance == null) {
                    instance = createExtension(name, wrap);
                    holder.set(instance);
                }
            }
        }
        return (T) instance;
    }

createExtension(name, wrap)

private T createExtension(String name, boolean wrap) {
		//根据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);

           // 通过wrap进行包装，并返回扩展类实现
            if (wrap) {

                List<Class<?>> wrapperClassesList = new ArrayList<>();
                if (cachedWrapperClasses != null) {
                    wrapperClassesList.addAll(cachedWrapperClasses);
                    wrapperClassesList.sort(WrapperComparator.COMPARATOR);
                    Collections.reverse(wrapperClassesList);
                }

                if (CollectionUtils.isNotEmpty(wrapperClassesList)) {
                    for (Class<?> wrapperClass : wrapperClassesList) {
                        Wrapper wrapper = wrapperClass.getAnnotation(Wrapper.class);
                        if (wrapper == null
                                || (ArrayUtils.contains(wrapper.matches(), name) && !ArrayUtils.contains(wrapper.mismatches(), name))) {
                            instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
                        }
                    }
                }
            }

            initExtension(instance);
            return instance;
        } catch (Throwable t) {
            throw new IllegalStateException("Extension instance (name: " + name + ", class: " +
                    type + ") couldn't be instantiated: " + t.getMessage(), t);
        }
    }

继续查看上述代码中getExtensionClasses().get(name) 代码

private Map<String, Class<?>> getExtensionClasses() {
      //从缓存中获取被加载的扩展类
        Map<String, Class<?>> classes = cachedClasses.get();
        if (classes == null) {
            synchronized (cachedClasses) {
                classes = cachedClasses.get();
                //若缓存中不存在，调用loadExtensionClasses加载扩展类
                if (classes == null) {
                    classes = loadExtensionClasses();
                    cachedClasses.set(classes);
                }
            }
        }
        return classes;
    }

loadExtensionClasses()

private Map<String, Class<?>> loadExtensionClasses() {
//获得当前type默认的扩展类
        cacheDefaultExtensionName();

        Map<String, Class<?>> extensionClasses = new HashMap<>();
//解析指定路径下的文件，并将解析内容保存到extensionClasses集合中
        for (LoadingStrategy strategy : strategies) {
            loadDirectory(extensionClasses, strategy.directory(), type.getName(), strategy.preferExtensionClassLoader(), strategy.overridden(), strategy.excludedPackages());
            loadDirectory(extensionClasses, strategy.directory(), type.getName().replace("org.apache", "com.alibaba"), strategy.preferExtensionClassLoader(), strategy.overridden(), strategy.excludedPackages());
        }

        return extensionClasses;
    }

cacheDefaultExtensionName()

private void cacheDefaultExtensionName() {
     //获得type类声明的注解@SPI 
        final SPI defaultAnnotation = type.getAnnotation(SPI.class);
        if (defaultAnnotation == null) {
            return;
        }
		//得到注解中的value值
        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];
            }
        }
    }

dubbo代码实现套路有点类似，都是先去缓存中获取，如果缓存中没有再创建实例并加入到缓存中。