登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 业界 ›Spring把「手动」的复杂裹成了「自动」的温柔 ...

Spring把「手动」的复杂裹成了「自动」的温柔

谭皎洁 3 天前
案例

案例一：@EnableXXX注解使用
在一个 Spring MVC 项目，通过给配置类加上一个 @EnableWebMvc 注解，加上之后 Spring 就会注册 Spring MVC 的一系列组件，包括：HandlerMapping，HandlerAdapter，ViewResolver 等。
案例二：Spring Boot自动配置
在一个 Spring Boot应用中会有 @SpringBootApplication 注解修饰启动类，当引入 spring-boot-starter-web 依赖之后，Spring 也会自动地注册 Spring MVC 的一系列组件。
那 Spring 中是如何实现自动注册的能力的呢？先说结论：
Spring 中提供了 @Import 注解可以引入一个配置类或者是配置类的选择器。
当使用一般的 @EnableXXX 注解时实际上是通过 @Import 注解引入了预先定义好的配置类，它会配置一些指定的 Bean 来实现对应的功能。
当使用 Spring Boot 的自动配置功能时实际上是通过 @Import 注解引入了一个配置类的选择器，它会读取配置文件中配置的所有配置类，然后判断该配置类的条件是否满足，如果满足，则引入，否则，则不引入，从而实现自动配置某些功能。
源码分析

@EnableXXX注解实现原理

先看一下 @EnableWebMvc 注解，该注解上通过 @Import 注解引用了一个 DelegatingWebMvcConfiguration 配置类，它上面有 @Configuration 注解修饰。代码如下：
  1. @Retention(RetentionPolicy.RUNTIME)
  2. @Target(ElementType.TYPE)
  3. @Documented
  4. @Import(DelegatingWebMvcConfiguration.class)
  5. public @interface EnableWebMvc {
  6. }
  8. @Configuration(proxyBeanMethods = false)  
  9. public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {
  10. }
复制代码
在 DelegatingWebMvcConfiguration 这个配置类的父类 WebMvcConfigurationSupport 中定义了很多由 @Bean 注解修饰的方法，这些就是 Spring 会注册的 Spring MVC 组件类。代码如下：
  1. public class WebMvcConfigurationSupport implements ApplicationContextAware, ServletContextAware {
  2.     // 定义HandlerMapping组件Bean
  3.     @Bean
  4.     @SuppressWarnings("deprecation")
  5.     public RequestMappingHandlerMapping requestMappingHandlerMapping(
  6.             @Qualifier("mvcContentNegotiationManager") ContentNegotiationManager contentNegotiationManager,
  7.             @Qualifier("mvcConversionService") FormattingConversionService conversionService,
  8.             @Qualifier("mvcResourceUrlProvider") ResourceUrlProvider resourceUrlProvider) {
  10.         // 省略代码
  11.     }
  13.     // 定义HandlerAdapter组件Bean
  14.     @Bean
  15.     public RequestMappingHandlerAdapter requestMappingHandlerAdapter(
  16.             @Qualifier("mvcContentNegotiationManager") ContentNegotiationManager contentNegotiationManager,
  17.             @Qualifier("mvcConversionService") FormattingConversionService conversionService,
  18.             @Qualifier("mvcValidator") Validator validator) {
  20.         // 省略代码
  21.     }
  23.     // 定义ViewResolver组件Bean
  24.     @Bean
  25.     public ViewResolver mvcViewResolver(
  26.             @Qualifier("mvcContentNegotiationManager") ContentNegotiationManager contentNegotiationManager) {
  27.         
  28.         // 省略代码
  29.     }
  30. }
