SpringBoot SPI机制理解

什么是SPI

SPI的全称是Service Provider Interface，服务提供接口。

简单来说就是通过配置文件指定接口的实现类

当我们开发一套框架，一套机制，一个插件，或者一套API的时候，如果需要第三方的服务支持，可以直接写死在代码里面，但是这种方式耦合太强，不利于切换到其他服务，好的方式就是指定一个配置文件，指定服务的实现方。jdk的spi就是这种机制。

一个接口可以有很多实现，比如数据库驱动，有oracle，mysql，postgress等等，他们都遵循JDBC规范，为了解耦，我们可以抽象出一个高层的Driver接口，让各个数据库服务商去实现各自的驱动，在使用的时候我们可以选择加载具体的实现方式，这时候我们就可以使用SPI这种技术。

JDK中的SPI

讲到JDK中的SPI ，我们不得不说 java.util.ServiceLoader这个类，我们先跑起来

1. 创建一个接口，Message

   public interface Message{
       void send()
   }

2. 在resources资源目录下创建META-INF/services文件夹
3. 在services文件夹中创建文件，以接口全名命名

4. 创建接口实现类

   public class SmsMessage implements Message{
       public void send(){
           System.out.println("send sms message");
       }
   }
   
   public class EmailMessage implements Message{   
       public void send(){
           System.out.println("send email message");
       }
   }

5. 测试

   public class TestServiceLoader{
       public static void main(String[] args){
           ServiceLoader<Message> messages = ServiceLoader.load(Message.class);
           for(Message msg : messages){
               msg.send();
           }
       }
   }

SpringBoot中的SPI

在SpringBoot的自动装配过程中，最终会加载META-INF/spring.factories文件，SpringBoot是通过SpringFactoriesLoader#loadFactoryNames方法加载的。从classpath下的每一个jar包中搜寻所有META-INF/spring.factories配置文件，然后将解析properties文件，找到指定名称的配置后返回。需要注意的是，其实这里不仅仅是会去ClassPath路径下查找，会扫描所有路径下的Jar包，只不过这个文件只会在Classpath下的jar包中。

public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
        ClassLoader classLoaderToUse = classLoader;
        if (classLoaderToUse == null) {
            classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
        }
        String factoryTypeName = factoryType.getName();
        return loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
}

private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
        Map<String, List<String>> result = cache.get(classLoader);
        if (result != null) {
            return result;
        }

        result = new HashMap<>();
        try {
            Enumeration<URL> urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION);
            while (urls.hasMoreElements()) {
                URL url = urls.nextElement();
                UrlResource resource = new UrlResource(url);
                Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                for (Map.Entry<?, ?> entry : properties.entrySet()) {
                    String factoryTypeName = ((String) entry.getKey()).trim();
                    String[] factoryImplementationNames =
                            StringUtils.commaDelimitedListToStringArray((String) entry.getValue());
                    for (String factoryImplementationName : factoryImplementationNames) {
                        result.computeIfAbsent(factoryTypeName, key -> new ArrayList<>())
                                .add(factoryImplementationName.trim());
                    }
                }
            }

            // Replace all lists with unmodifiable lists containing unique elements
            result.replaceAll((factoryType, implementations) -> implementations.stream().distinct()
                    .collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList)));
            cache.put(classLoader, result);
        }
        catch (IOException ex) {
            throw new IllegalArgumentException("Unable to load factories from location [" +
                    FACTORIES_RESOURCE_LOCATION + "]", ex);
        }
        return result;
}

SPI使用场景

适合根据实际使用，更换实现策略的框架。

如下：

1. JDBC负载驱动不同类型的数据库。
2. SLF4J载入不同供应商的日志实现类别。

   等等