理解自动配置Bean(auto-configuration)

自动配置类是标准的@Configuration类，附加用来限制是否生效的条件注解(@Conditional)。如
@ConditionalOnClass @ConditionalOnMissingBean 注解. 这个可以确认在相关的类存在或未申明某Bean时才生效这个自动配置类。

自动配置类放置在类路径classpash下的META-INF/spring.factories文件里。SpringBoot自带的spring.factories在spring-boot-autoconfiguration模块jar里，默认的配置内容有(当前版本:2.30)：

  1. # Initializers
  2. org.springframework.context.ApplicationContextInitializer=\
  3. org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\
  4. org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener
  6. # Application Listeners
  7. org.springframework.context.ApplicationListener=\
  8. org.springframework.boot.autoconfigure.BackgroundPreinitializer
  10. # Auto Configuration Import Listeners
  11. org.springframework.boot.autoconfigure.AutoConfigurationImportListener=\
  12. org.springframework.boot.autoconfigure.condition.ConditionEvaluationReportAutoConfigurationImportListener
  14. # Auto Configuration Import Filters
  15. org.springframework.boot.autoconfigure.AutoConfigurationImportFilter=\
  16. org.springframework.boot.autoconfigure.condition.OnBeanCondition,\
  17. org.springframework.boot.autoconfigure.condition.OnClassCondition,\
  18. org.springframework.boot.autoconfigure.condition.OnWebApplicationCondition
  20. # Auto Configure
  21. org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  22. org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
  23. org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
  25. org.springframework.boot.autoconfigure.gson.GsonAutoConfiguration,\
  27. ....

查找自己的自动配置候选类

在自己的Maven工程里，新建一份spring.factories文件放到recourses/META-INF/目录下：

  1. app
  2. --src
  3.     --main
  4.         --resources
  5.             --    META-INF
  6.                 --spring.factories
  7.     --test

配置内容格式为，属性键值对，Key=org.springframework.boot.autoconfigure.EnableAutoConfiguration

  1. org.springframework.boot.autoconfigure.EnableAutoConfiguration=xxx.emoAutoConfiguration

自动配置只能用这种方式存储并加载，需要确保这个路径不会被自动扫描，同时不能配置类似@ComponentScan这样的注解，但是可以配置@Import来导入额外的配置类。

可以使用@AutoConfigureAfter,@AutoConfigureBefore注解来应用配置类在特定的顺序下。例如如果是Web应用，你一般需要再WebMvcAutoConfiguration生效只会才加载你自己的配置类。同时你还可以使用@AutoConfigureOrder来指定你的配置类的生效顺序。

使用条件注解(@Conditional)

Class Conditions

@ConditionalOnClass

通过查找Name是否存在，如果存在配置类会被注册为Bean，同时生效配置类中的@Bean.

  1. @Configuration(proxyBeanMethods = true)
  2.     static class OnClassCondition {
  4.         // Auto-configured beans
  5.         @Bean
  6.         public List<String> list() {
  7.             return Lists.newArrayList("A", "B");
  8.         }
  10.         @Bean("userService")
  11.         public UserService userService1() {
  12.             return new UserService();
  13.         }
  15.         @Bean
  16.         @ConditionalOnMissingBean(name = "userService2")
  17.         public UserService userService2() {
  18.             return new UserService();
  19.         }
  21.         @Configuration(proxyBeanMethods = false)
  22.         @ConditionalOnClass(name = "org.test.EmbeddedAcmeService")
  23.         static class EmbeddedConfiguration {
  25.             @Bean
  26.             public String hello() {
  27.                 return "Hello";
  28.             }
  30.             @Bean
  31.             @ConditionalOnMissingBean
  32.             public UserService userService() {
  33.                 return new UserService();
  34.             }
  36.         }
  37.     }
  39.     @Test
  40.     public void testOnClassCondition() {
  42.         ApplicationContextRunner contextRunner = new ApplicationContextRunner()
  43.                 .withConfiguration(AutoConfigurations.of(OnClassCondition.class));
  45.         contextRunner.withUserConfiguration(OnClassCondition.class).run((context) -> {
  47.             System.out.println(Arrays.toString(context.getBeanDefinitionNames()));
  48.             assertThat(context).getBean(OnClassCondition.class).isNotNull();
  49.             List<String> list  = (List<String>) context.getBean("list");
  50.             assertThat(list).hasSize(2);
  52.             assertThat(context).getBean(UserService.class).isNull();
  53.             assertThat(context).getBean("hello").isNull();
  54.         });
  55.     }

