类说明SpringFactoriesLoader 是 Spring core 包中一个用于读取 classpath 下 META-INFO/spring.factories 文件中某个特定接口对应的实现类并完成实现类实例化的一个工具。该类是final 修饰的即不能被继承不能被修改。内部主要对外暴露了两个 public 类型的静态方法供使用方调用。public final class SpringFactoriesLoader { //定义读取的文件路径相对classpath public static final String FACTORIES_RESOURCE_LOCATION META-INF/spring.factories; private static final Log logger LogFactory.getLog(SpringFactoriesLoader.class); //内部缓存优先从缓存中查找实现类缓存中没有在去读取文件获取 private static final MapClassLoader, MultiValueMapString, String cache new ConcurrentReferenceHashMap(); private SpringFactoriesLoader() { } public static T ListT loadFactories(ClassT factoryType, Nullable ClassLoader classLoader) { Assert.notNull(factoryType, factoryType must not be null); ClassLoader classLoaderToUse classLoader; if (classLoader null) { classLoaderToUse SpringFactoriesLoader.class.getClassLoader(); } //调用loadFactoryNames方法获取 factoryType类型的实现类 ListString factoryImplementationNames loadFactoryNames(factoryType, classLoaderToUse); if (logger.isTraceEnabled()) { logger.trace(Loaded [ factoryType.getName() ] names: factoryImplementationNames); } ListT result new ArrayList(factoryImplementationNames.size()); Iterator var5 factoryImplementationNames.iterator(); while(var5.hasNext()) { String factoryImplementationName (String)var5.next(); //调用instantiateFactory 进行实现类的实例化创建将实例化后的对象添加到result列表中 result.add(instantiateFactory(factoryImplementationName, factoryType, classLoaderToUse)); } // 按优先级排序 AnnotationAwareOrderComparator.sort(result); return result; } public static ListString loadFactoryNames(Class? factoryType, Nullable ClassLoader classLoader) { String factoryTypeName factoryType.getName(); // 从 MultiValueMap 中查询key为 factoryType的实现类如果不存在则返回一个空列表 return (List)loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList()); } private static MapString, ListString loadSpringFactories(Nullable ClassLoader classLoader) { // 根据类加载器从缓存中找 MultiValueMap接口, 实现类 关系缓存 MultiValueMapString, String result (MultiValueMap)cache.get(classLoader); if (result ! null) { return result; } else { try { //获取classpath下所有的 META-INF/spring.factories文件 EnumerationURL urls classLoader ! null ? classLoader.getResources(META-INF/spring.factories) : ClassLoader.getSystemResources(META-INF/spring.factories); LinkedMultiValueMap result new LinkedMultiValueMap(); //循环遍历处理每个spring.factories文件 while(urls.hasMoreElements()) { URL url (URL)urls.nextElement(); UrlResource resource new UrlResource(url); //读取spring.factories 文件内容; spring.factories文件中存的是‘接口’和‘实现类’键值对多个实现类英文逗号分隔 Properties properties PropertiesLoaderUtils.loadProperties(resource); Iterator var6 properties.entrySet().iterator(); //遍历读取到的键值对 while(var6.hasNext()) { Entry?, ? entry (Entry)var6.next(); // 获取keykey为接口全路径名即工厂类型 String factoryTypeName ((String)entry.getKey()).trim(); // 实现类全路径名数组 String[] var9 StringUtils.commaDelimitedListToStringArray((String)entry.getValue()); int var10 var9.length; // 编辑实现类全路径名数组 for(int var11 0; var11 var10; var11) { String factoryImplementationName var9[var11]; //将实现类全路径名添加到以接口全路径名为key的result map中result的value值为列表 result.add(factoryTypeName, factoryImplementationName.trim()); } } } //最后添加到缓存对象中key为classLoader 对象 cache.put(classLoader, result); return result; } catch (IOException var13) { throw new IllegalArgumentException(Unable to load factories from location [META-INF/spring.factories], var13); } } } private static T T instantiateFactory(String factoryImplementationName, ClassT factoryType, ClassLoader classLoader) { try { Class? factoryImplementationClass ClassUtils.forName(factoryImplementationName, classLoader); if (!factoryType.isAssignableFrom(factoryImplementationClass)) { //校验实现类是否实现factoryType接口不是则抛出异常 throw new IllegalArgumentException(Class [ factoryImplementationName ] is not assignable to factory type [ factoryType.getName() ]); } else { //通过反射完成实现类无参构造函数的实例化 return ReflectionUtils.accessibleConstructor(factoryImplementationClass, new Class[0]).newInstance(); } } catch (Throwable var4) { throw new IllegalArgumentException(Unable to instantiate factory class [ factoryImplementationName ] for factory type [ factoryType.getName() ], var4); } } }这个类的逻辑还是比较简单虽然实现简单但是在 Spring Boot 启动过程中起着重要作用它可以很方便的完成 META-INFO/spring.factories 中配置的接口的实现类的装配即完成对象的实例化。单独如何使用由于 SpringFactoriesLoader 在 Spring core 包里这里单独启一个项目只引用code包pom如下dependencies dependency groupIdorg.springframework/groupId artifactIdspring-core/artifactId version5.2.13.RELEASE/version /dependency /dependencies在 src/test/resources/ 目录下添加 META-INFO/spring.factories文件并添加如下图所示的属性其中 com.jl.spring.task.Task 为实现 Runnable 接口的自定义实现类package com.jl.spring.task; public class Task implements Runnable { Override public void run() { System.out.println(run task); } }在 src/test/java 目录下创建 SpringFactoriesLoaderTest 类代码如下import org.springframework.core.io.support.SpringFactoriesLoader; import java.util.List; public class SpringFactoriesLoaderTest { public static void main(String[] args) { ListRunnable tasks SpringFactoriesLoader.loadFactories(Runnable.class, SpringFactoriesLoaderTest.class.getClassLoader()); tasks.forEach(Runnable::run); } }执行代码会看到控制台输出run task说明 SpringFactoriesLoader.loadFactories 成功读取到了配置并完成了实现类的实例化。注spring版本为5.2.13