Shulou(Shulou.com)06/02 Report--

This article mainly introduces the example analysis of the principle of SpringBoot automatic configuration, which has a certain reference value, and interested friends can refer to it. I hope you will gain a lot after reading this article.

What is SpringBoot

The birth of SpringBoot is to simplify the tedious XML configuration in Spring, and its essence is still Spring framework. After using SpringBoot, we can start a service without any XML configuration, so that we can build an application more quickly when using micro-service architecture.

To put it simply, SpringBoot is not really a new framework, it is configured by default in many ways of using the framework.

Second, the characteristics of SpringBoot

A fixed configuration is provided to simplify the configuration, that is, an approximate configuration is agreed upon.

Automatic configuration of Spring and third-party libraries as much as possible, that is, automatic assembly

Embedded containers to create independent Spring applications

Make testing simple, built-in JUnit, Spring Boot Test and other testing frameworks to facilitate testing

Provides features that can be used for production, such as metrics, health checks, and externalized configurations.

There is no need to generate code at all, and no XML configuration is required.

III. Startup class

Let's explore the startup principle of SpringBoot, let's not dwell on some details, let's just catch the main line analysis.

Note: the SpringBoot version of this article is 2.6.1

3. 1 @ SpringBootApplication

Everything comes from the startup class that originates SpringBoot, and we find that there is a note on the main method: @ SpringBootApplication

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

The @ SpringBootApplication annotation indicates that the class is the main configuration class of SpringBoot, and SpringBoot should run the main method of this class to launch the SpringBoot application. Its essence is a combined annotation. The meta-information of this class mainly contains three annotations:

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

@ SpringBootConfiguration (which is @ Configuration, which marks the current class as the configuration class, but only changes its name after doing a layer of encapsulation)

@ EnableAutoConfiguration (enable automatic configuration)

@ ComponentScan (packet scan)

Note: @ Inherited is an identifier that modifies the annotation. If a class uses the @ Inherited-modified annotation, its subclasses will inherit the annotation.

Let's analyze the effects of these three annotations one by one.

3.1.1 @ SpringBootConfiguration

Let's continue to click @ SpringBootConfiguration to check the source code as follows:

@ Target ({ElementType.TYPE}) @ Retention (RetentionPolicy.RUNTIME) @ Documented@Configuration@Indexedpublic @ interface SpringBootConfiguration {@ AliasFor (annotation = Configuration.class) boolean proxyBeanMethods () default true;}

@ Configuration is annotated on a class, indicating that this is a springboot configuration class. You can inject components into the container.

3.1.2 @ ComponentScan

ComponentScan: configure the component scan instruction for the Configuration class.

Provides support for parallelism with elements of Spring XML.

Specific packets to scan can be defined by basePackageClasses or basePackages. If no specific package is defined, the scan starts with the package of the class that declares the annotation.

3.1.3 @ EnableAutoConfiguration

@ EnableAutoConfiguration as the name implies: enable automatic configuration import

This note is the focus of SpringBoot, which we will explain in detail below.

4. @ EnableAutoConfiguration

Let's click in to see what the note contains.