@ConditionalOnMissingClass

如果Name指定的类不存在，则配置类生效，会被注册为Bean，同时生效配置类里的@Bean

  1. @Configuration(proxyBeanMethods = false)
  2.     static class OnClassMissingCondition {
  4.         // Auto-configured beans
  6.         @Configuration(proxyBeanMethods = false)
  7.         @ConditionalOnMissingClass("org.test.EmbeddedAcmeService")
  8.         static class EmbeddedConfiguration {
  10.             @Bean
  11.             public String hello() {
  12.                 return "world";
  13.             }
  15.             @Bean
  16.             @ConditionalOnMissingBean
  17.             public UserService userService() {
  18.                 return new UserService();
  19.             }
  21.         }
  22.     }
  24.     @Test
  25.     public void testOnClassMissingCondition() {
  27.         ApplicationContextRunner contextRunner = new ApplicationContextRunner()
  28.                 .withConfiguration(AutoConfigurations.of(OnClassMissingCondition.class));
  30.         contextRunner.withUserConfiguration(OnClassMissingCondition.class).run((context) -> {
  32.             System.out.println(Arrays.toString(context.getBeanDefinitionNames()));
  33.             assertThat(context).getBean(OnClassMissingCondition.class).isNotNull();
  34.             assertThat(context).getBean(OnClassMissingCondition.EmbeddedConfiguration.class).isNotNull();
  35.             assertThat(context).getBean(UserService.class).isNotNull();
  36.             assertThat(context).getBean("hello").hasToString("world");
  37.         });
  38.     }

Bean Conditions

@ConditionalOnMissingBean

Bean不存在时则生效配置类

@ConditionalOnBean

Bean存在时则生效配置类

Property Conditions

@ConditionalOnProperty

属性文件里配置了某属性=true，才生效。matchIfMission=true,表示如没有这个属性，默认生效。
如：spring.example.enble=true

  1. @Configuration(proxyBeanMethods = false)
  2.     @ConditionalOnProperty(prefix = "spring.example", name = "enable", matchIfMissing = true)
  3.     static class OnPropertyCondition {
  5.         @Bean
  6.         public UserService userService() {
  7.             return new UserService();
  8.         }
  9.     }
  11.     @Test
  12.     public void testOnPropertyCondition() {
  13.         ApplicationContextRunner contextRunner = new ApplicationContextRunner()
  14.                 .withConfiguration(AutoConfigurations.of(OnPropertyCondition.class));
  15.         contextRunner
  16.                 .withUserConfiguration(OnPropertyCondition.class)
  17.                 .withPropertyValues("spring.example.enable=false")
  18.                 .run((context) -> {
  20.             System.out.println(Arrays.toString(context.getBeanDefinitionNames()));
  21.             assertThat(context).getBean(OnPropertyCondition.class).isNull();
  22.             assertThat(context).getBean(UserService.class).isNull();
  23.         });
  24.     }

SpringBoot内置AutoConfiguration示例

AopAutoConfiguration

