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

This article introduces the relevant knowledge of "what are the advantages of SpringBoot automatic assembly". In the operation of practical cases, many people will encounter such a dilemma, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

1. Benefits of springBoot automatic configuration 1. Think back to when you were building a project using spring

You need to write a lot of xml about spring. For example, the bean that reads the property configuration, the data source bean, the transaction management factory bean, the entire bean of mybatis and spring, and so on. When you use this framework to build a project again, it is a cycle of operations.

But now when you use springBoot to build a project, you will find that you can implement all the configurations you don't have to write (you only need to configure them when connecting to an external database, but you don't need an application.properties configuration file at all if you use embedded database h3).

You can use the @ AutoWried @ Resource annotation in your specific business code to inject data sources, transaction factories, etc., into the business layer as if you had configured it yourself.

At this time, we will have a question.

What exactly does springBoot do so that we can use those feature objects without configuration.

In fact, springBoot uses the principle of condition-based automatic injection, that is, when a condition is met, spring will instantiate the corresponding bean of the annotation and put it into the Srping context, so that you can easily use it. The SpringBoot implementation condition configuration is inseparable from its core component @ Conditional.

Let's slowly unravel the mystery of springBoot automatic configuration.

2. @ Conditional annotation related introduction 1, @ ConditionalMini Demo

What the heck is @ Conditional? if you don't explain, let's have a little demo to get a general idea.

Describe the demo scenario: the Life entity bean is initialized by springBoot and placed in the spring context under certain conditions (@ Conditional).

1.1.The Life entity class

Life is meaningful only when dreams exist * / public class Life {/ / work private String work; / / learn private String study / / Love private String love; / / omit seter / geter}

1.2. Write our own conditional matching rules

