SpringBoot--如何创建自己的自动配置

在实际开发中，仅靠SpringBoot的自动配置是远远不够的，比如要访问多个数据源，自动配置就完全无能为力了。
自动配置的本质

本质就是在容器中预配置要整合的框架所需的基础Bean。
以MyBatis为例，spring整合MyBatis无非就是完成以下事情：

• 配置SqlSessionFactory Bean，当然，该Bean需要注入一个DataSource
  
• 配置SqlSessionTemplate Bean，将上面的SqlSessionFactory 注入该Bean
  
• 注册Mapper组件的自动扫描，相当于添加元素
  

自动配置非常简单，无非就是有框架提供一个@Configuration修饰的配置类（相当于传统的xml配置文件），在该配置类中用@Bean预先配置默认的SqlSessionFactory、SqlSessionTemplate，并注册Mapper组件的自动扫描即可。
比如MybatisAutoConfiguration源代码：

1. @Configuration // 被修饰的类变成配置类
2. // 当SqlSessionFactory、SqlSessionFactoryBean类存在时，才会生效。
3. // 条件注解之一
4. @ConditionalOnClass({SqlSessionFactory.class, SqlSessionFactoryBean.class})
5. // 当DataSource Bean存在时，才会生效
6. // 条件注解之一
7. @ConditionalOnSingleCandidate(DataSource.class)
8. // 启用Mybatis的属性处理类
9. // 启动属性处理类
10. @EnableConfigurationProperties({MybatisProperties.class})
11. //指定该配置类在DataSourceAutoConfiguration和MybatisLanguageDriverAutoConfiguration之后加载
12. @AutoConfigureAfter({DataSourceAutoConfiguration.class, MybatisLanguageDriverAutoConfiguration.class})
13. // 实现 InitializingBean 接口，该接口中的 afterPropertiesSet 方法会在该Bean初始化完成后被自动调用
14. public class MybatisAutoConfiguration implements InitializingBean {
15.     private static final Logger logger = LoggerFactory.getLogger(org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration.class);
16.     // Mybatis的配置属性
17.     private final MybatisProperties properties;
18.     // Mybatis的拦截器、类型处理器、语言驱动等
19.     private final Interceptor[] interceptors;
20.     private final TypeHandler[] typeHandlers;
21.     private final LanguageDriver[] languageDrivers;
22.     private final ResourceLoader resourceLoader;
23.     private final DatabaseIdProvider databaseIdProvider;
24.     private final List<ConfigurationCustomizer> configurationCustomizers;
25.     private final List<SqlSessionFactoryBeanCustomizer> sqlSessionFactoryBeanCustomizers;
27.     public MybatisAutoConfiguration(MybatisProperties properties, ObjectProvider<Interceptor[]> interceptorsProvider, ObjectProvider<TypeHandler[]> typeHandlersProvider, ObjectProvider<LanguageDriver[]> languageDriversProvider, ResourceLoader resourceLoader, ObjectProvider<DatabaseIdProvider> databaseIdProvider, ObjectProvider<List<ConfigurationCustomizer>> configurationCustomizersProvider, ObjectProvider<List<SqlSessionFactoryBeanCustomizer>> sqlSessionFactoryBeanCustomizers) {
28.         this.properties = properties;
29.         this.interceptors = (Interceptor[])interceptorsProvider.getIfAvailable();
30.         this.typeHandlers = (TypeHandler[])typeHandlersProvider.getIfAvailable();
31.         this.languageDrivers = (LanguageDriver[])languageDriversProvider.getIfAvailable();
32.         this.resourceLoader = resourceLoader;
33.         this.databaseIdProvider = (DatabaseIdProvider)databaseIdProvider.getIfAvailable();
34.         this.configurationCustomizers = (List)configurationCustomizersProvider.getIfAvailable();
35.         this.sqlSessionFactoryBeanCustomizers = (List)sqlSessionFactoryBeanCustomizers.getIfAvailable();
36.     }
38.     // 在Bean初始化完成后调用该方法
39.     public void afterPropertiesSet() {
40.         this.checkConfigFileExists();
41.     }
43.     // 检查Mybatis配置文件是否存在
44.     private void checkConfigFileExists() {
45.         if (this.properties.isCheckConfigLocation() && StringUtils.hasText(this.properties.getConfigLocation())) {
46.             // 获取配置文件的资源
47.             Resource resource = this.resourceLoader.getResource(this.properties.getConfigLocation());
48.             // 如果resource.exists()方法返回false，则抛出异常
49.             Assert.state(resource.exists(), "Cannot find config location: " + resource + " (please add config file or check your Mybatis configuration)");
50.         }
52.     }
54.     // 创建SqlSessionFactory Bean
55.     @Bean
56.     // 当没有SqlSessionFactory Bean时才会创建
57.     @ConditionalOnMissingBean
58.     public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
59.         // 创建SqlSessionFactoryBean实例
60.         SqlSessionFactoryBean factory = new SqlSessionFactoryBean();
61.         // 注入数据源
62.         factory.setDataSource(dataSource);
63.         factory.setVfs(SpringBootVFS.class);
64.         // 如果配置文件路径不为空，则设置配置文件位置
65.         if (StringUtils.hasText(this.properties.getConfigLocation())) {
66.             factory.setConfigLocation(this.resourceLoader.getResource(this.properties.getConfigLocation()));
67.         }
69.         this.applyConfiguration(factory);
70.         // 如果配置属性不为空，则设置配置属性
71.         if (this.properties.getConfigurationProperties() != null) {
72.             factory.setConfigurationProperties(this.properties.getConfigurationProperties());
73.         }
74.         // 应用所有的拦截器
75.         if (!ObjectUtils.isEmpty(this.interceptors)) {
76.             factory.setPlugins(this.interceptors);
77.         }
78.         // 应用所有databaseIdProvider
79.         if (this.databaseIdProvider != null) {
80.             factory.setDatabaseIdProvider(this.databaseIdProvider);
81.         }
82.         // 根据包名应用TypeAliases
83.         if (StringUtils.hasLength(this.properties.getTypeAliasesPackage())) {
84.             factory.setTypeAliasesPackage(this.properties.getTypeAliasesPackage());
85.         }
86.         // 根据父类型应用TypeAliases
87.         if (this.properties.getTypeAliasesSuperType() != null) {
88.             factory.setTypeAliasesSuperType(this.properties.getTypeAliasesSuperType());
89.         }
90.         // 根据包名应用TypeHandler
91.         if (StringUtils.hasLength(this.properties.getTypeHandlersPackage())) {
92.             factory.setTypeHandlersPackage(this.properties.getTypeHandlersPackage());
93.         }
94.         // 应用所有TypeHandler
95.         if (!ObjectUtils.isEmpty(this.typeHandlers)) {
96.             factory.setTypeHandlers(this.typeHandlers);
97.         }
98.         // 设置mapper的加载位置
99.         if (!ObjectUtils.isEmpty(this.properties.resolveMapperLocations())) {
100.             factory.setMapperLocations(this.properties.resolveMapperLocations());
101.         }
103.         Set<String> factoryPropertyNames = (Set) Stream.of((new BeanWrapperImpl(SqlSessionFactoryBean.class)).getPropertyDescriptors()).map(FeatureDescriptor::getName).collect(Collectors.toSet());
104.         Class<? extends LanguageDriver> defaultLanguageDriver = this.properties.getDefaultScriptingLanguageDriver();
105.         if (factoryPropertyNames.contains("scriptingLanguageDrivers") && !ObjectUtils.isEmpty(this.languageDrivers)) {
106.             factory.setScriptingLanguageDrivers(this.languageDrivers);
107.             if (defaultLanguageDriver == null && this.languageDrivers.length == 1) {
108.                 defaultLanguageDriver = this.languageDrivers[0].getClass();
109.             }
110.         }
112.         if (factoryPropertyNames.contains("defaultScriptingLanguageDriver")) {
113.             factory.setDefaultScriptingLanguageDriver(defaultLanguageDriver);
114.         }
116.         this.applySqlSessionFactoryBeanCustomizers(factory);
117.         // 返回SqlSessionFactory对象
118.         return factory.getObject();
119.     }
121.     private void applyConfiguration(SqlSessionFactoryBean factory) {
122.         org.apache.ibatis.session.Configuration configuration = this.properties.getConfiguration();
123.         if (configuration == null && !StringUtils.hasText(this.properties.getConfigLocation())) {
124.             configuration = new org.apache.ibatis.session.Configuration();
125.         }
127.         if (configuration != null && !CollectionUtils.isEmpty(this.configurationCustomizers)) {
128.             Iterator var3 = this.configurationCustomizers.iterator();
130.             while(var3.hasNext()) {
131.                 ConfigurationCustomizer customizer = (ConfigurationCustomizer)var3.next();
132.                 customizer.customize(configuration);
133.             }
134.         }
136.         factory.setConfiguration(configuration);
137.     }
139.     private void applySqlSessionFactoryBeanCustomizers(SqlSessionFactoryBean factory) {
140.         if (!CollectionUtils.isEmpty(this.sqlSessionFactoryBeanCustomizers)) {
141.             Iterator var2 = this.sqlSessionFactoryBeanCustomizers.iterator();
143.             while(var2.hasNext()) {
144.                 SqlSessionFactoryBeanCustomizer customizer = (SqlSessionFactoryBeanCustomizer)var2.next();
145.                 customizer.customize(factory);
146.             }
147.         }
149.     }
151.     // 创建SqlSessionTemplate Bean
152.     @Bean
153.     // 当没有SqlSessionTemplate Bean时才会创建
154.     @ConditionalOnMissingBean
155.     public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
156.         ExecutorType executorType = this.properties.getExecutorType();
157.         // 如果executorType不为null，则创建SqlSessionTemplate时使用该executorType
158.         return executorType != null ? new SqlSessionTemplate(sqlSessionFactory, executorType) : new SqlSessionTemplate(sqlSessionFactory);
159.     }
161.     @Configuration
162.     // 导入MapperScannerRegistrarNotFoundConfiguration注册类
163.     @Import({org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration.AutoConfiguredMapperScannerRegistrar.class})
164.     // 当MapperFactoryBean和MapperScannerConfigurer都不存在时，才会生效
165.     @ConditionalOnMissingBean({MapperFactoryBean.class, MapperScannerConfigurer.class})
166.     // 实现 InitializingBean 接口，该接口中的 afterPropertiesSet 方法会在该Bean初始化完成后被自动调用
167.     public static class MapperScannerRegistrarNotFoundConfiguration implements InitializingBean {
168.         public MapperScannerRegistrarNotFoundConfiguration() {
169.         }
171.         // 重写afterPropertiesSet方法
172.         public void afterPropertiesSet() {
173.             org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration.logger.debug("Not found configuration for registering mapper bean using @MapperScan, MapperFactoryBean and MapperScannerConfigurer.");
174.         }
175.     }
177.     // 注册Mapper扫描器的自动配置类
178.     // 实现 BeanFactoryAware接口可访问spring容器、
179.     // 实现ImportBeanDefinitionRegistrar 接口可配置额外的bean
180.     public static class AutoConfiguredMapperScannerRegistrar implements BeanFactoryAware, EnvironmentAware, ImportBeanDefinitionRegistrar {
181.         // BeanFactory对象，用于保存Spring容器
182.         private BeanFactory beanFactory;
183.         private Environment environment;
185.         public AutoConfiguredMapperScannerRegistrar() {
186.         }
188.         public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
189.             if (!AutoConfigurationPackages.has(this.beanFactory)) {
190.                 org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration.logger.debug("Could not determine auto-configuration package, automatic mapper scanning disabled.");
191.             } else {
192.                 org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration.logger.debug("Searching for mappers annotated with @Mapper");
193.                // 获取自动配置要处理的包
194.                 List<String> packages = AutoConfigurationPackages.get(this.beanFactory);
195.                 if (org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration.logger.isDebugEnabled()) {
196.                     packages.forEach((pkg) -> {
197.                         org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration.logger.debug("Using auto-configuration base package '{}'", pkg);
198.                     });
199.                 }
200.                 // 创建BeanDefinitionBuilder对象
201.                 // 它帮助开发者以反射的方式创建任意类的实例
202.                 // 此处就是帮助创建MapperScannerConfigurer类的实例
203.                 BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(MapperScannerConfigurer.class);
204.                // 为要创建的对象设置属性
205.                 builder.addPropertyValue("processPropertyPlaceHolders", true);
206.                 builder.addPropertyValue("annotationClass", Mapper.class);
207.                 builder.addPropertyValue("basePackage", StringUtils.collectionToCommaDelimitedString(packages));
208.                 BeanWrapper beanWrapper = new BeanWrapperImpl(MapperScannerConfigurer.class);
209.                 Set<String> propertyNames = (Set)Stream.of(beanWrapper.getPropertyDescriptors()).map(FeatureDescriptor::getName).collect(Collectors.toSet());
210.                 if (propertyNames.contains("lazyInitialization")) {
211.                     builder.addPropertyValue("lazyInitialization", "${mybatis.lazy-initialization:false}");
212.                 }
214.                 if (propertyNames.contains("defaultScope")) {
215.                     builder.addPropertyValue("defaultScope", "${mybatis.mapper-default-scope:}");
216.                 }
218.                 boolean injectSqlSession = (Boolean)this.environment.getProperty("mybatis.inject-sql-session-on-mapper-scan", Boolean.class, Boolean.TRUE);
219.                 if (injectSqlSession && this.beanFactory instanceof ListableBeanFactory) {
220.                     ListableBeanFactory listableBeanFactory = (ListableBeanFactory)this.beanFactory;
221.                     Optional<String> sqlSessionTemplateBeanName = Optional.ofNullable(this.getBeanNameForType(SqlSessionTemplate.class, listableBeanFactory));
222.                     Optional<String> sqlSessionFactoryBeanName = Optional.ofNullable(this.getBeanNameForType(SqlSessionFactory.class, listableBeanFactory));
223.                     if (!sqlSessionTemplateBeanName.isPresent() && sqlSessionFactoryBeanName.isPresent()) {
224.                         builder.addPropertyValue("sqlSessionFactoryBeanName", sqlSessionFactoryBeanName.get());
225.                     } else {
226.                         builder.addPropertyValue("sqlSessionTemplateBeanName", sqlSessionTemplateBeanName.orElse("sqlSessionTemplate"));
227.                     }
228.                 }
230.                 builder.setRole(2);
231.                 // 在容器中注册BeanDefinitionBuilder创建的MapperScannerConfigurer对象
232.                 registry.registerBeanDefinition(MapperScannerConfigurer.class.getName(), builder.getBeanDefinition());
233.             }
234.         }
236.         // 获取spring容器和环境对象
237.         public void setBeanFactory(BeanFactory beanFactory) {
238.             this.beanFactory = beanFactory;
239.         }
241.         public void setEnvironment(Environment environment) {
242.             this.environment = environment;
243.         }
245.         private String getBeanNameForType(Class<?> type, ListableBeanFactory factory) {
246.             String[] beanNames = factory.getBeanNamesForType(type);
247.             return beanNames.length > 0 ? beanNames[0] : null;
248.         }
249.     }
250. }

