Spring boot 自动装配机制

前述

在解析spring boot starter自动装配机制之前，我们先来回顾一下web工程是如何搭建的：

gradle/pom文件中引入项目依赖jar包；
配置web.xml，Servlet配置，拦截器设置，Listener配置…;
数据库连接，配置spring事务；
配置视图解析器；
开启注解，自动扫描功能
配置完成后部署tomcat，调试等…

…

在搭建这些环境的时候是非常耗时间耗精力的，而且有时还会缺斤少两，连蹦bug…

而有了springboot之后，所有的环境配置就会非常便捷。

自动配置原理

我们先来搭建一个最简单的springboot工程，如下：

application.properties文件如下：

server.port=8080

这样，我们就搭好了一个最简单的springboot工程，随后就可以启动了。

我们或许有点好奇，明明自己就只配置了一个端口号，剩下的自己啥也没配，为啥这个web程序就可以启动了？？为什么？？？

接下来，我们来分析以下，以下是我的思路分析过程（为了防止后面看着看着就迷路，我先来个大纲）：

SpringbootApplication启动类的注解@SpringBootApplication，即程序入口；
@EnableAutoConfiguration注解（bean的装配与加载）重点；
@ComponentScan注解（bean的扫描与发现）

程序入口

我们先来看一下主程序入口：

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

如以上代码，很常见，是一个main方法启动类，与javaEE程序不同的是，它被一个@springbootApplication注解修饰，那么这个注解何德何能，可以让一个web应用跑起来呢？

走进@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 {

	@AliasFor(annotation = EnableAutoConfiguration.class)
	Class<?>[] exclude() default {};

	@AliasFor(annotation = EnableAutoConfiguration.class)
	String[] excludeName() default {};

	@AliasFor(annotation = ComponentScan.class, attribute = "basePackages")
	String[] scanBasePackages() default {};

	@AliasFor(annotation = ComponentScan.class, attribute = "basePackageClasses")
	Class<?>[] scanBasePackageClasses() default {};

	@AliasFor(annotation = ComponentScan.class, attribute = "nameGenerator")
	Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;
    
	@AliasFor(annotation = Configuration.class)
	boolean proxyBeanMethods() default true;

}

我们暂时不要关注这个类的方法，我们先看看这个类上的几个注解：

@SpringBootConfiguration：在这里可以理解为是一个@Configuration注解；
@EnableAutoConfiguration：自动装配的核心！！用作bean的装配与加载
@ComponentScan：扫描包，用作bean的发现（此处扫描当前main下面app的所在包及其下属包）

@EnableAutoConfiguration

我们来看看它究竟做了什么事：

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

	String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

	Class<?>[] exclude() default {};

	String[] excludeName() default {};

}

点进去之后可以发现有两个比较重要的注解：

@AutoConfigurationPackage：其作用是自动配置的包；
@Import：他的作用是导入需要自动配置的组件；

@AutoConfigurationPackage如下：

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

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {

		@Override
		public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
			register(registry, new PackageImports(metadata).getPackageNames().toArray(new String[0]));
		}

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

	}

以上代码的作用就是：

加载启动类所在的包下的主类与子类的所有组件注册到spring容器。

那么问题来了，要搜集并注册到spring容器的那些beans来自哪里？

我们的@import注解就排上用场了，我们也可以细心的发现，@import注解里包括了一个AutoConfigurationImportSelector.class类，那么这个类具体是干嘛的呢？

public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware,
		ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {

	...
    //选择导入
	@Override
	public String[] selectImports(AnnotationMetadata annotationMetadata) {
		if (!isEnabled(annotationMetadata)) {
			return NO_IMPORTS;
		}
		AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(annotationMetadata);
		return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
	}
}

getAutoConfigurationEntry（）如下：

protected AutoConfigurationEntry getAutoConfigurationEntry(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 = getConfigurationClassFilter().filter(configurations);
		fireAutoConfigurationImportEvents(configurations, exclusions);
		return new AutoConfigurationEntry(configurations, exclusions);
	}
//候选者方法如下
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    	//扫描所有jar包类路径下  META‐INF/spring.factories 所有EnableAutoConﬁguration的值 把扫描到的这些文件的内容包装成properties对象 
		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;
	}
//获取被@EnableAutoConfiguration修饰的类
protected Class<?> getSpringFactoriesLoaderFactoryClass() {
		return EnableAutoConfiguration.class;
	}

META‐INF/spring.factories 所有EnableAutoConﬁguration的值:

# 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.context.ConfigurationPropertiesAutoConfiguration,\
org.springframework.boot.autoconfigure.context.LifecycleAutoConfiguration,\
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,\
...略

