JDK SPI 、Spring SPI、Dubbo SPI机制

JDK SPI机制

 SPI（Service Provider Interface)，是一种将服务接口与服务实现分离以达到解耦可拔插、大大提升了程序可扩展性的机制。

约定（我觉得称之为规范更合适）：

1. 制定统一的规范（比如 java.sql.Driver）

2. 服务提供商提供这个规范具体的实现，在自己jar包的META-INF/services/目录里创建一个以服务接口命名的文件，内容是实现类的全命名（比如：com.mysql.jdbc.Driver）。

3. 平台引入外部模块的时候，就能通过该jar包META-INF/services/目录下的配置文件找到该规范具体的实现类名，然后装载实例化，完成该模块的注入。

这个机制最大的优点就是无须在代码里指定，进而避免了代码污染，实现了模块的可拔插。

 JDK SPI的一个典型案例就是 java.sql.Driver 了

 

 我们最熟悉的代码

// 加载驱动
Class.forName("com.mysql.jdbc.Driver");
// 获取连接
Connection connection = DriverManager.getConnection("url", "user", "password");

我们进入DriverManager类，里面有个静态代码块，这部分的内容会先执行。

static {
    loadInitialDrivers();
    println("JDBC DriverManager initialized");
}

加载并初始化驱动

private static void loadInitialDrivers() {
    // ...

    // 如果驱动被打包作为服务提供者，则加载它。
    AccessController.doPrivileged(new PrivilegedAction<Void>() {
        public Void run() {
            // 1. load
            ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
            // 2. 获取Loader的迭代器
            Iterator<Driver> driversIterator = loadedDrivers.iterator();
            try{
                // 3. 调用next方法
                while(driversIterator.hasNext()) {
                    driversIterator.next();
                }
            } catch(Throwable t) {
            // Do nothing
            }
            return null;
        }
    });
    // ...
}

看 ServiceLoader#load方法

public static <S> ServiceLoader<S> load(Class<S> service) {
    // 获取类加载器
    ClassLoader cl = Thread.currentThread().getContextClassLoader();
    // load
    return ServiceLoader.load(service, cl);
}

public static <S> ServiceLoader<S> load(Class<S> service,ClassLoader loader){
    // new 一个 ServiceLoader，参数为服务接口Class和类加载器
    return new ServiceLoader<>(service, loader);
}

可以看出，上面主要是获取类加载器并新建ServiceLoader的过程，没有加载实现类的动作。现在看：ServiceLoader#iterator 方法

public Iterator<S> iterator() {
    // 这里是个Iterator的匿名内部类，重写了一些方法
    return new Iterator<S>() {

        // 已存在的提供者
        Iterator<Map.Entry<String,S>> knownProviders
            = providers.entrySet().iterator();

        public boolean hasNext() {
            // 先检查缓存
            if (knownProviders.hasNext())
                return true;
            // 缓存没有，走 java.util.ServiceLoader.LazyIterator#hasNext 方法
            return lookupIterator.hasNext();
        }

        public S next() {
            // 同样先检查缓存
            if (knownProviders.hasNext())
                return knownProviders.next().getValue();
            // 缓存没有，走 java.util.ServiceLoader.LazyIterator#next 方法
            return lookupIterator.next();
        }

        public void remove() {
            throw new UnsupportedOperationException();
        }

    };
}

看 ServiceLoader.LazyIterator#hasNext 方法

// java.util.ServiceLoader.LazyIterator#hasNext
public boolean hasNext() {
    if (acc == null) {
        return hasNextService();
    } else {
        PrivilegedAction<Boolean> action = new PrivilegedAction<Boolean>() {
            public Boolean run() { return hasNextService(); }
        };
        return AccessController.doPrivileged(action, acc);
    }
}
private boolean hasNextService() {
    if (nextName != null) {
        return true;
    }
    if (configs == null) {
        try {
            // 获取全路径：META-INF/services/java.sql.Driver
            String fullName = PREFIX + service.getName();
            // 加载资源
            if (loader == null)
                configs = ClassLoader.getSystemResources(fullName);
            else
                configs = loader.getResources(fullName);
        } catch (IOException x) {
            fail(service, "Error locating configuration files", x);
        }
    }
    // 这里负责解析前面加载的配置信息
    while ((pending == null) || !pending.hasNext()) {
        if (!configs.hasMoreElements()) {
            return false;
        }
        // 解析的返回值是一个 Iterator<String> 类型，其中的String代表文件里配置的实现类全限定名，比如：com.mysql.jdbc.Driver
        pending = parse(service, configs.nextElement());
    }
    // 把nextName初始化
    nextName = pending.next();
    return true;
}