复制代码
在3 个案例看透 Spring @Component 扫描：从普通应用到 Spring Boot文章中介绍了 Spring 中如何从 @Configuration 注解修饰的配置类的包扫描路径取扫描 Bean 的。主要是在ConfigurationClassParser 的 doProcessConfigurationClass() 方法中实现的，而对 @Import 注解引用的类也是在该方法中实现的。代码如下：
  1. @Nullable
  2. protected final SourceClass doProcessConfigurationClass(
  3.     ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
  4.     throws IOException {
  6.     // 省略代码
  8.         // 这里处理@Import注解
  9.     // Process any @Import annotations
  10.     processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
  12.     // 省略代码
  14.         // 这里处理@Bean注解修饰的方法
  15.     // Process individual @Bean methods
  16.     Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
  17.     for (MethodMetadata methodMetadata : beanMethods) {
  18.         if (methodMetadata.isAnnotated("kotlin.jvm.JvmStatic") && !methodMetadata.isStatic()) {
  19.             continue;
  20.         }
  21.         // 添加到配置类中
  22.         configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
  23.     }
  25.     // 省略代码
  27.     // No superclass -> processing is complete
  28.     return null;
  29. }
复制代码
在处理 @Import 注解引用的且是 @Configuration 注解修饰的类时，把它当作配置类，递归调用解析配置类的方法 processConfigurationClass()，然后又进入到 doProcessConfigurationClass() 中，解析该类上 @Bean 注解修饰的方法添加到配置类中 。代码如下：
  1. private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
  2.     Collection<SourceClass> importCandidates, Predicate<String> filter, boolean checkForCircularImports) {
  3.     // 省略代码
  5.     if (checkForCircularImports && isChainedImportOnStack(configClass)) {
  6.         // 省略代码
  7.     }
  8.     else {
  9.         this.importStack.push(configClass);
  10.         try {
  11.             for (SourceClass candidate : importCandidates) {
  12.                                 // 省略代码
  14.                 // 处理@Configuration注解修饰的类，就是去把它当作配置类继续解析它的配置
  15.                 this.importStack.registerImport(
  16.                             currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
  17.                 processConfigurationClass(candidate.asConfigClass(configClass), filter);
  18.             }
  19.         } finally {
  20.             this.importStack.pop();
  21.         }
  22.     }
  23. }
复制代码
具体把配置类中的 Bean 方法解析为 Bean 定义则是在 ConfigurationClassPostProcessor 的 processConfigBeanDefinitions() 中调用 ConfigurationClassBeanDefinitionReader 的 loadBeanDefinitionsForBeanMethod() 方法实现的。代码如下：
  1. public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
  2.     // 省略代码
  4.     // Parse each @Configuration class
  5.     ConfigurationClassParser parser = new ConfigurationClassParser(
  6.             this.metadataReaderFactory, this.problemReporter, this.environment,
  7.             this.resourceLoader, this.componentScanBeanNameGenerator, registry);
  9.     Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
  10.     Set<ConfigurationClass> alreadyParsed = CollectionUtils.newHashSet(configCandidates.size());
  11.     do {
  12.             // 省略代码
  13.         parser.parse(candidates);
  14.         parser.validate();
  16.                 // 省略代码
  18.         // 这里调用loadBeanDefinitionsForBeanMethod()解析并注册Bean定义
  19.         this.reader.loadBeanDefinitions(configClasses);
  20.         
  21.         // 省略代码
  22.     }
  23.     while (!candidates.isEmpty());
  25.     // 省略代码
  26. }
复制代码
然后在 ConfigurationClassBeanDefinitionReader 的 loadBeanDefinitionsForBeanMethod() 方法中从 @Bean 注解中获取 initMethod，destroyMethod 这些信息，然后注册 Bean 定义。代码如下：
  1. private void loadBeanDefinitionsForConfigurationClass(
  2.     ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {
  4.     // 省略代码
  5.    
  6.     for (BeanMethod beanMethod : configClass.getBeanMethods()) {
  7.         loadBeanDefinitionsForBeanMethod(beanMethod);
  8.     }
  9.    
  10.     // 省略代码
  11. }
  13. private void loadBeanDefinitionsForBeanMethod(BeanMethod beanMethod) {
  14.     ConfigurationClass configClass = beanMethod.getConfigurationClass();
  15.     MethodMetadata metadata = beanMethod.getMetadata();
  16.     String methodName = metadata.getMethodName();
  18.     // 省略代码
  19.     ConfigurationClassBeanDefinition beanDef = new ConfigurationClassBeanDefinition(configClass, metadata, beanName);
  21.     String initMethodName = bean.getString("initMethod");
  22.     if (StringUtils.hasText(initMethodName)) {
  23.         beanDef.setInitMethodName(initMethodName);
  24.     }
  26.     String destroyMethodName = bean.getString("destroyMethod");
  27.     beanDef.setDestroyMethodName(destroyMethodName);
  29.         // 注册Bean定义
  30.     this.registry.registerBeanDefinition(beanName, beanDefToRegister);
  31. }
复制代码
Spring Boot 自动配置原理

对于一个 Spring Boot 应用上的 @SpringBootApplication 注解是一个组合注解，它上面有 @EnableAutoConfiguration 注解修饰，而这个注解则是实现自动配置的关键。代码如下：
  1. @Target(ElementType.TYPE)  
  2. @Retention(RetentionPolicy.RUNTIME)  
  3. @Documented  
  4. @Inherited  
  5. @SpringBootConfiguration  
  6. @EnableAutoConfiguration  
  7. @ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),  
  8.        @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })  
  9. public @interface SpringBootApplication {}
