Spring 源码解析

文章15 |   阅读 8469 |   点赞0

来源：https://github.com/senntyou/blogs

Spring 源码解析十一：Spring 的扩展加载机制

x33g5p2x  于2022-02-11 发布在 Spring  
字(7.5k)|赞(0)|评价(0)|浏览(569)

Spring 的扩展加载机制主要有 2 个：自动加载第三方包中的类、扩展 xml 配置文件中 bean 的命名空间

1. 自动加载第三方包中的类

spring-core 提供了一个类似 Java SPI 的的扩展机制，在 META-INF/spring.factories 文件中定义需要自动加载的类，就可以自动实例化其他包指定的类，spring-boot, spring-cloud 都依赖这个机制自动加载资源。

比如 spring-boot 的扩展（一部分）

  1. # Logging Systems
  2. org.springframework.boot.logging.LoggingSystemFactory=\
  3. org.springframework.boot.logging.logback.LogbackLoggingSystem.Factory,\
  4. org.springframework.boot.logging.log4j2.Log4J2LoggingSystem.Factory,\
  5. org.springframework.boot.logging.java.JavaLoggingSystem.Factory
  7. # PropertySource Loaders
  8. org.springframework.boot.env.PropertySourceLoader=\
  9. org.springframework.boot.env.PropertiesPropertySourceLoader,\
  10. org.springframework.boot.env.YamlPropertySourceLoader
  12. # ConfigData Location Resolvers
  13. org.springframework.boot.context.config.ConfigDataLocationResolver=\
  14. org.springframework.boot.context.config.ConfigTreeConfigDataLocationResolver,\
  15. org.springframework.boot.context.config.StandardConfigDataLocationResolver
  17. # ConfigData Loaders
  18. org.springframework.boot.context.config.ConfigDataLoader=\
  19. org.springframework.boot.context.config.ConfigTreeConfigDataLoader,\
  20. org.springframework.boot.context.config.StandardConfigDataLoader
  22. # Run Listeners
  23. org.springframework.boot.SpringApplicationRunListener=\
  24. org.springframework.boot.context.event.EventPublishingRunListener

实现这个功能的类是 SpringFactoriesLoader

  1. public final class SpringFactoriesLoader {
  2.     // 自动加载文件地址
  3.     public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
  5.     // 加载spring.factories
  6.     public static <T> List<T> loadFactories(Class<T> factoryType, @Nullable ClassLoader classLoader) {
  7.         ClassLoader classLoaderToUse = classLoader;
  8.         if (classLoaderToUse == null) {
  9.             classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
  10.         }
  11.         // 加载spring.factories中的bean名字
  12.         List<String> factoryImplementationNames = loadFactoryNames(factoryType, classLoaderToUse);
  14.         // 结果集
  15.         List<T> result = new ArrayList<>(factoryImplementationNames.size());
  16.         for (String factoryImplementationName : factoryImplementationNames) {
  17.             // 初始化bean，并加入到结果集
  18.             result.add(instantiateFactory(factoryImplementationName, factoryType, classLoaderToUse));
  19.         }
  21.         return result;
  22.     }
  24.     // 加载spring.factories中的bean名字
  25.     public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
  26.         ClassLoader classLoaderToUse = classLoader;
  27.         if (classLoaderToUse == null) {
  28.             classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
  29.         }
  30.         String factoryTypeName = factoryType.getName();
  31.         // 加载spring.factories中的bean定义，并提取出名字
  32.         return loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
  33.     }
  35.     // 加载spring.factories中的bean定义
  36.     private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
  37.         // 如果有缓存，直接返回缓存
  38.         Map<String, List<String>> result = cache.get(classLoader);
  39.         if (result != null) {
  40.             return result;
  41.         }
  43.         // 结果集
  44.         result = new HashMap<>();
  45.         try {
  46.             // 加载所有包下的spring.factories，不光是主包，还有各种依赖包
  47.             Enumeration<URL> urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION);
  48.             // 遍历读取
  49.             while (urls.hasMoreElements()) {
  50.                 URL url = urls.nextElement();
  51.                 UrlResource resource = new UrlResource(url);
  52.                 // 把属性加载出来，以properties文件对待
  53.                 Properties properties = PropertiesLoaderUtils.loadProperties(resource);
  54.                 for (Map.Entry<?, ?> entry : properties.entrySet()) {
  55.                     // bean名字
  56.                     String factoryTypeName = ((String) entry.getKey()).trim();
  57.                     // bean类型，可以用逗号分隔多个
  58.                     String[] factoryImplementationNames =
  59.                             StringUtils.commaDelimitedListToStringArray((String) entry.getValue());
  60.                     // 遍历bean类型
  61.                     for (String factoryImplementationName : factoryImplementationNames) {
  62.                         // 加入到结果集
  63.                         result.computeIfAbsent(factoryTypeName, key -> new ArrayList<>())
  64.                                 .add(factoryImplementationName.trim());
  65.                     }
  66.                 }
  67.             }
  69.             // 去重
  70.             result.replaceAll((factoryType, implementations) -> implementations.stream().distinct()
  71.                     .collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList)));
  72.             // 加入缓存
  73.             cache.put(classLoader, result);
  74.         }
  75.         catch (IOException ex) {
  76.             // ... 代码省略
  77.         }
  78.         return result;
  79.     }
  81.     // 初始化bean
  82.     private static <T> T instantiateFactory(String factoryImplementationName, Class<T> factoryType, ClassLoader classLoader) {
  83.         try {
  84.             // 取出class
  85.             Class<?> factoryImplementationClass = ClassUtils.forName(factoryImplementationName, classLoader);
  86.             // factoryImplementationClass不是factoryType的子类
  87.             if (!factoryType.isAssignableFrom(factoryImplementationClass)) {
  88.                 // 报错
  89.             }
  90.             // 调用newInstance实例化
  91.             return (T) ReflectionUtils.accessibleConstructor(factoryImplementationClass).newInstance();
  92.         }
  93.         catch (Throwable ex) {
  94.             // ... 代码省略
  95.         }
  96.     }
  98. }