看 ServiceLoader.LazyIterator#next 方法

// java.util.ServiceLoader.LazyIterator#next
public S next() {
    if (acc == null) {
        return nextService();
    } else {
        PrivilegedAction<S> action = new PrivilegedAction<S>() {
            public S run() { return nextService(); }
        };
        return AccessController.doPrivileged(action, acc);
    }
}
// 进入 java.util.ServiceLoader.LazyIterator#nextService 方法
private S nextService() {
    if (!hasNextService())
        throw new NoSuchElementException();
    // com.mysql.jdbc.Driver
    String cn = nextName;
    nextName = null;
    Class<?> c = null;
    try {
        // 加载 com.mysql.jdbc.Driver Class
        c = Class.forName(cn, false, loader);
    } catch (ClassNotFoundException x) {
        fail(service,
             "Provider " + cn + " not found");
    }
    if (!service.isAssignableFrom(c)) {
        fail(service,
             "Provider " + cn  + " not a subtype");
    }
    try {
        // 实例化并转换成 com.mysql.jdbc.Driver 对象
        S p = service.cast(c.newInstance());
        // 添加到缓存
        providers.put(cn, p);
        return p;
    } catch (Throwable x) {
        fail(service,
             "Provider " + cn + " could not be instantiated",
             x);
    }
    throw new Error();          // This cannot happen
}

所以，DriverManager做了什么事：

// 1. 获取类加载器并创建ServiceLoader对象
ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
// 2. 创建迭代器并覆盖hasNext和next方法
Iterator<Driver> driversIterator = loadedDrivers.iterator();

try{
    // 3. 这个方法主要是读取配置文件，获取其中实现类的全限定名。
    while(driversIterator.hasNext()) {
        // 4. 这个方法主要是根据全限定名去生成一个实例
        driversIterator.next();
    }
} catch(Throwable t) {
// Do nothing
}

另外你也能发现，ServiceLoader只提供了遍历的方式来获取目标实现类，没有提供按需加载的方法，这也是常说的不足之处。

自己实现

定义一个接口

package com.demo.spi;

public interface Funny {

    void deal();
}

写一个实现类

package com.demo.spi;

public class FunnyImpl implements Funny {
    @Override
    public void deal() {
        System.out.println("FunnyImpl");
    }
}

配置

文件内容

 执行测试

@Test
public void test(){
    ServiceLoader<Funny> serviceLoader = ServiceLoader.load(Funny.class);
    serviceLoader.forEach(Funny::deal);
}

输出

Spring SPI机制

对于Spring的SPI机制主要体现在SpringBoot中。我们知道SpringBoot的启动包含new SpringApplication和执行run方法两个过程，new的时候有这么个逻辑：（getSpringFactoriesInstances）

这个方法走到里面，无非 1. 加载类的全限定名列表。2. 根据类名通过反射实例化。

重点在于：SpringFactoriesLoader.loadFactoryNames(type, classLoader) 

