// SpringFactoriesLoader.java/*** General purpose factory loading mechanism for internal use within the framework.** <p>{@code SpringFactoriesLoader} {@linkplain #loadFactories loads} and instantiates* factories of a given type from {@value #FACTORIES_RESOURCE_LOCATION} files which* may be present in multiple JAR files in the classpath. The {@code spring.factories}* file must be in {@link Properties} format, where the key is the fully qualified* name of the interface or abstract class, and the value is a comma-separated list of* implementation class names. For example:** <pre class="code">example.MyService=example.MyServiceImpl1,example.MyServiceImpl2</pre>** where {@code example.MyService} is the name of the interface, and {@code MyServiceImpl1}* and {@code MyServiceImpl2} are two implementations.*/

// SpringFactoriesLoader.java/*** The location to look for factories.* <p>Can be present in multiple JAR files.*/
public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";private static final Log logger = LogFactory.getLog(SpringFactoriesLoader.class);/*** 缓存** KEY1 ：ClassLoader* KEY2 ：接口的类名* VALUE ：实现的类名的数组。注意哟，是个 MultiValueMap 类*/
private static final Map<ClassLoader, MultiValueMap<String, String>> cache = new ConcurrentReferenceHashMap<>();private SpringFactoriesLoader() {
}

// SpringFactoriesLoader.java/*** Load the fully qualified class names of factory implementations of the* given type from {@value #FACTORIES_RESOURCE_LOCATION}, using the given* class loader.* @param factoryClass the interface or abstract class representing the factory* @param classLoader the ClassLoader to use for loading resources; can be* {@code null} to use the default* @throws IllegalArgumentException if an error occurs while loading factory names* @see #loadFactories*/
public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {// 获得接口的类名String factoryClassName = factoryClass.getName();// 加载 FACTORIES_RESOURCE_LOCATION 配置文件，获得接口对应的实现类名们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 {// 获得 FACTORIES_RESOURCE_LOCATION 对应的 URL 们Enumeration<URL> urls = (classLoader != null ? classLoader.getResources(FACTORIES_RESOURCE_LOCATION) : ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));// 创建 LinkedMultiValueMap 对象result = new LinkedMultiValueMap<>();// 遍历 URL 数组while (urls.hasMoreElements()) {// 获得 URLURL url = urls.nextElement();// 创建 UrlResource 对象UrlResource resource = new UrlResource(url);// 加载 "META-INF/spring.factories" 配置文件，成为 Properties 对象Properties properties = PropertiesLoaderUtils.loadProperties(resource);// 遍历 Properties 对象for (Map.Entry<?, ?> entry : properties.entrySet()) {// 使用逗号分隔List<String> factoryClassNames = Arrays.asList(StringUtils.commaDelimitedListToStringArray((String) entry.getValue()));// 添加到 result 中result.addAll((String) entry.getKey(), factoryClassNames);}}// 添加到 cache 中cache.put(classLoader, result);return result;} catch (IOException ex) {throw new IllegalArgumentException("Unable to load factories from location [" + FACTORIES_RESOURCE_LOCATION + "]", ex);}
}

// SpringFactoriesLoader.java/*** Load and instantiate the factory implementations of the given type from* {@value #FACTORIES_RESOURCE_LOCATION}, using the given class loader.* <p>The returned factories are sorted through {@link AnnotationAwareOrderComparator}.* <p>If a custom instantiation strategy is required, use {@link #loadFactoryNames}* to obtain all registered factory names.* @param factoryClass the interface or abstract class representing the factory* @param classLoader the ClassLoader to use for loading (can be {@code null} to use the default)* @throws IllegalArgumentException if any factory implementation class cannot* be loaded or if an error occurs while instantiating any factory* @see #loadFactoryNames*/
public static <T> List<T> loadFactories(Class<T> factoryClass, @Nullable ClassLoader classLoader) {Assert.notNull(factoryClass, "'factoryClass' must not be null");// 获得 ClassLoaderClassLoader classLoaderToUse = classLoader;if (classLoaderToUse == null) {classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();}// 获得接口对应的实现类名们List<String> factoryNames = loadFactoryNames(factoryClass, classLoaderToUse);if (logger.isTraceEnabled()) {logger.trace("Loaded [" + factoryClass.getName() + "] names: " + factoryNames);}// 遍历 factoryNames 数组，创建实现类的对象List<T> result = new ArrayList<>(factoryNames.size());for (String factoryName : factoryNames) {result.add(instantiateFactory(factoryName, factoryClass, classLoaderToUse));}// 排序AnnotationAwareOrderComparator.sort(result);return result;
}private static <T> T instantiateFactory(String instanceClassName, Class<T> factoryClass, ClassLoader classLoader) {try {// 获得 Class 类Class<?> instanceClass = ClassUtils.forName(instanceClassName, classLoader);// 判断是否实现了指定接口if (!factoryClass.isAssignableFrom(instanceClass)) {throw new IllegalArgumentException("Class [" + instanceClassName + "] is not assignable to [" + factoryClass.getName() + "]");}// 创建对象return (T) ReflectionUtils.accessibleConstructor(instanceClass).newInstance();} catch (Throwable ex) {throw new IllegalArgumentException("Unable to instantiate factory class: " + factoryClass.getName(), ex);}
}