Springboot-starter-xxx原理解析
2019-11-05 本文已影响0人
海涛_meteor
前言
首先我们来看一个redis整合springboot最简单的例子，主要包括pom依赖、配置文件和使用示例三个部分。
pom依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
配置参数
spring:
redis:
password: redis
timeout: 2000ms
cluster:
max-redirects: 5 #获取失败时最大重定向次数
nodes:
- 172.28.19.80:6380
- 172.28.19.80:6381
- 172.28.19.85:6380
- 172.28.19.85:6381
- 172.28.19.89:6380
- 172.28.19.89:6381
lettuce:
pool:
max-active: 50 #连接池最大连接数（使用负值表示没有限制）
max-idle: 10 #连接池中的最大空闲连接
max-wait: 1000ms #连接池最大阻塞等待时间（使用负值表示没有限制）
min-idle: 5 #连接池中的最小空闲连接
代码示例
@Slf4j
@RestController
public class TestController {
@Autowired
private StringRedisTemplate redisTemplate;
@GetMapping("/set")
public void set(){
redisTemplate.opsForValue().set("test.goods","电视");
}
@GetMapping("/get")
public String get(){
String result = redisTemplate.opsForValue().get("test.goods");
return result;
}
}
依赖分析
为了分析spring-boot-starter的工作原理，我们首先来看一下spring-boot-starter-data-redis的定义
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starters</artifactId>
<version>2.1.3.RELEASE</version>
</parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
<version>2.1.3.RELEASE</version>
******
省略部分内容
******
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
<version>2.1.3.RELEASE</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-redis</artifactId>
<version>2.1.5.RELEASE</version>
<scope>compile</scope>
<exclusions>
<exclusion>
<artifactId>jcl-over-slf4j</artifactId>
<groupId>org.slf4j</groupId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>io.lettuce</groupId>
<artifactId>lettuce-core</artifactId>
<version>5.1.4.RELEASE</version>
<scope>compile</scope>
</dependency>
</dependencies>
</project>
这里比较重要的内容其实都在spring-boot-starters中了，来看一下其内容
******
省略部分内容
******
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot</artifactId>
<version>2.1.3.RELEASE</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-autoconfigure</artifactId>
<version>2.1.3.RELEASE</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-logging</artifactId>
<version>2.1.3.RELEASE</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>javax.annotation</groupId>
<artifactId>javax.annotation-api</artifactId>
<version>1.3.2</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>5.1.5.RELEASE</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.yaml</groupId>
<artifactId>snakeyaml</artifactId>
<version>1.23</version>
<scope>runtime</scope>
</dependency>
</dependencies>
</project>
包加载机制
这里最核心的部分是引入了spring-boot-autoconfigure包，那么这个包里的内容又是如何被加载的呢，这里就要回到我之前的文章《Springboot初始化流程解析》留下的伏笔，文章中说到springboot初始化时会调用到AbstractApplicationContext类的refresh()方法，其中有许多用于刷新的方法，而invokeBeanFactoryPostProcessors(beanFactory)方法就是我们要找的加载入口
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
// (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}
由于这个调用链比较长，我们简单梳理一下这个调用流程，首先调用到PostProcessorRegistrationDelegate类的invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors)方法，其部分代码片段如下
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
registryProcessor.postProcessBeanDefinitionRegistry(registry);
registryProcessors.add(registryProcessor);
}
else {
regularPostProcessors.add(postProcessor);
}
}
通过循环的方式调用了registryProcessor.postProcessBeanDefinitionRegistry(registry)并将registryProcessor对象依次加入registryProcessors这个list中，这里的registryProcessors的实现类为ConfigurationClassPostProcessor，调用其postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)方法
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
int registryId = System.identityHashCode(registry);
if (this.registriesPostProcessed.contains(registryId)) {
throw new IllegalStateException(
"postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);
}
if (this.factoriesPostProcessed.contains(registryId)) {
throw new IllegalStateException(
"postProcessBeanFactory already called on this post-processor against " + registry);
}
this.registriesPostProcessed.add(registryId);
processConfigBeanDefinitions(registry);
}
关联调用processConfigBeanDefinitions(BeanDefinitionRegistry registry)方法
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
******
// Parse each @Configuration class
ConfigurationClassParser parser = new ConfigurationClassParser(
this.metadataReaderFactory, this.problemReporter, this.environment,
this.resourceLoader, this.componentScanBeanNameGenerator, registry);
Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
do {
parser.parse(candidates);
parser.validate();
Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
configClasses.removeAll(alreadyParsed);
// Read the model and create bean definitions based on its content
if (this.reader == null) {
this.reader = new ConfigurationClassBeanDefinitionReader(
registry, this.sourceExtractor, this.resourceLoader, this.environment,
this.importBeanNameGenerator, parser.getImportRegistry());
}
this.reader.loadBeanDefinitions(configClasses);
alreadyParsed.addAll(configClasses);
candidates.clear();
if (registry.getBeanDefinitionCount() > candidateNames.length) {
String[] newCandidateNames = registry.getBeanDefinitionNames();
Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
Set<String> alreadyParsedClasses = new HashSet<>();
for (ConfigurationClass configurationClass : alreadyParsed) {
alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
}
for (String candidateName : newCandidateNames) {
if (!oldCandidateNames.contains(candidateName)) {
BeanDefinition bd = registry.getBeanDefinition(candidateName);
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
!alreadyParsedClasses.contains(bd.getBeanClassName())) {
candidates.add(new BeanDefinitionHolder(bd, candidateName));
}
}
}
candidateNames = newCandidateNames;
}
}
while (!candidates.isEmpty());
******
}
这里循环调用ConfigurationClassParser类的parse(Set<BeanDefinitionHolder> configCandidates)方法
public void parse(Set<BeanDefinitionHolder> configCandidates) {
******
this.deferredImportSelectorHandler.process();
}
public void process() {
List<DeferredImportSelectorHolder> deferredImports = this.deferredImportSelectors;
this.deferredImportSelectors = null;
try {
if (deferredImports != null) {
DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler();
deferredImports.sort(DEFERRED_IMPORT_COMPARATOR);
deferredImports.forEach(handler::register);
handler.processGroupImports();
}
}
finally {
this.deferredImportSelectors = new ArrayList<>();
}
}
这里的handler对象是ConfigurationClassParser的内部类DeferredImportSelectorGroupingHandler的实例，会调用其对应的方法processGroupImports()
public void processGroupImports() {
for (DeferredImportSelectorGrouping grouping : this.groupings.values()) {
grouping.getImports().forEach(entry -> {
ConfigurationClass configurationClass = this.configurationClasses.get(
entry.getMetadata());
try {
processImports(configurationClass, asSourceClass(configurationClass),
asSourceClasses(entry.getImportClassName()), false);
}
catch (BeanDefinitionStoreException ex) {
throw ex;
}
catch (Throwable ex) {
throw new BeanDefinitionStoreException(
"Failed to process import candidates for configuration class [" +
configurationClass.getMetadata().getClassName() + "]", ex);
}
});
}
}
改方法中的grouping为ConfigurationClassParser类的内部类DeferredImportSelectorGrouping的实例，因此会调用其对应的getImports()方法
public Iterable<Group.Entry> getImports() {
for (DeferredImportSelectorHolder deferredImport : this.deferredImports) {
this.group.process(deferredImport.getConfigurationClass().getMetadata(),
deferredImport.getImportSelector());
}
return this.group.selectImports();
}
当这里的group为AutoConfigurationImportSelector类的内部类AutoConfigurationGroup的实例时，process方法的调用如下
@Override
public void process(AnnotationMetadata annotationMetadata,
DeferredImportSelector deferredImportSelector) {
Assert.state(
deferredImportSelector instanceof AutoConfigurationImportSelector,
() -> String.format("Only %s implementations are supported, got %s",
AutoConfigurationImportSelector.class.getSimpleName(),
deferredImportSelector.getClass().getName()));
AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector) deferredImportSelector)
.getAutoConfigurationEntry(getAutoConfigurationMetadata(),
annotationMetadata);
this.autoConfigurationEntries.add(autoConfigurationEntry);
for (String importClassName : autoConfigurationEntry.getConfigurations()) {
this.entries.putIfAbsent(importClassName, annotationMetadata);
}
}
然后调用到AutoConfigurationImportSelector的getAutoConfigurationEntry方法
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方法
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;
}
到这里我们看到了一个非常熟悉的方法SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader())，在之前的文章《Springboot初始化流程解析》中有分析过，loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader)方法会扫描所有jar包下的META-INF/spring.factories文件，并将其中的类加载到内存中，而这里的getSpringFactoriesLoaderFactoryClass()方法返回的是EnableAutoConfiguration.class，因此可以推断，此处会加载spring.factories文件中EnableAutoConfiguration下对应的类。
配置类加载
经过上述分析，我们直接找到spring-boot-autoconfigure包下的META-INF/spring.factories文件来看看
******
省略部分内容
******
# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\
org.springframework.boot.autoconfigure.cloud.CloudServiceConnectorsAutoConfiguration,\
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,\
org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration,\
org.springframework.boot.autoconfigure.dao.PersistenceExceptionTranslationAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchRepositoriesAutoConfiguration,\
******
可以看到在EnableAutoConfiguration下springboot官方已经预先定义了许多的Configuration，其中有3个是redis打头的，我们以其中最重要的RedisAutoConfiguration为例来进行分析。
@Configuration
@ConditionalOnClass(RedisOperations.class)
@EnableConfigurationProperties(RedisProperties.class)
@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
public class RedisAutoConfiguration {
@Bean
@ConditionalOnMissingBean(name = "redisTemplate")
public RedisTemplate<Object, Object> redisTemplate(
RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
RedisTemplate<Object, Object> template = new RedisTemplate<>();
template.setConnectionFactory(redisConnectionFactory);
return template;
}
@Bean
@ConditionalOnMissingBean
public StringRedisTemplate stringRedisTemplate(
RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
StringRedisTemplate template = new StringRedisTemplate();
template.setConnectionFactory(redisConnectionFactory);
return template;
}
}
这里用到了条件注解@ConditionalOnClass和@ConditionalOnMissingBean，那就一起罗列一下几个常用的条件注解：
-
@ConditionalOnBean：仅在当前spring上下文中存在参数中的bean时，才会实例化被注解的Bean
-
@ConditionalOnClass：参数中的class位于classpath上，才会实例化被注解的Bean
-
@ConditionalOnExpression：当表达式为true的时候，才会实例化被注解的Bean
-
@ConditionalOnMissingBean：仅在当前spring上下文中不存在参数中的bean时，才会实例化被注解的Bean
-
@ConditionalOnMissingClass：参数中的class不存在于classpath上，才会实例化被注解的Bean
-
@ConditionalOnNotWebApplication：不是web应用时才会实例化被注解的Bean
-
@AutoConfigureAfter：在参数中的bean完成自动配置后实例化被注解的bean
-
@AutoConfigureBefore：在参数中的bean完成自动配置前实例化被注解的bean
除了上述条件注解外，还要提一下@EnableConfigurationProperties(RedisOperations.class)，该用法通常说明参数bean（这里指RedisOperations）上标有@ConfigurationProperties注解，而@EnableConfigurationProperties能使该注解生效，从而将对应的配置文件转化为参数bean对象（这里指RedisOperations）。
根据上述说明不难看出，类RedisAutoConfiguration的加载依赖于RedisOperations类，而这个类位于spring-data-redis包中，由spring-boot-starter-data-redis包依赖引入，所以，虽然RedisAutoConfiguration类可能会由于spring-boot-autoconfigure包被依赖而被提前引入，但只有依赖了spring-boot-starter-data-redis包后它才会被真正初始化。
注：这里有一点要说明的是，RedisOperations类是redis的基本参数类，其中有一些属性是带有默认值的，这些值就允许你不进行设置，这也就是通常所说的springboot约定大于配置特点的一个体现。
总结
本文根据redis整合springboot的简单例子分析了Springboot-starter-xxx的一般工作原理，说明了springboot启动过程中操作redis的客户端是如何根据pom文件中的依赖被实例化出来的。