复制代码
@EnableAutoConfiguration 注解和上面的 @EnableWebMvc 注解类似也是通过 @Import 注解引入了一个类 AutoConfigurationImportSelector，但是这个类却没有 @Configuration 注解修饰，而是实现了 ImportSelector 接口。代码如下：
  1. @Target(ElementType.TYPE)  
  2. @Retention(RetentionPolicy.RUNTIME)  
  3. @Documented  
  4. @Inherited  
  5. @AutoConfigurationPackage  
  6. @Import(AutoConfigurationImportSelector.class)  
  7. public @interface EnableAutoConfiguration {}
  9. public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware,  
  10.        ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {}
复制代码
在上面的 ConfigurationClassParser 类的 processImports() 方法中有一个分支就是判断 @Import 注解引入的类是不是 DeferredImportSelector 接口，如果是则会调用 DeferredImportSelectorHandler 的 handle() 方法进行处理。代码如下：
  1. private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
  2.     Collection<SourceClass> importCandidates, Predicate<String> filter, boolean checkForCircularImports) {
  4.     if (importCandidates.isEmpty()) {
  5.         return;
  6.     }
  8.     if (checkForCircularImports && isChainedImportOnStack(configClass)) {
  9.         this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
  10.     }
  11.     else {
  12.         this.importStack.push(configClass);
  13.         try {
  14.             for (SourceClass candidate : importCandidates) {
  15.                 if (selector instanceof DeferredImportSelector deferredImportSelector) {  
  16.                                             // 调用deferredImportSelectorHandler的handle()方法
  17.                                             this.deferredImportSelectorHandler.handle(configClass, deferredImportSelector);  
  18.                                         }
  19.             }
  20.         } finally {
  21.             this.importStack.pop();
  22.         }
  23.     }
  24. }
复制代码
而 DeferredImportSelectorHandler 的 handle 方法只是先把当前类加入到自己的 deferredImportSelectors 属性中。代码如下：
  1. private class DeferredImportSelectorHandler {
  2.     @Nullable
  3.     private List<DeferredImportSelectorHolder> deferredImportSelectors = new ArrayList<>();
  5.     void handle(ConfigurationClass configClass, DeferredImportSelector importSelector) {
  6.         DeferredImportSelectorHolder holder = new DeferredImportSelectorHolder(configClass, importSelector);
  7.         if (this.deferredImportSelectors == null) {
  8.             DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler();
  9.             handler.register(holder);
  10.             handler.processGroupImports();
  11.         }
  12.         else {
  13.             this.deferredImportSelectors.add(holder);
  14.         }
  15.     }
  16. }
复制代码
最后在 ConfigurationClassParser 的 parse() 方法最后调用它的 process() 方法。在 DeferredImportSelectorHandler 的 process() 方法中又调用了 DeferredImportSelectorHolder 的 processGroupImport() 方法。代码如下：
  1. public void parse(Set<BeanDefinitionHolder> configCandidates) {
  2.     // 省略代码
  4.     this.deferredImportSelectorHandler.process();
  5. }
  7. void handle(ConfigurationClass configClass, DeferredImportSelector importSelector) {
  8.     DeferredImportSelectorHolder holder = new DeferredImportSelectorHolder(configClass, importSelector);
  9.     if (this.deferredImportSelectors == null) {
  10.         DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler();
  11.         handler.register(holder);
  12.         handler.processGroupImports();
  13.     }
  14.     else {
  15.         this.deferredImportSelectors.add(holder);
  16.     }
  17. }
  19. private class DeferredImportSelectorGroupingHandler {
  20.     @SuppressWarnings("NullAway")
  21.     void processGroupImports() {
  22.         for (DeferredImportSelectorGrouping grouping : this.groupings.values()) {
  23.             Predicate<String> filter = grouping.getCandidateFilter();
  24.             // 调用getImports()方法获取到配置类，然后在递归调用processImports()方法
  25.             grouping.getImports().forEach(entry -> {
  26.                 ConfigurationClass configurationClass = this.configurationClasses.get(entry.getMetadata());
  27.                 try {
  28.                     processImports(configurationClass, asSourceClass(configurationClass, filter),
  29.                             Collections.singleton(asSourceClass(entry.getImportClassName(), filter)),
  30.                             filter, false);
  31.                 }
  32.                 // 省略代码
  33.             });
  34.         }
  35.     }
  36. }
