Automatic configuration (startup process)

Posted Jun 28, 20207 min read

### 2.2 Automatic configuration(startup process)

Concept:when we add jar package dependencies, we can automatically configure the relevant configuration of some components for us. We can run the written project without configuration or only a small amount of configuration.

Question:In the end, how does Spring Boot auto-configure and what components are auto-configured?

The startup entry of the Spring Boot application is the main() method in the @SpringBootApplication annotation annotation class. @SpringBootApplication can scan Spring components and automatically configure Spring Boot

Below, check @SpringBootApplication internal source code for analysis, the core code is as follows



public class SpringbootDemoApplication {

public static void main(String[]args) {, args);





@Target({ElementType.TYPE}) //The scope of annotations, Type means that annotations can be described in classes, interfaces, annotations or enumerations

@Retention(RetentionPolicy.RUNTIME) //Indicates the life cycle of the annotation, Runtime runtime

@Documented //Indicates that the annotation can be recorded in javadoc

@Inherited //Indicates that the annotation can be inherited by subclasses

@SpringBootConfiguration //Mark this class as the configuration class

@EnableAutoConfiguration //Start the automatic configuration function

@ComponentScan(//package scanner

excludeFilters = {@Filter(

type = FilterType.CUSTOM,

classes = {TypeExcludeFilter.class}

), @Filter(

type = FilterType.CUSTOM,

classes = {AutoConfigurationExcludeFilter.class}



public @interface SpringBootApplication {




It can be seen from the above source code that the @SpringBootApplication annotation is a combined annotation. The first 4 are the metadata information of the annotation. We mainly look at the following 3 annotations:@SpringBootConfiguration, @EnableAutoConfiguration, @ComponentScan three core annotations, about these three The relevant explanations of each core note are as follows:

**1. @SpringBootConfiguration annotation**

The @SpringBootConfiguration annotation indicates the Spring Boot configuration class. See @SpringBootConfiguration annotation source code, the core code is as follows.





@Configuration //Configure the IOC container

public @interface SpringBootConfiguration {



It can be seen from the above source code that there is a core annotation @Configuration inside the @SpringBootConfiguration annotation, which is provided by the Spring framework and indicates that the current class is a configuration class(annotation representation form of the XML configuration file) and can be used by the component scanner scanning. It can be seen that the function of @SpringBootConfiguration annotation is the same as @Configuration annotation, which is to identify a configuration class that can be scanned by the component scanner, but @SpringBootConfiguration is repackaged and named by Spring Boot.

**2. @EnableAutoConfiguration annotation**

@EnableAutoConfiguration annotation indicates that the automatic configuration function is turned on. This annotation is the most important annotation of the Spring Boot framework and is also an annotation for automatic configuration. Similarly, view the source code information inside this note, the core code is as follows


It can be found that it is a combined annotation. There are many annotations starting with Enable in Spring. Its function is to use @Import to collect and register beans related to a specific scene and load it into the IoC container. @EnableAutoConfiguration is to use @Import to collect all bean definitions that meet the automatic configuration conditions and load them into the IoC container.

Here are the two core notes:

(1) @AutoConfigurationPackage annotation

Check @AutoConfigurationPackage annotation internal source information, the core code is as follows:






@Import({Registrar.class}) //Import the components registered in Registrar

public @interface AutoConfigurationPackage {



It can be seen from the above source code that the function of @AutoConfigurationPackage annotation is implemented by @Import annotation. It is the bottom annotation of the spring framework. Its function is to import a component class into the container, such as @Import(AutoConfigurationPackages.Registrar. class), it is to import the Registrar component class into the container, you can view the registerBeanDefinitions method in the Registrar class, this method is the specific implementation of the imported component class:


It can be seen from the above source code that there is a registerBeanDefinitions() method in the Registrar class. Use the Debug mode to start the project. You can see that the selected part is com.lagou. In other words, the main function of the @AutoConfigurationPackage annotation is to scan the components in the package where the main program class is located and all the sub-packages into the spring container.

Therefore, when defining the project package structure, it is required that the defined package structure is very standardized. The project main program startup class should be defined in the outermost root directory location, and then the subpackages and classes should be established within the root directory location for business development, so that it can Ensure that the defined classes can be scanned by the component scanner

(2)**@Import({AutoConfigurationImportSelector.class}):**import **AutoConfigurationImportSelector**this class into the spring container,**AutoConfigurationImportSelector** can help The springboot application loads all eligible @Configuration configurations into the IoC container(ApplicationContext) created and used by the current SpringBoot

Continue to study **AutoConfigurationImportSelector** this class, through source code analysis, this class is through the method of selectImports to tell springboot that those components need to be imported:


**In-depth study of loadMetadata method**


**In-depth getCandidateConfigurations method**

There is an important method loadFactoryNames in this method, this method is to let SpringFactoryLoader to load the names of some components.


Continue to open the loadFactory method


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

//Get the access key

String factoryClassName = factoryClass.getName();

return(List)loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());


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

MultiValueMap<String, String> result =(MultiValueMap)cache.get(classLoader);

if(result != null) {

return result;

} else {

try {

//If the class loader is not null, load the spring.factories file in the class path, and encapsulate the full path information of the configuration class set in it into an Enumeration class object

Enumeration urls = classLoader != null? ClassLoader.getResources("META-INF/spring.factories"):ClassLoader.getSystemResources("META-INF/spring.factories");

LinkedMultiValueMap result = new LinkedMultiValueMap();

//Cycle the Enumeration class object, generate a Properties object according to the corresponding node information, get the value through the passed key, and then cut the value into a small string into an Array, method result collection

while(urls.hasMoreElements()) {

URL url =(URL)urls.nextElement();

UrlResource resource = new UrlResource(url);

Properties properties = PropertiesLoaderUtils.loadProperties(resource);

Iterator var6 = properties.entrySet().iterator();

while(var6.hasNext()) {

Entry entry =(Entry);

String factoryClassName =((String)entry.getKey()).trim();

String[]var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());

int var10 = var9.length;

for(int var11 = 0; var11 <var10; ++var11) {

String factoryName = var9[var11];

result.add(factoryClassName, factoryName.trim());




cache.put(classLoader, result);

return result;


Will go to read a sprin g.factories file, can not read this error, we continue to see, the final path is like this, and this is a tool class provided by spring


public final class SpringFactoriesLoader {

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



It actually loads an external file, and this file is in



@EnableAutoConfiguration is to search the META-INF/spring.factories configuration file from the classpath, and instantiate the configuration items corresponding to org.springframework.boot.autoconfigure.EnableutoConfiguration through reflection(Java Refletion) into the corresponding JavaConfig marked with @Configuration Form configuration class and load it into the IOC container

Taking the project just now as an example, the Web environment dependency launcher is added to the project, and the corresponding WebMvcAutoConfiguration automatic configuration class will take effect. Open the automatic configuration class and you will find that in the configuration class, you can configure Spring by fully annotating the configuration class. The environment required for MVC operation has been configured by default, including default prefix, default suffix, view parser, MVC checker, etc. The essence of these automatic configuration classes is the corresponding XML configuration file in the traditional Spring MVC framework, but it is pre-configured in the form of automatic configuration classes in Spring Boot. Therefore, after adding the relevant dependency starter to the Spring Boot project, you can basically run the program without any configuration. Of course, we can also change the default configuration in these automatic configuration classes.