然后在 CachedIntrospectionResults
静态加载

  1. public final class CachedIntrospectionResults {
  2.     private static final List<BeanInfoFactory> beanInfoFactories = SpringFactoriesLoader.loadFactories(
  3.             BeanInfoFactory.class, CachedIntrospectionResults.class.getClassLoader());
  4. }

2. 扩展 xml 配置文件中 bean 的命名空间

spring-beans 提供了基于 XML 配置的、第三方对 bean 的命令空间扩展机制，主要是在
META-INF/spring.handlers, META-INF/spring.schemas 文件中定义需要扩展的命令空间，
如 <dubbo:application name="name"/>, <dubbo:registry address="address"/>

比如 spring-beans 下的扩展

  1. http\://www.springframework.org/schema/c=org.springframework.beans.factory.xml.SimpleConstructorNamespaceHandler
  2. http\://www.springframework.org/schema/p=org.springframework.beans.factory.xml.SimplePropertyNamespaceHandler
  3. http\://www.springframework.org/schema/util=org.springframework.beans.factory.xml.UtilNamespaceHandler

实现这个功能的类是 DefaultNamespaceHandlerResolver

  1. public class DefaultNamespaceHandlerResolver implements NamespaceHandlerResolver {
  2.     // 自动加载文件地址
  3.     public static final String DEFAULT_HANDLER_MAPPINGS_LOCATION = "META-INF/spring.handlers";
  5.     // 默认加载DEFAULT_HANDLER_MAPPINGS_LOCATION
  6.     public DefaultNamespaceHandlerResolver() {
  7.         this(null, DEFAULT_HANDLER_MAPPINGS_LOCATION);
  8.     }
  10.     // 默认加载DEFAULT_HANDLER_MAPPINGS_LOCATION
  11.     public DefaultNamespaceHandlerResolver(@Nullable ClassLoader classLoader) {
  12.         this(classLoader, DEFAULT_HANDLER_MAPPINGS_LOCATION);
  13.     }
  15.     public DefaultNamespaceHandlerResolver(@Nullable ClassLoader classLoader, String handlerMappingsLocation) {
  16.         this.classLoader = (classLoader != null ? classLoader : ClassUtils.getDefaultClassLoader());
  17.         this.handlerMappingsLocation = handlerMappingsLocation;
  18.     }
  20.     // 解析命名空间
  21.     @Override
  22.     public NamespaceHandler resolve(String namespaceUri) {
  23.         // 获取命令空间映射
  24.         Map<String, Object> handlerMappings = getHandlerMappings();
  25.         // 获取处理器
  26.         Object handlerOrClassName = handlerMappings.get(namespaceUri);
  28.         // 没有，返回null
  29.         if (handlerOrClassName == null) {
  30.             return null;
  31.         }
  32.         // NamespaceHandler，返回NamespaceHandler
  33.         else if (handlerOrClassName instanceof NamespaceHandler) {
  34.             return (NamespaceHandler) handlerOrClassName;
  35.         }
  36.         else {
  37.             String className = (String) handlerOrClassName;
  38.             try {
  39.                 // 当做类加载
  40.                 Class<?> handlerClass = ClassUtils.forName(className, this.classLoader);
  41.                 // 初始化类，并调用init方法
  42.                 NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);
  43.                 namespaceHandler.init();
  44.                 // 载入缓存
  45.                 handlerMappings.put(namespaceUri, namespaceHandler);
  46.                 return namespaceHandler;
  47.             }
  48.             catch (ClassNotFoundException ex) {
  49.                 // ... 代码省略
  50.             }
  51.             // ... 代码省略
  52.         }
  53.     }
  55.     // 获取命令空间映射
  56.     private Map<String, Object> getHandlerMappings() {
  57.         Map<String, Object> handlerMappings = this.handlerMappings;
  58.         // 如果已经加载过了，就不加载了
  59.         if (handlerMappings == null) {
  60.             synchronized (this) {
  61.                 handlerMappings = this.handlerMappings;
  62.                 if (handlerMappings == null) {
  63.                     try {
  64.                         // 加载所有包下的spring.handlers，不光是主包，还有各种依赖包
  65.                         // 把属性加载出来，以properties文件对待
  66.                         Properties mappings =
  67.                                 PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation, this.classLoader);
  69.                         handlerMappings = new ConcurrentHashMap<>(mappings.size());
  70.                         CollectionUtils.mergePropertiesIntoMap(mappings, handlerMappings);
  72.                         // 赋值给handlerMappings
  73.                         this.handlerMappings = handlerMappings;
  74.                     }
  75.                     catch (IOException ex) {
  76.                         // ... 代码省略
  77.                     }
  78.                 }
  79.             }
  80.         }
  81.         return handlerMappings;
  82.     }
  83. }

因为 DefaultNamespaceHandlerResolver 是默认的命名空间解析器，所以从一开始就会被初始化，所以也就会自动加载 spring.handlers

后续

更多博客，查看 https://github.com/senntyou/blogs

作者：深予之 (@senntyou)

版权声明：自由转载-非商用-非衍生-保持署名（创意共享 3.0 许可证）

内容来源于网络，如有侵权，请联系作者删除！

相关文章

    查看更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com