SpringFactoriesLoader与SPI（服务提供接口）

1.什么是SPI (面试题)

SPI全名Service Provider interface，翻译过来就是“服务提供接口”，再说简单就是提供某一个服务的接口， 提供给服务开发者或者服务生产商来进行实现。

Java SPI 是JDK内置的一种动态加载扩展点的实现。

这个机制在一般的业务代码中很少用到，但是在底层框架中却被大量使用，包括JDBC、Dubbo、Spring框架、日志接口中都有用到，不同的是有的使用Java原生的实现，有的框架则自己实现了一套SPI机制.

2.Spring SPI

Spring中的SPI相比于JDK原生的，它的功能更为强大，因为它可以替换的类型不仅仅局限于接口/抽象类，它可以是任何一个类，接口，注解；

正因为Spring SPI是支持替换注解类型的SPI，这个特性在Spring Boot中的自动装配有体现（EnableAutoConfiguration注解）：

Spring的SPI文件是有规矩的，它需要放在工程的META-INF下，且文件名必须为spring.factories ，而文件的内容本质就是一个properties；如spring-boot-autoconfigure包下的META-INF/spring.factories文件，用于自动装配的；

Spring SPI加载spring.factories文件的操作是使用SpringFactoriesLoader，SpringFactoriesLoader它不仅可以加载声明的类的对象，而且可以直接把预先定义好的全限定名都取出来；

SpringFactoriesLoader#loadFactories加载spring.factories文件，最终会调用SpringFactoriesLoader#loadSpringFactories；

通过类加载器获取类路径下的FACTORIES_RESOURCE_LOCATION，之后获取到的资源路径，以properties的方式解析配置文件，其中配置文件的key为声明的类型，value为具体的实现的列表，最后将结果添加到缓存，其中缓存的key为类加载器，value为配置文件的内容；

3.SpringFactoriesLoader

1.介绍

SpringFactoriesLoader类的主要作用是通过类路径下的META-INF/spring.factories文件获取工厂类接口的实现类，初始化并保存在缓存中，以供Springboot启动过程中各个阶段的调用。Spring的自动化配置功能，也与此息息相关。

SpringFactoriesLoader 工厂加载机制是 Spring 内部提供的一个约定俗成的加载方式，只需要在模块的 META-INF/spring.factories 文件中，以 Properties 类型(即 key-value 形式)配置，就可以将相应的实现类注入 Spirng 容器中。

Properties 类型格式：

key:value 
key：是全限定名(抽象类|接口)
value：是实现类，多个实现类通过逗号进行分隔

spring boot 类路径下： META-INFO/spring.factories

# Logging Systems
org.springframework.boot.logging.LoggingSystemFactory=\
........

# Application Context Initializers
org.springframework.context.ApplicationContextInitializer=\
......
org.springframework.boot.web.context.ServerPortInfoApplicationContextInitializer

# Application Listeners
org.springframework.context.ApplicationListener=\
......
org.springframework.boot.liquibase.LiquibaseServiceLocatorApplicationListener

# Environment Post Processors
org.springframework.boot.env.EnvironmentPostProcessor=\
......
org.springframework.boot.reactor.DebugAgentEnvironmentPostProcessor

# Failure Analyzers
org.springframework.boot.diagnostics.FailureAnalyzer=\
......

2.方法

返回值	方法	描述
<T> List<T>	loadFactories(Class<T> factoryType, @Nullable ClassLoader classLoader)	静态方法； 根据接口获取其实现类的实例； 该方法返回的是实现类对象列表。
List<String>	loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader)	公共静态方法； 根据接口l获取其实现类的名称； 该方法返回的是实现类的类名的列表