@ Target ({ElementType.TYPE}) @ Retention (RetentionPolicy.RUNTIME) @ Documented@Inherited@AutoConfigurationPackage / / Auto Guide package @ Import ({AutoConfigurationImportSelector.class}) / / Auto configuration Import Select public @ interface EnableAutoConfiguration {String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration"; Class [] exclude () default {}; String [] excludeName () default {};} 4.1 @ AutoConfigurationPackage

Automatically import configuration package

Click in to view the code:

Target ({ElementType.TYPE}) @ Retention (RetentionPolicy.RUNTIME) @ Documented@Inherited@Import ({Registrar.class}) public @ interface AutoConfigurationPackage {String [] basePackages () default {}; Class [] basePackageClasses () default {};}

@ Import is the annotation of spring, imports a configuration file, imports a component into the container in springboot, and the imported component is determined by the logic of AutoConfigurationPackages.class 's inner class Registrar.class.

4.1.1 @ Import ({Registrar.class})

Click Registrar.class to view the source code as follows:

Static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {Registrar () {} public void registerBeanDefinitions (AnnotationMetadata metadata, BeanDefinitionRegistry registry) {/ / breakpoint AutoConfigurationPackages.register (registry, (String []) (new AutoConfigurationPackages.PackageImports (metadata)). GetPackageNames (). ToArray (new String [0]);} public Set determineImports (AnnotationMetadata metadata) {return Collections.singleton (new AutoConfigurationPackages.PackageImports (metadata));}}

Note: if Registrar implements the ImportBeanDefinitionRegistrar class, it can be imported into the spring container with the annotation @ Import.

Break point in this place.

The value of (String []) (new AutoConfigurationPackages.PackageImports (metadata)) .getPackageNames () .toArray (new String [0]) is com.ljw.springbootwork: the name of the package in which the current startup class resides

Conclusion: @ AutoConfigurationPackage is to scan and annotate all the components under the package where the main configuration class (@ SpringBootApplication annotated class) is located into the spring container.

4.2 @ Import ({AutoConfigurationImportSelector.class})

Function: AutoConfigurationImportSelector opens the selector for automatically configuring the guide package of classes, that is, which classes are brought in, and import selectively

Click AutoConfigurationImportSelector.class to check the source code. There are two methods in this class that you can see by name:

1.selectImports: select the components to be imported

Public String [] selectImports (AnnotationMetadata annotationMetadata) {if (! this.isEnabled (annotationMetadata)) {return NO_IMPORTS;} else {AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry (annotationMetadata); return StringUtils.toStringArray (autoConfigurationEntry.getConfigurations ());}}

2.getAutoConfigurationEntry: returns AutoConfigurationImportSelector.AutoConfigurationEntry based on the AnnotationMetadata of the imported @ Configuration class

Protected AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry (AnnotationMetadata annotationMetadata) {if (! this.isEnabled (annotationMetadata)) {return EMPTY_ENTRY;} else {AnnotationAttributes attributes = this.getAttributes (annotationMetadata); / / make a breakpoint to see the returned data List configurations = this.getCandidateConfigurations (annotationMetadata, attributes); / / delete the duplicates configurations = this.removeDuplicates (configurations); Set exclusions = this.getExclusions (annotationMetadata, attributes) / / check this.checkExcludedClasses (configurations, exclusions); / / remove dependencies to be excluded: configurations.removeAll (exclusions); configurations = this.getConfigurationClassFilter () .filter (configurations); this.fireAutoConfigurationImportEvents (configurations, exclusions); return new AutoConfigurationImportSelector.AutoConfigurationEntry (configurations, exclusions);}}

This.getCandidateConfigurations (annotationMetadata, attributes) check the breakpoint here

The length of the configurations array is 133, and the file suffix is * * AutoConfiguration.

Conclusion: these are all candidate configuration classes, and after deduplication and removal of the required excluded dependencies, the final components are all the components needed in this environment. With automatic configuration, we do not need our own handwritten configuration values, configuration classes have default values.

Let's move on to see how to return the components that need to be configured

4.2.1 getCandidateConfigurations (annotationMetadata, attributes)

The methods are as follows:

Protected List getCandidateConfigurations (AnnotationMetadata metadata, AnnotationAttributes attributes) {List configurations = SpringFactoriesLoader.loadFactoryNames (this.getSpringFactoriesLoaderFactoryClass (), this.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;}

There is an assertion here: 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.")

The autoconfiguration class was not found in META-INF/spring.factories. If you use a custom wrapper, make sure that the file is correct.

Conclusion: that is, the loadFactoryNames () method will not report an error until it finds the automatic configuration class return.

4.2.1.1 getSpringFactoriesLoaderFactoryClass ()

We click in and find that this.getSpringFactoriesLoaderFactoryClass () returns the comment EnableAutoConfiguration.class. This annotation is the same as the tagged annotation under @ SpringBootApplication.

Protected Class getSpringFactoriesLoaderFactoryClass () {return EnableAutoConfiguration.class;}

Conclusion: get a class that can load the auto-configuration class, that is, SpringBoot default auto-configuration class is EnableAutoConfiguration

4.2.2 SpringFactoriesLoader

The SpringFactoriesLoader factory loading mechanism is a conventional loading method provided within Spring, only in the module's META-INF/spring.factories file, the key in this Properties format file is the full name of the interface, annotation, or abstract class, and value is a comma, "separated implementation class, using SpringFactoriesLoader to implement the corresponding implementation class injection into the Spirng container.

Note: all META-INF/spring.factories files under the classpath path under the jar package will be loaded, so there is more than one file.

4.2.2.1 loadFactoryNames ()

Public static List loadFactoryNames (Class factoryType, @ Nullable ClassLoader classLoader) {ClassLoader classLoaderToUse = classLoader; if (classLoaderToUse = = null) {classLoaderToUse = SpringFactoriesLoader.class.getClassLoader ();} String factoryTypeName = factoryType.getName (); return loadSpringFactories (classLoaderToUse) .getOrDefault (factoryTypeName, Collections.emptyList ());}

Breakpoint view factoryTypeName:

First, the EnableAutoConfiguration.class is passed to factoryType.

Then String factoryTypeName = factoryType.getName ();, so the factoryTypeName value is org.springframework.boot.autoconfigure.EnableAutoConfiguration

4.2.2.2 loadSpringFactories ()

Then look at the role of the loadSpringFactories method

Private static Map loadSpringFactories (ClassLoader classLoader) {/ / breakpoint view Map result = cache.get (classLoader); if (result! = null) {return result;} result = new HashMap (); try {/ / Note here: META-INF/spring.factories Enumeration urls = classLoader.getResources (FACTORIES_RESOURCE_LOCATION); while (urls.hasMoreElements ()) {URL url = urls.nextElement (); UrlResource resource = new UrlResource (url) Properties properties = PropertiesLoaderUtils.loadProperties (resource); for (Map.Entry entry: properties.entrySet ()) {String factoryTypeName = ((String) entry.getKey ()) .trim (); String [] factoryImplementationNames = StringUtils.commaDelimitedListToStringArray ((String) entry.getValue ()) For (String factoryImplementationName: factoryImplementationNames) {/ / breakpoint result.computeIfAbsent (factoryTypeName, key-> new ArrayList ()) .add (factoryImplementationName.trim ()) } / / Replace all lists with unmodifiable lists containing unique elements / / to remove duplicates, the breakpoint to view the result value result.replaceAll ((factoryType, implementations)-> implementations.stream (). Distinct () .duplicate (Collectors.collectingAndThen (Collectors.toList (), Collections::unmodifiableList)); cache.put (classLoader, result) } catch (IOException ex) {throw new IllegalArgumentException ("Unable to load factories from location [" + FACTORIES_RESOURCE_LOCATION + "]", ex);} return result;}

The FACTORIES_RESOURCE_LOCATION here is defined above: META-INF/spring.factories.

Public final class SpringFactoriesLoader {/ * * The location to look for factories. *

Can be present in multiple JAR files. * / public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories"

Where is the META-INF/spring.factories file?

META-INF/spring.factories files under the current classpath of all imported java packages are read, such as:

The breakpoint view result value is as follows:

The function of this method is to load all dependent path META-INF/spring.factories files, save through the map structure, key for some of the identification factory classes defined in the file, value is some factory classes that can be automatically configured, and value saves and repeats with list.

Look back at loadSpringFactories (classLoaderToUse) .getOrDefault (factoryTypeName, Collections.emptyList ())

Because the first parameter carried by the loadFactoryNames method is EnableAutoConfiguration.class, the factoryType value is also EnableAutoConfiguration.class, so the factoryTypeName value is EnableAutoConfiguration. The value obtained is that the key under the META-INF/spring.factories file is

The value of org.springframework.boot.autoconfigure.EnableAutoConfiguration

GetOrDefault use this key value when there is this key in the Map collection, or use the default value empty array if not

Conclusion:

LoadSpringFactories () this method loads the fully qualified class name of a factory implementation of a given type from "META-INF/spring.factories" into map

LoadFactoryNames () is based on the startup life process of SpringBoot. When the automatic configuration class needs to be loaded, the org.springframework.boot.autoconfigure.EnableAutoConfiguration parameter is passed in to find the value of key as org.springframework.boot.autoconfigure.EnableAutoConfiguration from map. These values are added to the container through reflection, and then the function is to use them for automatic configuration. This is where the automatic configuration of Springboot begins.

Only after these autoconfiguration classes have entered the container will the next autoconfiguration class start.

When other configurations are needed, such as listening for related configurations: listenter, pass different parameters to get the relevant listenter configuration.

5. Process summary diagram

6. Commonly used Conditional notes

When loading the automatic configuration class, instead of loading all the configuration of spring.factories, it is loaded dynamically through the judgment of @ Conditional and other annotations.

@ Conditional is actually the underlying annotation of spring, which means to judge different conditions according to different conditions. If the specified conditions are met, then the configuration in the configuration class will take effect.

Common Conditional comments:

@ ConditionalOnClass: takes effect when this class exists in classpath

@ ConditionalOnMissingClass: takes effect when this class does not exist in classpath

@ ConditionalOnBean: takes effect when this type of bean exists in the DI container

@ ConditionalOnMissingBean: takes effect when this type of bean does not exist in the DI container

@ ConditionalOnSingleCandidate: only one Bean of this type or @ Primary in the DI container takes effect

@ ConditionalOnExpression: when the result of SpEL expression is true

@ ConditionalOnProperty: takes effect when parameters are set or values are consistent

@ ConditionalOnResource: takes effect when the specified file exists

@ ConditionalOnJndi: the specified JNDI takes effect when it exists

@ ConditionalOnJava: the specified Java version takes effect when it exists

@ ConditionalOnWebApplication: effective in Web application environment

@ ConditionalOnNotWebApplication: takes effect in non-Web application environment

7. @ Import supports three ways of import

1. Configuration class with @ Configuration

The realization of 2.ImportSelector

The realization of 3.ImportBeanDefinitionRegistrar

Thank you for reading this article carefully. I hope the article "sample Analysis of the principle of SpringBoot automatic configuration" shared by the editor will be helpful to you. At the same time, I also hope that you will support us and pay attention to the industry information channel. More related knowledge is waiting for you to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.