复制代码

开发WriterTemplate类

1. # Auto Configure
2. org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
3. org.mybatis.spring.boot.autoconfigure.MybatisLanguageDriverAutoConfiguration,\
4. org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration

复制代码

然后使用 mvn install 命令打成jar包并安装到本地资源库。
在Starter的项目中引入上面的jar包。pom.xml如下：

1. @Configuration(proxyBeanMethods = false)
2. // 仅当com.mysql.cj.jdbc.Driver类存在时该配置类生效
3. @ConditionalOnClass(name = "com.mysql.cj.jdbc.Driver")
4. public class FkConfig
5. {
6.    @Bean
7.    public MyBean myBean()
8.    {
9.       return new MyBean();
10.    }
11. }

复制代码

然后在开发中编写自定义配置类：

1. // 仅当容器中不存在名为myService的Bean时，才创建该Bean   
2. @ConditionalOnMissingBean
3. @Bean
4. public MyService myService()
5. {
6.    ...
7. }
9. // 当容器中不存在名为jdbcTemplate的Bean时，才创建该Bean
10. @ConditionalOnMissingBean(name="jdbcTemplate")
11. @Bean
12. public JdbcTemplate JdbcTemplate()
13. {
14.    ...
15. }

复制代码

上面代码中的FunnyProperties类

