The configuration class (this class under @Configuration) is actually equivalent to a factory, marked @ The method of Bean annotation is equivalent to the factory method
Consider the following example:
@Configuration // 注意点1: 配置类其实相当于一个工厂, 标注 @Bean 注解的方法相当于工厂方法 static class MyConfig { @Bean public Bean1 bean1() { System.out.println("bean1()"); return new Bean1(); }
If you want to generate an instance of bean1 in the future, you must first find an instance called myConfig bean (it is a factory), and then call the method called "bean1" in this factory to generate a bean1 object.
For @Bean factory methods without static modification, called instance factories, you need to create an instance of the configuration class myConfig first; those with static modification are static methods, you only need to get the class object of myConfig, and then directly. Just the method.
@Bean does not support method overloading. If there are multiple overloaded methods, only one can be selected as a factory method
@Configuration @MapperScan("aaa") // 注意点1: 配置类其实相当于一个工厂, 标注 @Bean 注解的方法相当于工厂方法 static class MyConfig { // 注意点2: @Bean 不支持方法重载, 如果有多个重载方法, 仅有一个能入选为工厂方法 @Bean public Bean1 bean1() { System.out.println("bean1()"); return new Bean1(); } @Bean public Bean1 bean1(@Value("${java.class.version}") String a) { System.out.println("bean1(" + a + ")"); return new Bean1(); } @Bean public Bean1 bean1(@Value("${java.class.version}") String a, @Value("${JAVA_HOME}") String b) { System.out.println("bean1(" + a + ", " + b + ")"); return new Bean1(); }
If there are overloads Method, the more values that need to be injected into the parameters, the higher the priority.
@Configuration cannot be deleted casually, because a proxy will be generated for the annotated class by default. The purpose is to ensure that when @Bean methods call each other, their singleton characteristics can still be guaranteed
#@Configuration If there is a BeanFactory post-processor, the instance factory method will cause MyConfig to be created in advance, causing its dependency injection to fail. The solution is to use the static factory method or directly For dependency injection of method parameters of @Bean, you can use the annotation method instead for MapperScanner
@SpringBootApplication is a combined annotation, consisting of @ComponentScan, @EnableAutoConfiguration and @SpringBootConfiguration:
Compared with ordinary @Configuration, the only difference between @SpringBootConfiguration and ordinary @Configuration is that the former requires it to appear only once in the entire app, because the main configuration class must be determined based on it, and the entrance to the entire program can be found based on the main configuration class
@ComponentScan:Component scan
excludeFilters - used to exclude during component scanning, and also exclude automatic configuration classes
@EnableAutoConfiguration is also a combined annotation, consisting of the following annotations
@AutoConfigurationPackage – Used to remember the starting package of scanning, that is, the package where the class marked by it is recorded
@Import(AutoConfigurationImportSelector.class) Used to load META-INF/spring.factories The automatic configuration class in (the automatic configuration class means that if the main configuration class is not configured, the automatic configuration class will be used)
Why not use @Import to directly introduce the automatic configuration class
There are two Reason:
Let the main configuration class and the automatic configuration class become strongly coupled. The main configuration class should not know what slave configurations there are
Use @Import (automatic configuration class.class) directly. The introduced configuration parsing priority is higher. The parsing of the automatic configuration class should be used as the default configuration when the main configuration is not provided.
Therefore, @Import(AutoConfigurationImportSelector.class)
META-INF/spring.factories from AutoConfigurationImportSelector.class
The automatic configuration class in implements weak coupling.
AutoConfigurationImportSelector.class implements the DeferredImportSelector interface so that the parsing of the automatic configuration is later than the parsing of the main configuration
The above is the detailed content of Springboot automatic configuration and @Configuration configuration class instance analysis. For more information, please follow other related articles on the PHP Chinese website!