脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → SpringBoot自动配置原理

深入解析SpringBoot自动配置原理

 更新时间：2023年11月02日 09:29:50   作者：桐花思雨  
这篇文章主要介绍了深入解析SpringBoot自动配置原理,SpringBoot 的一大好处就是：大大简化了 Spring 和其他框架的整合配置,为了简化配置文件使开发者更专注于业务编码,可以使用 SpringBoot 来进行 Web 开发,需要的朋友可以参考下

前言

SpringBoot 的一大好处就是：大大简化了 Spring 和其他框架的整合配置。传统的 SSM 套装虽然很大程度地简化了 Web 开发，但是其的配置文件却较为繁琐，为了简化配置文件使开发者更专注于业务编码，可以使用 SpringBoot 来进行 Web 开发，其精简的配置和庞大繁茂的生态圈绝对令人惊叹

SpringBoot 之所以可以达到如此精简的配置，主要原因就是 SpringBoot自动配置

自动配置原理

本文的 SpringBoot 的版本为 2.0.6 RELEASE

SpringBoot 应用的启动类

SpringBoot 应用是从启动类的 main 方法中启动，加载 SpringBoot 配置类

@SpringBootApplication
public class Application {

	public static void main(String[] args) {
		SpringApplication.run(Application.class, args);
	}
}

@SpringBootApplication 注解

由于 SpringBoot 应用是从启动类的 main 方法中启动的，我们就有必要查看 @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 {
	// 省略 ......
}

可以看到 @SpringBootApplication 这个注解是一个复合注解，它有三个核心注解，下面我们依次查看它们

  • @SpringBootConfiguration
  • @EnableAutoConfiguration
  • @ComponentScan

@SpringBootConfiguration 注解

表明它是一个配置类

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration {

}

@ComponentScan 注解

它负责包的扫描，并排除一些特定的类型（不允许注册进 Spring 容器）

@ComponentScan(excludeFilters = {
		@Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })

@EnableAutoConfiguration 注解

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
	// 省略 ......
}

可以看到 @EnableAutoConfiguration 注解是个复合注解，有两个元注解，我们依次查看它们

  • @AutoConfigurationPackage
  • @Import(AutoConfigurationImportSelector.class)

@AutoConfigurationPackage

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {

}

查看 AutoConfigurationPackages.Registrar

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {

	@Override
	public void registerBeanDefinitions(AnnotationMetadata metadata,BeanDefinitionRegistry registry) {
		register(registry, new PackageImport(metadata).getPackageName());
	}

	@Override
	public Set<Object> determineImports(AnnotationMetadata metadata) {
		return Collections.singleton(new PackageImport(metadata));
	}
}

它其实是注册了一个 bean 的定义，返回了当前主启动类包的同级以及子级的包组件

@Import(AutoConfigurationImportSelector.class)

在 AutoConfigurationImportSelector 类中查看 selectImports() 方法

@Override
public String[] selectImports(AnnotationMetadata annotationMetadata) {
	if (!isEnabled(annotationMetadata)) {
		return NO_IMPORTS;
	}
	
	AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
				.loadMetadata(this.beanClassLoader);
				
	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 StringUtils.toStringArray(configurations);
}

再查看 getCandidateConfigurations(annotationMetadata, attributes) 方法

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(getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader()) 方法

public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {

	String factoryClassName = factoryClass.getName();
	return loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
}

loadSpringFactories 方法调用如下

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {

	MultiValueMap<String, String> result = cache.get(classLoader);
	if (result != null) {
		return result;
	}

	try {
		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()) {
				List<String> factoryClassNames = Arrays.asList(
						StringUtils.commaDelimitedListToStringArray((String) entry.getValue()));
				result.addAll((String) entry.getKey(), factoryClassNames);
			}
		}
		cache.put(classLoader, result);
		return result;
	}
	catch (IOException ex) {
		throw new IllegalArgumentException("Unable to load factories from location [" +
				FACTORIES_RESOURCE_LOCATION + "]", ex);
	}
}

该方法的作用：扫描类路径下所有具有 META-INF/spring.factories 的 jar 包，将扫描到的相应类组件注册进 Spring 容器中，不过这些扫描到的类组件注册进 Spring 容器中需要生效也是有条件的，使用条件注解 @Conditional

public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";

在这里插入图片描述

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.cloud.CloudAutoConfiguration,\
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.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,\
org.springframework.boot.autoconfigure.data.jpa.JpaRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoReactiveRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisReactiveAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.rest.RepositoryRestMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.data.web.SpringDataWebAutoConfiguration,\
org.springframework.boot.autoconfigure.elasticsearch.jest.JestAutoConfiguration,\
org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration,\
org.springframework.boot.autoconfigure.freemarker.FreeMarkerAutoConfiguration,\
org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.JndiDataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.XADataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.JmsAutoConfiguration,\
org.springframework.boot.autoconfigure.jmx.JmxAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.JndiConnectionFactoryAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.activemq.ActiveMQAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.artemis.ArtemisAutoConfiguration,\
org.springframework.boot.autoconfigure.kafka.KafkaAutoConfiguration,\
org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongoAutoConfiguration,\
org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration,\
org.springframework.boot.autoconfigure.mongo.MongoReactiveAutoConfiguration,\
org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration,\
org.springframework.boot.autoconfigure.thymeleaf.ThymeleafAutoConfiguration,\
org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration,\
org.springframework.boot.autoconfigure.transaction.jta.JtaAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.ServletWebServerFactoryAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.error.ErrorMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.HttpEncodingAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.MultipartAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.websocket.reactive.WebSocketReactiveAutoConfiguration,\
org.springframework.boot.autoconfigure.websocket.servlet.WebSocketServletAutoConfiguration,\
org.springframework.boot.autoconfigure.websocket.servlet.WebSocketMessagingAutoConfiguration,\

