Springboot automatic configuration and @Configuration configuration class instance analysis

@Configuration

Note 1

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.

Note 2

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

Note 3

@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

Note 4

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

springboot automatic configuration

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

• ## is used to read

  META-INF/spring.factories from AutoConfigurationImportSelector.class The automatic configuration class in implements weak coupling.

• In addition

  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!