SpringBoot中自定义starter实例与原理
1 自定义启动器
本文首先提出以下开发需求：需要自定义一个启动器spring-boot-football-starter，业务方引入这个启动器之后可以直接使用Football实例。
1.1 创建项目
1.1.1 项目名
java-front-football-starter
1.1.2 springboot版本号
<dependency>
<artifactId>spring-boot-dependenciesartifactId>
<groupId>org.springframework.bootgroupId>
<scope>importscope>
<type>pomtype>
<version>2.1.7.RELEASEversion>
dependency>
1.2 创建Football
@Getter
@Setter
public class Football {
private String a;
private String b;
}
1.3 创建配置类
@Getter
@Setter
@ConfigurationProperties(prefix = "football") // prefix不支持驼峰命名
public class FootballProperties {
private boolean enable = true;
private String a;
private String b;
}
1.4 创建AutoConfiguration
@Slf4j
@Configuration
@ConditionalOnClass(Football.class) // 只有当classpath中存在Football类时才实例化本类
@EnableConfigurationProperties(FootballProperties.class)
public class FootballAutoConfiguration {
@Autowired
private FootballProperties footballProperties;
@Bean
@ConditionalOnMissingBean(Football.class) // 只有当容器不存在其它Football实例时才使用此实例
public Football football() {
if (!footballProperties.isEnable()) {
String defaultValue = "default";
Football football = new Football();
football.setA(defaultValue);
football.setB(defaultValue);
log.info("==========football close bean={}==========", JSON.toJSONString(football));
return football;
}
Football football = new Football();
football.setA(footballProperties.getA());
football.setB(footballProperties.getB());
log.info("==========football open bean={}==========", JSON.toJSONString(football));
return football;
}
}
- 条件注解说明
@ConditionalOnBean
只有在当前上下文中存在某个对象时才进行实例化Bean
@ConditionalOnClass
只有classpath中存在class才进行实例化Bean
@ConditionalOnExpression
只有当表达式等于true才进行实例化Bean
@ConditionalOnMissingBean
只有在当前上下文中不存在某个对象时才进行实例化Bean
@ConditionalOnMissingClass
某个class类路径上不存在时才进行实例化Bean
@ConditionalOnNotWebApplication
当前应用不是WEB应用才进行实例化Bean
1.5 spring.factories
- 工厂文件位置
- src/main/resources
- META-INF
-spring.factories
- 工厂文件内容
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.java.front.football.starter.configuration.FootballAutoConfiguration
2 测试启动器
2.1 引入依赖
<dependency>
<groupId>com.java.testgroupId>
<artifactId>java-front-football-starterartifactId>
<version>1.0.0version>
dependency>
2.2 application.yml
server:
port: 9999
football:
enable: true
a: "aaa"
b: "bbb"
2.3 TestController
@RestController
@RequestMapping("/test/football")
public class TestController {
@Resource
private Football football;
@GetMapping
public Football get() {
return football;
}
}
2.4 TestApplication
@SpringBootApplication
public class TestApplication {
public static void main(String[] args) {
SpringApplication.run(TestApplication.class, args);
}
}
2.5 测试用例
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT, classes = TestApplication.class)
@RunWith(SpringJUnit4ClassRunner.class)
public class TestControllerTest {
@Test
public void test() {
String response = HttpUtil.get("http://localhost:9999/test/football");
Assert.assertTrue(!StringUtils.isEmpty(response));
}
}
2.6 测试结果
==========football open bean={"a":"aaa","b":"bbb"}==========
3 原理分析
- 启动类
@SpringBootApplication
public class TestApplication {
public static void main(String[] args) {
SpringApplication.run(TestApplication.class, args);
}
}
SpringBootApplication
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class), @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class)})
public @interface SpringBootApplication {
//......
}
EnableAutoConfiguration
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
//......
}
AutoConfigurationImportSelector
public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware, ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {
protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata,
AnnotationMetadata annotationMetadata) {
if (!isEnabled(annotationMetadata)) {
return EMPTY_ENTRY;
}
AnnotationAttributes attributes = getAttributes(annotationMetadata);
// 加载配置
List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
configurations = removeDuplicates(configurations);
Set<String> exclusions = getExclusions(annotationMetadata, attributes);
checkExcludedClasses(configurations, exclusions);
configurations.removeAll(exclusions);
configurations = filter(configurations, autoConfigurationMetadata);
fireAutoConfigurationImportEvents(configurations, exclusions);
return new AutoConfigurationEntry(configurations, exclusions);
}
}
getCandidateConfigurations
public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware, ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());
Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct.");
return configurations;
}
}
loadFactoryNames
public final class SpringFactoriesLoader {
// 工厂加载路径
public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
String factoryClassName = factoryClass.getName();
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 {
// 根据路径加载工厂信息（FootballAutoConfiguration）
Enumeration<URL> urls = (classLoader != null ? classLoader.getResources(FACTORIES_RESOURCE_LOCATION) : ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
result = new LinkedMultiValueMap<>();
while (urls.hasMoreElements()) {
URL url = urls.nextElement();
UrlResource resource = new UrlResource(url);
Properties properties = PropertiesLoaderUtils.loadProperties(resource);
for (Map.Entry<?, ?> entry : properties.entrySet()) {
String factoryClassName = ((String) entry.getKey()).trim();
for (String factoryName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {
result.add(factoryClassName, factoryName.trim());
}
}
}
cache.put(classLoader, result);
return result;
} catch (IOException ex) {
throw new IllegalArgumentException("Unable to load factories from location [" FACTORIES_RESOURCE_LOCATION + "]", ex);
}
}
}
4 延伸知识
4.1 spring官方启动器
https://docs.spring.io/spring-boot/docs/2.1.7.RELEASE/reference/html/using-boot-build-systems.html#using-boot-starter
- 英文介绍
Starters are a set of convenient dependency descriptors that you can include in your application. You get a one-stop shop for all the Spring and related technologies that you need without having to hunt through sample code and copy-paste loads of dependency descriptors. For example, if you want to get started using Spring and JPA for database access, include the spring-boot-starter-data-jpa dependency in your project
- 中文介绍
Starter是一组方便的依赖描述符，你可以将其包含在应用程序中。你可以一站式获得所有所需的Spring和相关技术，而无需在示例代码中搜索并复制粘贴大量依赖描述符。如果你想要开始使用Spring和JPA进行数据库访问，请在项目中包含spring-boot-starter-data-jpa依赖项
4.2 spring-boot-starter
这个启动器是核心启动器，功能包括自动配置支持、日志记录和YAML。任意引入一个启动器点击分析，最终发现引用核心启动器。
- 引用
spring-boot-starter-data-redis
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-data-redisartifactId>
dependency>
- 发现引用
spring-boot-starter
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starterartifactId>
<version>2.1.7.RELEASEversion>
<scope>compilescope>
dependency>
- 发现引用
spring-boot-autoconfigure
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-autoconfigureartifactId>
<version>2.1.7.RELEASEversion>
<scope>compilescope>
dependency>
- 工厂文件位置
/META-INF/spring.factories
- 文件中指定Redis自动配置
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration
- 自动装配类
RedisAutoConfiguration
@Configuration
@ConditionalOnClass(RedisOperations.class)
@EnableConfigurationProperties(RedisProperties.class) // 配置信息类
@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
public class RedisAutoConfiguration {
//......
}
- 配置信息类
RedisProperties
@ConfigurationProperties(prefix = "spring.redis")
public class RedisProperties {
private int database = 0;
private String url;
private String host = "localhost";
private String password;
private int port = 6379;
//......
}
- application.yml文件配置
spring
redis
host:xxx
port:xxx
password:xxx
4.3 第三方启动器
如果使用第三方启动器，如何知道在yml文件中设置什么配置项？本章节以mybatis为例：
- 引入
mybatis-spring-boot-starter
<dependency>
<groupId>org.mybatis.spring.bootgroupId>
<artifactId>mybatis-spring-boot-starterartifactId>
<version>2.2.3version>
dependency>
- 自动装配依赖
<dependency>
<groupId>org.mybatis.spring.bootgroupId>
<artifactId>mybatis-spring-boot-autoconfigureartifactId>
dependency>
- 工厂文件位置
/META-INF/spring.factories
- 文件中指定MyBatis自动配置
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration
- 自动配置类
MybatisAutoConfiguration
@ConditionalOnClass({ SqlSessionFactory.class, SqlSessionFactoryBean.class })
@ConditionalOnSingleCandidate(DataSource.class)
@EnableConfigurationProperties(MybatisProperties.class) // 配置信息类
@AutoConfigureAfter({ DataSourceAutoConfiguration.class, MybatisLanguageDriverAutoConfiguration.class })
public class MybatisAutoConfiguration implements InitializingBean {
//......
}
- 配置信息类
MybatisProperties
@ConfigurationProperties(prefix = MybatisProperties.MYBATIS_PREFIX)
public class MybatisProperties {
public static final String MYBATIS_PREFIX = "mybatis";
private String configLocation;
private String[] mapperLocations;
private String typeAliasesPackage;
private Class<?> typeAliasesSuperType;
//......
}
- application.yml文件配置
mybatis:
mapperLocations: classpath:db/sqlmappers/*.xml
configLocation: classpath:db/mybatis-config.xml
5 文章总结
第一章节介绍如何自定义一个简单启动器，第二章节对自定义启动器进行测试，第三章节通过源码分析介绍启动器运行原理，第四章进行知识延伸介绍spring官方启动器，使用第三方启动器相关知识，希望本文对大家有所帮助。