public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
    // 获取类的全限定名
    String factoryClassName = factoryClass.getName();
    // 1. 执行loadSpringFactories，这里只传入了类加载器，肯定是要获取全部配置
    // 2. getOrDefault，获取指定接口的实现类名称列表，如果没有则返回一个空列表
    return loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
}

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
    // 先检查缓存
    MultiValueMap<String, String> result = cache.get(classLoader);
    if (result != null) {
        return result;
    }
    try {
        // 获取类路径下所有META-INF/spring.factories
        Enumeration<URL> urls = (classLoader != null ?
                classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
                ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
        result = new LinkedMultiValueMap<>();
        // 把加载的配置转换成Map<String, List<String>>格式
        while (urls.hasMoreElements()) {
            URL url = urls.nextElement();
            UrlResource resource = new UrlResource(url);
            Properties properties = PropertiesLoaderUtils.loadProperties(resource);
            for (Map.Entry<?, ?> entry : properties.entrySet()) {
                String factoryClassName = ((String) entry.getKey()).trim();
                for (String factoryName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {
                    result.add(factoryClassName, factoryName.trim());
                }
            }
        }
        cache.put(classLoader, result);
        return result;
    }
    catch (IOException ex) {
        throw new IllegalArgumentException("Unable to load factories from location [" +
                FACTORIES_RESOURCE_LOCATION + "]", ex);
    }
}

它还提供了实例化的方法：SpringFactoriesLoader.loadFactories(factoryClass, classLoader) 利用反射实现，理解起来也不困难，不做解释了

对比ServiceLoader：

1. 都是XXXLoader。命名格式都一样。

2. 一个是加载 META-INF/services/ 目录下的配置；一个是加载 META-INF/spring.factories 固定文件的配置。思路都一样。

3. 两个都是利用ClassLoader和ClassName来完成操作的。不同的是Java的ServiceLoader加载配置和实例化都是自己来实现，并且不能按需加载；SpringFactoriesLoader既可以单独加载配置然后按需实例化也可以实例化全部。

如何实现一个Spring-Boot-Starter？

先看一下SpringBoot的相关要点。

这个是SpringBoot的 @SpringBootApplication 注解，里面还有一个 @EnableAutoConfiguration 注解，开启自动配置的。

可以发现这个自动配置注解在另一个工程，而这个工程里也有个spring.factories文件，如下图：

我们知道在SpringBoot的目录下有个spring.factories文件，里面都是一些接口的具体实现类，可以由SpringFactoriesLoader加载。

那么同样的道理，spring-boot-autoconfigure模块也能动态加载了。看一下其中的内容：

我们看到有个接口【org.springframework.boot.autoconfigure.EnableAutoConfiguration】，有N个配置类，都是自动配置相关的，那么我们可以猜一猜，是不是模仿一下这样的配置，我们就可以丝滑进入了？

为了证明这一点，我们看一下 dubbo-spring-boot-starter 的结构

你会发现starter项目没有实现类，只有个pom文件。

它的关键在于引入了一个 autoconfigure 依赖。

这个里面配置了Spring的 spring.factories 其中只有一个配置

看到这里你是不是感觉到了什么：

1. 新建一个只有pom的starter工程，引入写好的自动配置模块。

2. 自动配置模块配置 spring.factories 文件，格式如上。

3. 具体实现自动配置逻辑。

这样当SpringBoot启动加载配置类的时候，就会把这些第三方的配置一起加载。

所以我认为 Starter的作用就是在启动之前把第三方的配置加载到容器中，具体表现就是无须用户手动配置即可使用。【如果不准确望指正】

具体实现一个starter

两个maven工程，目录如下：

custom-spring-boot-autoconfigure↓↓↓↓↓

pom

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.demo</groupId>
    <artifactId>custom-spring-boot-autoconfigure</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
            <version>2.1.6.RELEASE</version>
        </dependency>
    </dependencies>

</project>

CustomAutoConfiguration

import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConditionalOnClass(name = "org.springframework.web.servlet.DispatcherServlet")
public class CustomAutoConfiguration {

    @Bean
    public CustomConfig customConfig(){
        System.out.println("!!!!!!!!!!!!!!!!!!!!!!!!!第三方自定义的配置");
        return new CustomConfig();
    }
}

CustomConfig

/**
 * 自定义配置
 */
public class CustomConfig {

    private String value = "Default";
}

spring.factories

org.springframework.boot.autoconfigure.EnableAutoConfiguration=
com.demo.CustomAutoConfiguration

一共四个文件

custom-spring-boot-starter↓↓↓↓

只有pom文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.demo</groupId>
    <artifactId>custom-spring-boot-starter</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>com.demo</groupId>
            <artifactId>custom-spring-boot-autoconfigure</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

    </dependencies>

</project>

最后把这两个工程install

下面是新建一个SpringBoot项目，然后引入咱们自定义的starter依赖。

<dependency>
    <groupId>com.demo</groupId>
    <artifactId>custom-spring-boot-starter</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

然后启动就可以啦，可以看见，用户引入依赖之后无需手动配置就可以使用第三方插件

看下工程依赖

Dubbo SPI机制

上面介绍了两种SPI，到Dubbo这里就不难理解了吧？

思路都是处理类+约定配置 ，在Dubbo里，约定扩展配置在  META-INF/dubbo/internal/ 目录下

在Dubbo源码里也可以发现，核心类是 ExtensionLoader

private static final Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();

private static final ProxyFactory PROXY_FACTORY = ExtensionLoader.getExtensionLoader(ProxyFactory.class).getAdaptiveExtension();

getExtensionLoader

// 这个方法就是获取一个特定类型的ExtensionLoader的实例
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;
}