public final class SpringFactoriesLoader {
    //文件位置，可以存在多个JAR文件中
    public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
    //用来缓存MultiValueMap对象
    private static final Map<ClassLoader, MultiValueMap<String, String>> cache = new ConcurrentReferenceHashMap<>();
    private SpringFactoriesLoader() {
    }
    /**
     * 根据给定的类型加载并实例化工厂的实现类
     */
    public static <T> List<T> loadFactories(Class<T> factoryType, @Nullable ClassLoader classLoader) {
        Assert.notNull(factoryType, "'factoryType' must not be null");
        //获取类加载器
        ClassLoader classLoaderToUse = classLoader;
        if (classLoaderToUse == null) {
            classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
        }
        //加载类的全限定名
        List<String> factoryImplementationNames = loadFactoryNames(factoryType, classLoaderToUse);
        if (logger.isTraceEnabled()) {
            logger.trace("Loaded [" + factoryType.getName() + "] names: " + factoryImplementationNames);
        }
        //创建一个存放对象的List
        List<T> result = new ArrayList<>(factoryImplementationNames.size());
        for (String factoryImplementationName : factoryImplementationNames) {
            //实例化Bean,并将Bean放入到List集合中
            result.add(instantiateFactory(factoryImplementationName, factoryType, classLoaderToUse));
        }
        //对List中的Bean进行排序
        AnnotationAwareOrderComparator.sort(result);
        return result;
    }

    /**
     * 根据给定的类型加载类路径的全限定名
     */
    public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
        //获取名称
        String factoryTypeName = factoryType.getName();
        //加载并获取所有META-INF/spring.factories中的value
        return loadSpringFactories(classLoader).getOrDefault(factoryTypeName, 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 {
            //获取所有JAR及classpath路径下的META-INF/spring.factories的路径
            Enumeration<URL> urls = (classLoader != null ?
                    classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
                    ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
            result = new LinkedMultiValueMap<>();
            //遍历所有的META-INF/spring.factories的路径
            while (urls.hasMoreElements()) {
                URL url = urls.nextElement();
                UrlResource resource = new UrlResource(url);
                //将META-INF/spring.factories中的key value加载为Prpperties对象
                Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                for (Map.Entry<?, ?> entry : properties.entrySet()) {
                    //key名称
                    String factoryTypeName = ((String) entry.getKey()).trim();
                    for (String factoryImplementationName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {
                        //以factoryTypeName为key,value为值放入map集合中
                        result.add(factoryTypeName, factoryImplementationName.trim());
                    }
                }
            }
            //放入到缓存中 
            cache.put(classLoader, result);
            return result;
        }
        catch (IOException ex) {
            throw new IllegalArgumentException("Unable to load factories from location [" +
                    FACTORIES_RESOURCE_LOCATION + "]", ex);
        }
    }

    //实例化Bean对象
    @SuppressWarnings("unchecked")
    private static <T> T instantiateFactory(String factoryImplementationName, Class<T> factoryType, ClassLoader classLoader) {
        try {
            Class<?> factoryImplementationClass = ClassUtils.forName(factoryImplementationName, classLoader);
            if (!factoryType.isAssignableFrom(factoryImplementationClass)) {
                throw new IllegalArgumentException(
                        "Class [" + factoryImplementationName + "] is not assignable to factory type [" + factoryType.getName() + "]");
            }
            return (T) ReflectionUtils.accessibleConstructor(factoryImplementationClass).newInstance();
        }
        catch (Throwable ex) {
            throw new IllegalArgumentException(
                "Unable to instantiate factory class [" + factoryImplementationName + "] for factory type [" + factoryType.getName() + "]",
                ex);
        }
    }

}

3.测试

首先在classpath:路径下新建一个META-INF/spring.factories文件，在里面配置如下：

com.beiyou.springboot04.service.StudentService=com.beiyou.springboot04.service.impl.StudentServiceImpl

进行相关的测试

@SpringBootApplication

public class DemoApplication {

    public static void main(String[] args) {
       

        //获取所有META-INF/spring.factories中的value值
        List<String> factoryNames = SpringFactoriesLoader.loadFactoryNames(StudentService.class,  ClassUtils.getDefaultClassLoader());
        for (String name : factoryNames) {
            System.out.println(name);
        }
        //实例化所有在META-INF/spring.factories配置的且实现BeanInfoFactory接口的类
        List<StudentService> list = SpringFactoriesLoader.loadFactories(StudentService.class,DemoApplication.class.getClassLoader());
        System.out.println(list.size());

    }
}

通过以上可以证明，SpringFactoriesLoader会寻找jar包中配置META-INF下的spring.factories配置文件相应Key的value,并根据需要实例化。

如何配置多个实现类？

com.beiyou.springboot04.service.StudentService=\com.beiyou.springboot04.service.impl.StudentServiceImpl,\com.beiyou.springboot04.service.impl.StudentServiceImpl2

运行结果如下：

4.面试题