复制代码
然后调用到了 AutoConfigurationGroup 的 process() 方法，在该方法中会调用 AutoConfigurationImportSelector 的 getAutoConfigurationEntry() 方法，这个里这个类就是通过 @EnableAutoConfiguration 引入的类了。代码如下：
  1. private static final class AutoConfigurationGroup
  2.     implements DeferredImportSelector.Group, BeanClassLoaderAware, BeanFactoryAware, ResourceLoaderAware {
  3.     @Override
  4.     public void process(AnnotationMetadata annotationMetadata, DeferredImportSelector deferredImportSelector) {
  5.         // 省略代码
  6.         
  7.         // 调用AutoConfigurationImportSelector的getAutoConfigurationEntry()方法
  8.         AutoConfigurationEntry autoConfigurationEntry = autoConfigurationImportSelector
  9.             .getAutoConfigurationEntry(annotationMetadata);
  10.             
  11.         this.autoConfigurationEntries.add(autoConfigurationEntry);
  12.         for (String importClassName : autoConfigurationEntry.getConfigurations()) {
  13.             this.entries.putIfAbsent(importClassName, annotationMetadata);
  14.         }
  15.     }
  16. }
复制代码
在 AutoConfigurationImportSelector 的 getAutoConfigurationEntry() 方法调用 ImportCandidates 读取默认值为 org.springframework.boot.autoconfigure.AutoConfiguration.imports 文件中列举的配置类，然后过滤掉不满足条件的配置类，过滤的方式可以是判断 CLASSPATH 路径下某些类是否存在。代码如下：
  1. AutoConfigurationImportSelector{
  2.         protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
  3.         // 省略代码
  4.         
  5.         // 获取所有配置类
  6.         List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
  7.         
  8.         // 过滤掉不满足条件的配置类
  9.         configurations = getConfigurationClassFilter().filter(configurations);
  10.         fireAutoConfigurationImportEvents(configurations, exclusions);
  11.         return new AutoConfigurationEntry(configurations, exclusions);
  12.     }
  14.     protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
  15.         ImportCandidates importCandidates = ImportCandidates.load(this.autoConfigurationAnnotation,
  16.                 getBeanClassLoader());
  17.         return configurations;
  18.     }
  19. }
  21. public final class ImportCandidates implements Iterable<String> {
  23.     private static final String LOCATION = "META-INF/spring/%s.imports";
  24.    
  25.     public static ImportCandidates load(Class<?> annotation, ClassLoader classLoader) {
  26.         ClassLoader classLoaderToUse = decideClassloader(classLoader);
  27.         // 这里就是配置类所在文件，默认是org.springframework.boot.autoconfigure.AutoConfiguration.imports
  28.         String location = String.format(LOCATION, annotation.getName());
  29.         Enumeration<URL> urls = findUrlsInClasspath(classLoaderToUse, location);
  30.         List<String> importCandidates = new ArrayList<>();
  31.         while (urls.hasMoreElements()) {
  32.             URL url = urls.nextElement();
  33.             importCandidates.addAll(readCandidateConfigurations(url));
  34.         }
  35.         return new ImportCandidates(importCandidates);
  36.     }
  37. }
复制代码
org.springframework.boot.autoconfigure.AutoConfiguration.imports 文件中内容如下：
1.png

这里以 WebMvcAutoConfiguration 配置类为例，它要不被过滤掉的条件是 CLASSPATH 路径下存在 Servlet, DispatcherServlet, WebMvcConfigurer 这些类，即这些类存在则会解析 WebMvcAutoConfiguration 配置类配置的 Bean，从而实现 Spring MVC 组件的 Bean 的注册。代码如下：
  1. @AutoConfiguration(after = { DispatcherServletAutoConfiguration.class, TaskExecutionAutoConfiguration.class,  
  2.        ValidationAutoConfiguration.class })  
  3. @ConditionalOnWebApplication(type = Type.SERVLET)  
  4. @ConditionalOnClass({ Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })  
  5. @ConditionalOnMissingBean(WebMvcConfigurationSupport.class)  
  6. @AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)  
  7. @ImportRuntimeHints(WebResourcesRuntimeHints.class)  
  8. public class WebMvcAutoConfiguration {}
复制代码
来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

使用道具 举报
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
谭皎洁
3 天前

0

粉丝关注

10

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