1. @Configuration(proxyBeanMethods = false)
2. public class FkConfig
3. {
4.    @Bean
5.    // 只有当org.fkjava.test属性具有foo属性值时，下面配置方法才会生效
6.    @ConditionalOnProperty(name = "test", havingValue = "foo",
7.          prefix = "org.fkjava")
8.    public DateFormat dateFormat()
9.    {
10.       return DateFormat.getDateInstance();
11.    }
12. }

复制代码

接下来在META-INF/spring.factories文件中注册自动配置类

1. @SpringBootApplication
2. public class App
3. {
4.    public static void main(String[] args)
5.    {
6.       // 创建Spring容器、运行Spring Boot应用
7.       var ctx = SpringApplication.run(App.class, args);
8.       System.out.println(ctx.getBean("dateFormat"));
9.    }
10. }

复制代码

然后使用 mvn install 命令打成jar包，并安装到maven本地资源库中，就会在自己的本地资源库中找到该jar包，这样就完成了自定义配置的实现。
创建自定义的Starter

一个完整的SpringBoot Starter包含一下两个组件：

• 自动配置模块（auto-configure）：包含自动配置类和spring.factories文件
  
• Starter模块：负责管理自动配置模块和第三方依赖。简而言之，添加本Starter就能使用该自动配置。
  