/ * implement ConfigurationCondition (this API inherits Condition) * / public class MyTestConditional implements ConfigurationCondition {/ * set the time to use this class for parsing * 1, REGISTER_BEAN: condition resolution will be performed when registering Bean * that is to judge the condition when the corresponding @ Bean annotation and @ condition annotation are used together * @ Bean annotation corresponds to the xml tag of spring * 2, PARSE_CONFIGURATION: parsing condition when parsing @ Configuration * that is to judge the condition when the corresponding @ Configuration annotation and @ condition annotation are used together * @ Configuration annotation corresponds to the xml tag of spring * @ return * / @ Override public ConfigurationPhase getConfigurationPhase () {return ConfigurationPhase.REGISTER_BEAN } / * * this method is the core of condition judgment. If the method returns true, the condition is valid. Execute the corresponding configuration * @ param conditionContext * @ param annotatedTypeMetadata * @ return * / @ Override public boolean matches (ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {return false; / / indicates that the verification fails}

This class implements ConfigurationCondition with the following two methods

1. GetConfigurationPhase () when the conditional rule is in effect

2. Matches () condition matching rules here in order to demonstrate not to deal with specific logical conditions

Returns a Boolean value. If it is ture, the condition is established and the configuration takes effect.

On the contrary, it does not work.

1.3.Writing our java instance bean automatic configuration

@ Configuration//@Configuration is marked on the class, which is equivalent to treating the class as the xml configuration file of spring. / / the function is to configure the spring container (application context) public class ServerAutoConfiguration {@ Configuration// spring in the xml configuration file / / use this annotation to indicate When springBoot starts, the corresponding Life object / / that is, match () in MyTestConditional is generated only if MyTestConditional.class is satisfied. Return true @ Bean effective @ Conditional (MyTestConditional.class) public static class StudentAutoConfiguration {@ Bean public Life create () {System.out.println ("life start....") Return new Life ("work hard", "keep learning", "dare to love and hate");}

Unit Test of springBoot

/ / use Spring's unit test environment @ RunWith (SpringRunner.class) / / load the SpringBoot context into the unit test @ SpringBootTest (classes = AutoApplication.class) public class AutoApplicationTests {/ / inject springBoot condition-based instantiation bean @ Autowired private Life life; @ Test public void showlife () {System.out.println ("all of Life:" + life.toString ());}}

Start the springBoot project, no Life objects are found in the console and Life cannot be injected into the unit test

If match () in the modified MyTestConditional returns true and starts again, the Life object is created.

At the same time, use the unit test of SpringBoot to use the Life entity set for us by springBoot.

The entity creation process is as follows: when the springBoot project starts, all bean under @ Configuration (xml configuration of srping) will be loaded, when @ Conditional (MyTestConditional.class) is encountered, the method's Match will be called, and according to its return value to determine whether to instantiate all classes under the annotation using @ Bean @ Import annotation.

Customize a conditional configuration class / springBoot custom annotation 1, simply explain @ Condition annotation family

(1), @ Conditional

Official document definition:

"Indicates that a component is only eligible for registration when all specified conditions match"

This means that a bean is created only after some column conditions have been met. And register in the context of spring

(2), provided by SpringBoot

@ ConditionalOnWebApplication the application must be a web application

@ ConditionalOnMissingBean if there is no specified bean in the application context

@ ConditionalOnBean if there is a specified bean in the application context

@ ConditionalOnProperty (name,value) only the configuration file that has the value of the corresponding name loads the bean under this annotation

@ ConditionalOnCloudPlatform matches when in a cloud platform environment

@ ConditionalOnClass if there is a specified bean @ ConditionalOnExpression in the classpath, if the corresponding expression is successful

@ ConditionalOnJava matches successfully according to the version of JVM that the application is running

@ ConditionalOnRepositoryType succeeds when a specific type of spring Data JPA is enabled

@ ConditionalOnSingleCandidate when the bean corresponding to a particular class exists and is uniquely determined

@ ConditionalOnJndi finds the established conditions through JNDI

@ Profile is triggered by specific conditions (this configuration is used in production environments, but not in non-production environments)

@ ConditionalOnResource query from the resource file

@ ConditionalOnEnabledResourceChain queries from the resource chain

@ ConditionalOnNotWebApplication this condition works if the application is not a web application

@ ConditionalOnMissingClass create a corresponding class if it does not exist

When the condition is met, the class under the action of the annotation is loaded to work.

(3) the so-called class acting under the action of this annotation refers to

These annotations are used in the following two ways

1. If it acts on a class, all @ Bean annotations under that class will work (if the condition is true, all entity classes that load @ Bean under that annotation will be stored in the spring context)

2. If it works on the method, the corresponding @ bean annotation under the method works (if the condition is true, the entity classes that use @ Bean under the annotation are loaded and stored in the spring context)

Used with @ Configuration or @ Bean, when used with @ Configuration

Then all @ Bean methods or @ Import or @ ComponentScan under this class will be affected by its configuration conditions.

@ Configuration is equivalent to the label of spring's xml profile

The @ Bean annotation is equivalent to the label of spring's xml configuration file

@ Import (Xxx.class) injects the specified class instance into the context of spring

@ Configuration is marked on the class, which is equivalent to using the class as the xml configuration file of spring. Its function is to configure the spring container (application context).

2. Comments on custom conditions

Set up a custom annotation with demo

(1) Custom comments

/ * Custom Conditional condition annotations * / @ Target ({ElementType.TYPE, ElementType.METHOD}) @ Retention (RetentionPolicy.RUNTIME) @ Documented@Conditional (MyTestConditional.class) public @ interface ConditionalOnLife {Class [] value () default {}; String [] name () default {};}

(2) configure and use

The use of this annotation in the xml configuration file of @ Configuration / / spring indicates that the corresponding Life object / / custom conditional annotation @ ConditionalOnLife//@Conditional (MyTestConditional.class) public static class DreamAutoConfiguration {@ Bean public Dream createDream () {/ / life.toString (); System.out.println ("dream start...."); return new Dream ();}} is generated only if MyTestConditional.class is met when the Life is started.

The background call successfully created the Dream entity and put it into the spring context

This is the end of the content of "what are the advantages of SpringBoot automatic assembly". Thank you for reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

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.