......

这些自动配置类都是以 AutoConfiguration 结尾来命名的，它实际上就是一个 JavaConfig 形式的 Spring 容器配置类

在此我们以 RedisAutoConfiguration 类为例，举例说明

@Configuration
@ConditionalOnClass(RedisOperations.class)// 当给定的类名在类路径上存在时，则实例化当前 bean
@EnableConfigurationProperties(RedisProperties.class)// 将 RedisProperties 这个类注册进 spring 容器中
@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;
	}
}

@Conditional 条件注解

  • @ConditionalOnBean：当给定的在 bean 存在时，则实例化当前 bean
  • @ConditionalOnExpression：当表达式为 true 的时候，才会实例化一个 bean
  • @ConditionalOnMissingBean：当给定的在 bean 不存在时，则实例化当前 bean
  • @ConditionalOnMissingClass：当给定的类名在类路径上不存在时，则实例化当前 bean
  • @ConditionalOnNotWebApplication：不是 web 应用
  • @ConditionalOnClass：当给定的类名在类路径上存在时，则实例化当前 bean

RedisProperties 类

该类负责读取配置文件中具体配置，如 spring.redis.host 和 spring.redis.port

@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;

	private boolean ssl;

	private Duration timeout;

	private Sentinel sentinel;

	private Cluster cluster;

	private final Jedis jedis = new Jedis();

	private final Lettuce lettuce = new Lettuce();

	......
}

当我们在使用 maven 引入了相关的 jar 包的时候，在类路径下也就具有了 META-INF/spring.factories 这样的文件，同时也就满足了上面的某些条件注解。这时，maven 引入了相关的 jar 包的类组件也就成功的注册进 Spring 容器中了

自动配置总结

@SpringBootApplication 它有三个核心注解：@SpringBootConfiguration，@EnableAutoConfiguration（重点关注），@ComponentScan

@EnableAutoConfiguration：核心作用是扫描类路径下所有具有 META-INF/spring.factories 的类组件（配置类），这些类组件都是以 AutoConfiguration 结尾来命名的，他能读取在配置文件中配置的属性信息，如 server.port，redis.port 等

然后将上述扫描到的相应类组件注册进 Spring 容器中；不过这些扫描到的类组件注册进 Spring 容器中需要生效也是有条件的，此时使用了条件注解 @ConditionOnxxx

当我们在使用 maven 或 gradle 引入了相关的 jar 包的时候，在类路径下也就具有了 META-INF/spring.factories 这样的文件；同时也就满足了某些 @ConditionOnxxx 的条件注解。这时，maven 或 gradle 引入了相关的 jar 包的类组件也就成功的注册进 Spring 容器中了

到此这篇关于深入解析SpringBoot自动配置原理的文章就介绍到这了,更多相关SpringBoot自动配置原理内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

相关文章

  • Spring P标签的使用详解

    Spring P标签的使用详解

    这篇文章主要介绍了Spring P标签的使用详解，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
    2021-08-08
  • Docker环境下Spring Boot应用内存飙升分析与解决场景分析

    Docker环境下Spring Boot应用内存飙升分析与解决场景分析

    当运行一个Spring Boot项目时，如果未设置JVM内存参数，Spring Boot默认会采用JVM自身默认的配置策略，接下来通过本文给大家介绍Docker环境下Spring Boot应用内存飙升分析与解决方法，需要的朋友参考下吧
    2021-08-08
  • 关于Map的遍历以及转JsonArray存储方式

    关于Map的遍历以及转JsonArray存储方式

    在Java开发过程中,经常会遇到需要对复杂数据结构进行处理的情况,本案例以List<Map<String,Object>>为例,介绍了如何遍历该数据结构,并根据特定条件筛选出符合要求的元素,通过自定义一个Edit类来模拟形成一个新的Map对象,实现了数据的有序存储
    2024-11-11
  • java单机滑动窗口限流器的实现

    java单机滑动窗口限流器的实现

    本文主要介绍了java单机滑动窗口限流器的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2026-03-03
  • java实现区域内屏幕截图示例

    java实现区域内屏幕截图示例

    这篇文章主要介绍了java截图示例,需要的朋友可以参考下
    2014-04-04
  • SpringMVC文件上传请求问题分析

    SpringMVC文件上传请求问题分析

    这篇文章主要介绍了SpringMVC文件上传请求,我们发的请求默认都是由DispatcherServlet类的doDispatch()来处理,这个方法的逻辑处理的第一步就是处理文件上传的请求,我们一起来看看是怎么处理的吧
    2024-07-07
  • Java JDK1.7对字符串的BASE64编码解码方法

    Java JDK1.7对字符串的BASE64编码解码方法

    今天小编就为大家分享一篇Java JDK1.7对字符串的BASE64编码解码方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
    2018-10-10
  • Spring框架 引入@Resource注解报空指针的解决

    Spring框架 引入@Resource注解报空指针的解决

    这篇文章主要介绍了Spring框架 引入@Resource注解报空指针的解决，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
    2021-11-11
  • 23种设计模式（14）java迭代器模式

    23种设计模式（14）java迭代器模式

    这篇文章主要为大家详细介绍了23种设计模式之java迭代器模式，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2017-12-12
  • Java基础之不简单的数组

    Java基础之不简单的数组

    数组(Array)是有序的元素序列。 若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量
    2021-09-09

最新评论