由此看出，Starter不包含任何Class文件，只管理愿意来。如果查看官方提供的jar就会发现，它所有自动配置类的Class都由spring-boot-autoconfigure.jar提供，而各个xxx-starter.jar并未提供任何Class文件，只是在这些jar下的相同路径下提供了一个xxx-starter.pom文件，该文件指定Starter管理的自动依赖模块和第三方依赖。
SpringBoot为自动配置包和Starter包提供推荐命名

• 自动配置包的推荐名：xxx-spring-boot
  
• Starter包的推荐名：xxx-spring-boot-starter
  

对于第三方Starter不要使用spring-boot-starter-xxx这种方式，这是官方使用的。
有了自定义的Starter后，使用起来和官方的没有区别，比如
添加依赖：

1. org.fkjava.test=foo

复制代码

在application.properties文件添加配置

1. @Configuration(proxyBeanMethods = false)
2. public class FkConfig
3. {
4.    @Bean
5.    // 只有当前应用是反应式Web应用时，该配置才会生效
6.    @ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.REACTIVE)
7.    public DateFormat dateFormat()
8.    {
9.       return DateFormat.getDateInstance();
10.    }
11. }

复制代码

主类的代码：

1. @SpringBootApplication
2. public class App
3. {
4.    public static void main(String[] args)
5.    {
6.       var app = new SpringApplication(App.class);
7.       // 设置Web应用的类型，如果不设置则使用默认的类型：
8.       // 如果有Sping Web依赖，自动是基于Servlet的Web应用
9.       // 如果有Sping WebFlux依赖，自动是反应式Web应用
10.       app.setWebApplicationType(WebApplicationType.REACTIVE);  // ①
11.       // 创建Spring容器、运行Spring Boot应用
12.       var ctx = app.run(args);
13.       System.out.println(ctx.getBean("dateFormat"));
14.    }
15. }

复制代码

来源：豆瓜网用户自行投稿发布，如果侵权，请联系站长删除