ConditionalOnProperty+ConditionalOnClass

  1. /**
  2.  * {@link org.springframework.boot.autoconfigure.EnableAutoConfiguration
  3.  * Auto-configuration} for Spring's AOP support. Equivalent to enabling
  4.  * {@link EnableAspectJAutoProxy @EnableAspectJAutoProxy} in your configuration.
  5.  * <p>
  6.  * The configuration will not be activated if {@literal spring.aop.auto=false}. The
  7.  * {@literal proxyTargetClass} attribute will be {@literal true}, by default, but can be
  8.  * overridden by specifying {@literal spring.aop.proxy-target-class=false}.
  9.  *
  10.  * @author Dave Syer
  11.  * @author Josh Long
  12.  * @since 1.0.0
  13.  * @see EnableAspectJAutoProxy
  14.  */
  15. @Configuration(proxyBeanMethods = false)
  16. @ConditionalOnProperty(prefix = "spring.aop", name = "auto", havingValue = "true", matchIfMissing = true)
  17. public class AopAutoConfiguration {
  19.     @Configuration(proxyBeanMethods = false)
  20.     @ConditionalOnClass(Advice.class)
  21.     static class AspectJAutoProxyingConfiguration {
  23.         @Configuration(proxyBeanMethods = false)
  24.         @EnableAspectJAutoProxy(proxyTargetClass = false)
  25.         @ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "false",
  26.                 matchIfMissing = false)
  27.         static class JdkDynamicAutoProxyConfiguration {
  29.         }
  31.         @Configuration(proxyBeanMethods = false)
  32.         @EnableAspectJAutoProxy(proxyTargetClass = true)
  33.         @ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true",
  34.                 matchIfMissing = true)
  35.         static class CglibAutoProxyConfiguration {
  37.         }
  39.     }
  41.     @Configuration(proxyBeanMethods = false)
  42.     @ConditionalOnMissingClass("org.aspectj.weaver.Advice")
  43.     @ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true",
  44.             matchIfMissing = true)
  45.     static class ClassProxyingConfiguration {
  47.         ClassProxyingConfiguration(BeanFactory beanFactory) {
  48.             if (beanFactory instanceof BeanDefinitionRegistry) {
  49.                 BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
  50.                 AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);
  51.                 AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
  52.             }
  53.         }
  55.     }
  57. }

PropertyPlaceholderAutoConfiguration

AutoConfigureOrder+ConditionalOnMissingBean

  1. @Configuration(proxyBeanMethods = false)
  2. @AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
  3. public class PropertyPlaceholderAutoConfiguration {
  5.     @Bean
  6.     @ConditionalOnMissingBean(search = SearchStrategy.CURRENT)
  7.     public static PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer() {
  8.         return new PropertySourcesPlaceholderConfigurer();
  9.     }
  11. }

DispatcherServletAutoConfiguration

ConditionalOnClass+EnableConfigurationProperties

  1. @AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
  2. @Configuration(proxyBeanMethods = false)
  3. @ConditionalOnWebApplication(type = Type.SERVLET)
  4. @ConditionalOnClass(DispatcherServlet.class)
  5. @AutoConfigureAfter(ServletWebServerFactoryAutoConfiguration.class)
  6. public class DispatcherServletAutoConfiguration {
  8.     /*
  9.      * The bean name for a DispatcherServlet that will be mapped to the root URL "/"
  10.      */
  11.     public static final String DEFAULT_DISPATCHER_SERVLET_BEAN_NAME = "dispatcherServlet";
  13.     /*
  14.      * The bean name for a ServletRegistrationBean for the DispatcherServlet "/"
  15.      */
  16.     public static final String DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME = "dispatcherServletRegistration";
  18.     @Configuration(proxyBeanMethods = false)
  19.     @Conditional(DefaultDispatcherServletCondition.class)
  20.     @ConditionalOnClass(ServletRegistration.class)
  21.     @EnableConfigurationProperties(WebMvcProperties.class)
  22.     protected static class DispatcherServletConfiguration {
  24.         @Bean(name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
  25.         public DispatcherServlet dispatcherServlet(WebMvcProperties webMvcProperties) {
  26.             DispatcherServlet dispatcherServlet = new DispatcherServlet();
  27.             dispatcherServlet.setDispatchOptionsRequest(webMvcProperties.isDispatchOptionsRequest());
  28.             dispatcherServlet.setDispatchTraceRequest(webMvcProperties.isDispatchTraceRequest());
  29.             dispatcherServlet.setThrowExceptionIfNoHandlerFound(webMvcProperties.isThrowExceptionIfNoHandlerFound());
  30.             dispatcherServlet.setPublishEvents(webMvcProperties.isPublishRequestHandledEvents());
  31.             dispatcherServlet.setEnableLoggingRequestDetails(webMvcProperties.isLogRequestDetails());
  32.             return dispatcherServlet;
  33.         }
  35.         @Bean
  36.         @ConditionalOnBean(MultipartResolver.class)
  37.         @ConditionalOnMissingBean(name = DispatcherServlet.MULTIPART_RESOLVER_BEAN_NAME)
  38.         public MultipartResolver multipartResolver(MultipartResolver resolver) {
  39.             // Detect if the user has created a MultipartResolver but named it incorrectly
  40.             return resolver;
  41.         }
  43.     }
  44. }