下面看getExtension方法

public T getExtension(String name) {
    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);
                holder.set(instance);
            }
        }
    }
    return (T) instance;
}

看createExtension方法

private T createExtension(String name) {
    // 1. 获取扩展Class
    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);
        }
        // 2. IOC注入依赖
        injectExtension(instance);
        Set<Class<?>> wrapperClasses = cachedWrapperClasses;
        if (CollectionUtils.isNotEmpty(wrapperClasses)) {
            for (Class<?> wrapperClass : wrapperClasses) {
                instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
            }
        }
        return instance;
    } catch (Throwable t) {
        throw new IllegalStateException("Extension instance (name: " + name + ", class: " +
                type + ") couldn't be instantiated: " + t.getMessage(), t);
    }
}

1. 获取所有扩展类

private Map<String, Class<?>> getExtensionClasses() {
    // 缓存 + 双重检查
    Map<String, Class<?>> classes = cachedClasses.get();
    if (classes == null) {
        synchronized (cachedClasses) {
            classes = cachedClasses.get();
            if (classes == null) {
                // 加载扩展类
                classes = loadExtensionClasses();
                cachedClasses.set(classes);
            }
        }
    }
    return classes;
}

// 对于loadDirectory，每个目录有两个执行逻辑，因为目前要兼容alibaba老版本
private Map<String, Class<?>> loadExtensionClasses() {
    cacheDefaultExtensionName();
    Map<String, Class<?>> extensionClasses = new HashMap<>();
    // 加载目录：META-INF/dubbo/internal/
    loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY, type.getName());
    loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));
    // 加载目录：META-INF/dubbo/
    loadDirectory(extensionClasses, DUBBO_DIRECTORY, type.getName());
    loadDirectory(extensionClasses, DUBBO_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));
    // 加载目录：META-INF/services/
    loadDirectory(extensionClasses, SERVICES_DIRECTORY, type.getName());
    loadDirectory(extensionClasses, SERVICES_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));
    return extensionClasses;
}

private void loadDirectory(Map<String, Class<?>> extensionClasses, String dir, String type) {
    // 文件路径，比如 META-INF/dubbo/internal/com.alibaba.dubbo.rpc.Protocol
    String fileName = dir + type;
    try {
        Enumeration<java.net.URL> urls;
        ClassLoader classLoader = findClassLoader();
        // 加载文件
        if (classLoader != null) {
            urls = classLoader.getResources(fileName);
        } else {
            urls = ClassLoader.getSystemResources(fileName);
        }
        if (urls != null) {
            while (urls.hasMoreElements()) {
                java.net.URL resourceURL = urls.nextElement();
                // 加载资源（读取文件内容）
                loadResource(extensionClasses, classLoader, resourceURL);
            }
        }
    } catch (Throwable t) {
        logger.error("Exception occurred when loading extension class (interface: " +
                type + ", description file: " + fileName + ").", t);
    }
}