看了以上代码，我们可以发现``AutoConfigurationImportSelector`干了这么几件事：

扫描所有jar包类路径下 META‐INF/spring.factories ；
把扫描到的这些文件的内容包装成properties对象；
从properties中获取到EnableAutoConfiguration.class类（类名）对应的值。

来小结一下：

@EnableAutoConfiguration这个注解干了那些事？

通过@import注解，引入了AutoConfigurationImportSelector这个类；
AutoConfigurationImportSelector这个类扫描了所有被@EnableAutoConfiguration修饰的类；
通过上面扫描到的类，通过@AutoConfigurationPackage将其扫描到的类装配到容器中；

接下来我们来看一下被@EnableAutoConfiguration修饰的类长什么样：

以下解析是以HttpEncodingAutoConﬁguration为例解释自动装配的原理的。

@Configuration(proxyBeanMethods = false)//表示这是一个配置类，以前编写的配置文件一样，也可以给容器中添加组件 
@EnableConfigurationProperties(ServerProperties.class)//启动指定类的 ConfigurationProperties功能；将配置文件中对应的值和HttpEncodingProperties绑定起来；并把 HttpEncodingProperties加入到ioc容器中   
@ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET)//Spring底层@Conditional注解（Spring注解版），根据不同的条件，如果 满足指定的条件，整个配置类里面的配置就会生效；    判断当前应用是否是web应用，如果是，当前配置类生效   
@ConditionalOnClass(CharacterEncodingFilter.class)//判断当前项目有没有这个类 CharacterEncodingFilter；SpringMVC中进行乱码解决的过滤器；   
@ConditionalOnProperty(prefix = "server.servlet.encoding", value = "enabled", matchIfMissing = true) //判断配置文件中是否存在某个配置  spring.http.encoding.enabled；如果不存在，判断也是成立的 //即使我们配置文件中不配置pring.http.encoding.enabled=true，也是默认生效的；
public class HttpEncodingAutoConfiguration {
	//与SpringBoot的配置文件映射 
	private final Encoding properties;
	//只有一个有参构造器的情况下，参数的值就会从容器中拿，与上述的@EnableConfigurationProperties引进来的文件相呼应。 
	public HttpEncodingAutoConfiguration(ServerProperties properties) {
		this.properties = properties.getServlet().getEncoding();
	}

	@Bean //给容器中添加一个组件，这个组件的某些值需要从properties中获取 
	@ConditionalOnMissingBean //判断容器没有这个组件？
	public CharacterEncodingFilter characterEncodingFilter() {
		CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
		filter.setEncoding(this.properties.getCharset().name());
		filter.setForceRequestEncoding(this.properties.shouldForce(Encoding.Type.REQUEST));
		filter.setForceResponseEncoding(this.properties.shouldForce(Encoding.Type.RESPONSE));
		return filter;
	}
	...略

	}
}

ServerProperties文件如下

@ConfigurationProperties(prefix = "server", ignoreUnknownFields = true)
public class ServerProperties {

	/**
	 * Server HTTP port.
	 */
	private Integer port;

	/**
	 * Network address to which the server should bind.
	 */
	private InetAddress address;

	@NestedConfigurationProperty
	private final ErrorProperties error = new ErrorProperties();
    ...略
}

首先我们来分析一下：

@Configuration与@bean的结合使用相当于是：创建一个基于java代码的配置类，可以用来替代相应的xml配置文件。
@EnableConfigurationProperties：引入外部文件，与springboot的配置文件形成映射。

其余就是各种@condition条件，达到条件之后，这个类才生效；

下面是一些condition条件的具体应用：

@Conditional扩展注解	作用（判断是否满足当前指定条件）
@ConditionalOnJava	系统的java版本是否符合要求
@ConditionalOnBean	容器中存在指定Bean；
@ConditionalOnMissingBean	容器中不存在指定Bean；
@ConditionalOnExpression	满足SpEL表达式指定
@ConditionalOnClass	系统中有指定的类
@ConditionalOnMissingClass	系统中没有指定的类
@ConditionalOnSingleCandidate	容器中只有一个指定的Bean，或者这个Bean是首选Bean
@ConditionalOnProperty	系统中指定的属性是否有指定的值
@ConditionalOnResource	类路径下是否存在指定资源文件
@ConditionalOnWebApplication	当前是web环境
@ConditionalOnNotWebApplication	当前不是web环境
@ConditionalOnJndi	JNDI存在指定项

@ComponentScan注解（bean的扫描与发现）

这块就是扫描springboot app程序的所在包，好像也没什么可说的。

总结

springboot的自动状态，我们大致可总结为这么几个步骤：

主程序中的@springbootApplication修饰；
在@EableAutoConfiguration注解中（实现bean的装配与加载），实现了以下两步：
- @Import引入的AutoCongurationImportSelector负责找到需要导入bean；
- @AutoConfigurationPackage负责将其bean加载到容器中；
被@EableAutoConfiguration修饰的注解：
- 通过@Conguration与@bean使用java的方式配置bean；
- @EnableConfigurationProperties引入配置文件属性，与spring boot的配置文件相映射（这也是为什么你在application.yml里面配置文件的时候可以生效）;
- @Conditionxx条件，满足则存在；
@CompomentScan扫描包。（实现bean的扫描与发现）

Spring boot 自动装配机制

前述

自动配置原理

程序入口

@EnableAutoConfiguration

@ComponentScan注解（bean的扫描与发现）

总结

使用c#强大的表达式树实现对象的深克隆之解决循环引用的问题

free AI online tools All In One

痞子衡嵌入式：恩智浦i.MX RT1xxx系列MCU启动那些事（12.A）- uSDHC eMMC启动时间(RT1170)

linux安装cuda和cudnn

Mellanox网卡开启SR-IOV

模拟手机设备：使用 Playwright 实现移动端自动化测试

HTML 00 Tutorial

全面系统的AI学习路径，帮助普通人也能玩转AI

从零开始：使用 Playwright 脚本录制实现自动化测试

uni-app实现上拉加载

Spring boot 自動裝配機制

@FunctionalInterface函數式接口註解及其示例

FastJson動態解析多層嵌套未知key json

Oracle 表已經有數據修改字段類型,把varchar2類型變成date類型

談一下對裝飾者模式的理解

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結