private void loadResource(Map<String, Class<?>> extensionClasses, ClassLoader classLoader, java.net.URL resourceURL) {
    try {
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(resourceURL.openStream(), StandardCharsets.UTF_8))) {
            String line;
            // 按行读取
            while ((line = reader.readLine()) != null) {
                // 判断注释
                final int ci = line.indexOf('#');
                if (ci >= 0) {
                    // 截取 # 之前的字符串，# 之后的内容为注释，需要忽略
                    line = line.substring(0, ci);
                }
                line = line.trim();
                if (line.length() > 0) {
                    try {
                        String name = null;
                        // 按照 = 分割，前面是name，后面是类全限定名
                        int i = line.indexOf('=');
                        if (i > 0) {
                            name = line.substring(0, i).trim();
                            line = line.substring(i + 1).trim();
                        }
                        if (line.length() > 0) {
                            // 加载Class
                            loadClass(extensionClasses, resourceURL, Class.forName(line, true, classLoader), name);
                        }
                    } catch (Throwable t) {
                        IllegalStateException e = new IllegalStateException("Failed to load extension class (interface: " + type + ", class line: " + line + ") in " + resourceURL + ", cause: " + t.getMessage(), t);
                        exceptions.put(line, e);
                    }
                }
            }
        }
    } catch (Throwable t) {
        logger.error("Exception occurred when loading extension class (interface: " +
                type + ", class file: " + resourceURL + ") in " + resourceURL, t);
    }
}

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)) {
        // 设置 cachedAdaptiveClass缓存
        cacheAdaptiveClass(clazz);
    // 检测 clazz 是否是 Wrapper 类型
    } else if (isWrapperClass(clazz)) {
        // 存储 clazz 到 cachedWrapperClasses 缓存中
        cacheWrapperClass(clazz);
    } else {
        // 检测 clazz 是否有默认的构造方法，如果没有，则抛出异常
        clazz.getConstructor();
        if (StringUtils.isEmpty(name)) {
            // 如果 name 为空，则尝试从 Extension 注解中获取 name，或使用小写的类名作为 name
            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 (ArrayUtils.isNotEmpty(names)) {
            // 存储 name 到 Activate 注解对象的映射关系
            cacheActivateClass(clazz, names[0]);
            for (String n : names) {
                // 存储 Class 到名称的映射关系
                cacheName(clazz, n);
                // 存储名称到 Class 的映射关系
                saveInExtensionClass(extensionClasses, clazz, n);
            }
        }
    }
}

这部分有些注释直接拿的官网，总结下来这部分：

1. 根据约定的路径比如【META-INF/dubbo/internal/】加载文件URl。

2. 读取并解析每一个文件内容，具体为按行读取，去掉注释，按等号分割为 name-class全限定名键值对。

3. 根据类全限定名生成Class对象，根据Class对象的的特点进行相关的缓存以及name到Class对象的缓存。

2. IOC注入依赖

private T injectExtension(T instance) {
    try {
        if (objectFactory != null) {
            for (Method method : instance.getClass().getMethods()) {
                // 这里判断方法是否是setter方法，Dubbo目前只处理setter的IOC
                if (isSetter(method)) {
                    // 如果标注了@DisableInject，则不进行注入
                    if (method.getAnnotation(DisableInject.class) != null) {
                        continue;
                    }
                    // 获取 setter 方法参数类型
                    Class<?> pt = method.getParameterTypes()[0];
                    // 基本类型跳过
                    if (ReflectUtils.isPrimitives(pt)) {
                        continue;
                    }
                    try {
                        // 获取属性名，比如 setName 方法对应属性名 name
                        String property = getSetterProperty(method);
                        // 从 ObjectFactory 中获取依赖对象
                        Object object = objectFactory.getExtension(pt, property);
                        if (object != null) {
                            // 通过反射调用 setter 方法设置object依赖
                            method.invoke(instance, object);
                        }
                    } catch (Exception e) {
                        logger.error("Failed to inject via method " + method.getName()
                                + " of interface " + type.getName() + ": " + e.getMessage(), e);
                    }
                }
            }
        }
    } catch (Exception e) {
        logger.error(e.getMessage(), e);
    }
    return instance;
}

这部分容易理解，核心部分利用反射实现，其它前置处理做了一些校验。

而使用Dubbo SPI的话也是一样的套路，扩展类实现 + 配置 + ExtensionLoader