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

This article is about how SpringBoot customizes Starter. The editor thinks it is very practical, so share it with you as a reference and follow the editor to have a look.

What is Starter?

Starter is a very important concept in Spring Boot. Starter is equivalent to a module. It can integrate the dependencies needed by the module and automatically configure the Bean in the module according to the environment (conditions).

Users only need to rely on the Starter of the corresponding function, and without too much configuration and dependence, Spring Boot can automatically scan and load the corresponding module and set the default value, which can be used immediately out of the box.

Why use Starter

In our daily development work, there are often some configuration modules independent of the business, and we often put them under a specific package, and then if another project needs to reuse this function, it is extremely troublesome to hard copy the code to another project and reintegrate it.

If we package these function configuration modules independent of the business code into starter and set default values in starter, we only need to reference dependencies in pom when we reuse them, and Spring Boot can automatically assemble them for us to use right out of the box.

Springboot automatic configuration

Starter in SpringBoot is a very important mechanism, which can abandon the previous complicated configuration and integrate it into starter. The application only needs to introduce starter dependency into maven, and SpringBoot can automatically scan the spring.factories file of the classpath path under each jar package, load the automatic configuration class information, load the corresponding bean information and start the corresponding default configuration.

Spring Boot provides spring-boot-starter dependency modules for daily enterprise application research and development scenarios. All of these dependency modules follow the conventional default configuration and allow us to adjust these configurations, that is, to follow the concept of "convention is greater than configuration".

You can take a look at an article I wrote earlier, which introduces in detail the process of springboot automatic configuration: one article understands the principle of SpringBoot automatic configuration.

Spring.factories

SpringBoot scans packages at the same level as the startup class by default. If our Starter is not under the same main package as the startup class, you need to configure the spring.factories file to take effect. SpringBoot loads the spring.factories file of the classpath path under each jar package by default, and the configured key is org.springframework.boot.autoconfigure.EnableAutoConfiguration.

Notes commonly used in Starter development

The use of annotations has been greatly convenient for us to develop, and we no longer need to write xml configuration files. SpringBoot looks up the spring.factories file and loads the automatic configuration class, which defines a variety of runtime judgment conditions, such as @ ConditionalOnMissingBean (A.class). As long as there is no specified A-type bean information in the ioc container, the configuration file will take effect.

@ Conditional is a new annotation provided by Spring4. Its function is to judge according to certain conditions and register bean for the container if the conditions are met.

1. Attribute mapping annotation

@ ConfigurationProperties: mapping of profile attribute values and entity classes

@ EnableConfigurationProperties: used in conjunction with @ ConfigurationProperties to add @ ConfigurationProperties decorated classes to the ioc container.

two。 Configure bean comments

Configuration: identifies the class as a configuration class and injects it into the ioc container

@ Bean: commonly used in methods, declare that a bean,bean name defaults to the method name and the type is the return value.

3. Conditional annotation

@ Conditional: create a specific Bean based on the conditional class, which needs to implement the Condition interface and override the matches interface to construct the judgment condition.

@ ConditionalOnBean: a Bean will be instantiated only if the specified bean exists in the container

@ ConditionalOnMissingBean: the specified bean does not exist in the container before a Bean is instantiated

@ ConditionalOnClass: a Bean will be instantiated only if there is a specified class in the system

@ ConditionalOnMissingClass: a Bean is instantiated only if no class is specified in the system

@ ConditionalOnExpression: a Bean is instantiated only when the SpEl expression is true

@ AutoConfigureAfter: instantiate a bean after it has been automatically configured

AutoConfigureBefore: instantiate a bean before completing its automatic configuration

@ ConditionalOnJava: whether the version in the system meets the requirements

ConditionalOnSingleCandidate: triggers instantiation when there is only one Bean specified in the container, or when there are multiple but the preferred Bean is specified

@ ConditionalOnResource: whether the specified resource file exists under the classpath

@ ConditionalOnWebApplication: it's a web application

@ ConditionalOnNotWebApplication: not a web application

@ ConditionalOnJndi:JNDI specifies the existence item

@ ConditionalOnProperty: configure the loading rules for Configuration

Prefix: configure the prefix of the attribute name

Value: array to get the value of the corresponding property name, which cannot be used with name at the same time

Name: array, which can be combined with prefix to form a complete configuration property name. It cannot be used with value.

HavingValue: compare whether the obtained attribute value is the same as the value given by havingValue before loading the configuration

MatchIfMissing: whether this configuration property can be loaded if it is missing. If true, it will load normally without the configuration property; otherwise, it will not take effect.

Full full mode and Lite lightweight mode

@ Configuration parameter proxyBeanMethods:

Full full mode (default): @ Configuration (proxyBeanMethods = true)

Under the same configuration class, when the object injected by the @ Bean-modified method is called directly, the calling method will be proxied to fetch the bean real column from the ioc container, so the real column is the same. That is, a single instance object. In this mode, every time SpringBoot starts, it determines whether the component exists in the container.

Lite lightweight mode: @ Configuration (proxyBeanMethods = false)

Under the same configuration class, when you directly call the object injected by the @ Bean-modified method, calling the method will not be proxied, which is equivalent to directly calling a normal method. There will be a construction method, but without the life cycle of bean, different instances will be returned.

Note: proxyBeanMethods is intended to allow methods annotated with @ Bean to be proxied. Instead of setting parameters for @ Bean's singleton and multiple instances.

The test examples are not shown here. You can download my code to view it.

@ Configuration (proxyBeanMethods = false) public class AppConfig {/ / put a myBean to the ioc container @ Bean public Mybean myBean () {return new Mybean ();} / put a yourBean to the ioc container @ Bean public YourBean yourBean () {System.out.println ("=") / / Note: @ Configuration (proxyBeanMethods = false): myBean () method does not proxy, call directly / / Note: @ Configuration (proxyBeanMethods = true): myBean () method proxy, get return new YourBean (myBean ()) from the ioc container;}}

When to use Full full mode and when to use Lite lightweight mode?

When there are dependencies between bean instances injected into the container in your same Configuration configuration class, it is recommended to use Full full mode

When there are no dependencies between bean instances injected into the container in your same Configuration configuration class, it is recommended to use Lite lightweight mode to improve the startup speed and performance of springboot.

Starter naming convention

Spring official Starter is usually named spring-boot-starter- {name} such as: spring-boot-starter-web

Spring officially recommends that unofficial Starter naming should follow the format of {name}-spring-boot-starter, such as mybatis-spring-boot-starter.

Develop Starter1. Create a Starter project

After you create a new project, delete the main startup class

two。 Add dependency org.springframework.boot spring-boot-starter-parent 2.6.1 4.0.0 com.ljw ljw-spring-boot-starter 1.0 1.8 8 org.springframework.boot spring-boot-starter Org.springframework.boot spring-boot-autoconfigure org.springframework.boot spring-boot-configuration-processor true

We have no main entry, so we need to remove the maven packaging plug-in spring-boot-maven-plugin from the pom file.

Spring-boot-configuration-processor function:

Spring-boot-configuration-processor is actually an annotation processor that works during the compilation phase. Generally, the declaration in maven is that optional is true.

You can click port in idea, enter this field, and you can also see the configuration prompt.

This is because there is a spring-configuration-metadata.json file in your resource file, which is the metadata of the spring configuration, in the form of json

3. Write attribute classes

@ ConfigurationProperties can define a configuration information class and map it to the configuration file

@ ConfigurationProperties (prefix = "ljw.config") public class HelloProperties {private String name = "hello default!" ; private int age = 8; public int getAge () {return age;} public void setAge (int age) {this.age = age;} public String getName () {return name;} public void setName (String name) {this.name = name;}} 4. Custom business class

Here you can simulate some business classes that have obtained the configuration file information for business operations.

Public class HelloService {private String name; private int age; public String getName () {return name;} public void setName (String name) {this.name = name;} public int getAge () {return age;} public void setAge (int age) {this.age = age } public String hello () {return "HelloService {" + "name='" + name +''+ ", age=" + age +'}';}} 5. Write automatic configuration classes

Naming convention: XxxAutoConfiguration

@ Configuration (proxyBeanMethods = false) / / this autoconfiguration class will take effect only when a class exists @ ConditionalOnClass (value = {HelloService.class}) / / Import our custom configuration class for the current class to use @ EnableConfigurationProperties (value = HelloProperties.class) / / this autoconfiguration class will take effect only if it is not a web application @ ConditionalOnWebApplication// determines whether the value of ljw.config.flag is "true" MatchIfMissing = true: @ ConditionalOnProperty (prefix = "ljw.config", name = "flag", havingValue = "true", matchIfMissing = true) public class HelloAutoConfiguration {/ * @ param helloProperties direct method signature into parameter HelloProperties can also be loaded without this configuration attribute. You can also use attribute injection * @ return * / @ Bean @ ConditionalOnMissingBean (HelloService.class) / / @ ConditionalOnProperty (prefix = "ljw.config", name = "flag"). HavingValue = "true", matchIfMissing = true) public HelloService helloService (HelloProperties helloProperties) {HelloService helloService = new HelloService () / / inject the acquired information into helloService.setName (helloProperties.getName ()); helloService.setAge (helloProperties.getAge ()); return helloService;}}

Note: a web application can be injected here, and whether the value of ljw.config.flag is "true" or whether the key is not configured to inject HelloService service.

6. Write spring.factories

Configure the automatic configuration class HelloAutoConfiguration under the key of org.springframework.boot.autoconfigure.EnableAutoConfiguration, and springboot will automatically load the file and assemble it according to the conditions.

Org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ com.ljw.starter.config.HelloAutoConfiguration7. Write a configuration prompt file (optional)

Additional-spring-configuration-metadata.json

After configuring the additional-spring-configuration-metadata.json file, the developer's IDE tool uses personally written configuration reads to effectively complete the prompts under the application.properties or application.yml file.

Configure detailed format parameters to view the document

My configuration:

{"properties": [{"name": "ljw.config.name", "type": "java.lang.String", "defaultValue": "hello default! Here are the prompts. The real default value is in Properties "," description ":" this is the string name. "}, {" name ":" ljw.config.age "," defaultValue ": 8," description ":" this is the age of int type. "," deprecation ": {" reason ":" obsolete reason. " "replacement": "alternative key is: ljw.config.age22", "level": "warning"}}]}

Please refer to the following properties table for configuration understanding.

Deprecation the JSON object contained in the attributes of each properties element can contain the following attributes:

Spring-configuration-metadata.json

The amount of spring-configuration-metadata.json code is quite large, so we can generate it through IDE for convenience. Here we use idea.

Search for Annotation Processors in the idea settings, and then check Enable annonation processing. You can see the automatically generated spring-configuration-metadata.json in the compiled and packaged file. We don't have to write this file.

The following is automatically generated:

{"groups": [{"name": "ljw.config", "type": "com.ljw.starter.properties.HelloProperties", "sourceType": "com.ljw.starter.properties.HelloProperties"}], "properties": [{"name": "ljw.config.name", "type": "java.lang.String", "description": "this is a string name." "sourceType": "com.ljw.starter.properties.HelloProperties", "defaultValue": "hello default! Here are the prompts. The real default values are in Properties "}, {" name ":" ljw.config.age "," type ":" java.lang.Integer "," description ":" this is the age of int type. "," sourceType ":" com.ljw.starter.properties.HelloProperties "," defaultValue ": 8," deprecated ": true," deprecation ": {" level ":" warning " "reason": "reasons for obsolescence.", "replacement": "alternative key is: ljw.config.age22"}], "hints": []} Test Starter1. Pre-environment

Install package Custom starter Project: ljw-spring-boot-starter

New project: ljw-test-spring-boot-starter

two。 Add dependency

Introduce a packed custom starter

Org.springframework.boot spring-boot-starter org.springframework.boot spring-boot-starter-web com.ljw ljw-spring-boot-starter 1.0 3. Test class @ Servicepublic class TestController implements CommandLineRunner {/ * inject custom starter service * / @ Resource private HelloService helloService; @ Override public void run (String... Args) throws Exception {System.out.println (helloService.hello ());}} 4. Modify the configuration file

Enter the prefix to see that there is already a hint

Ljw.config.name=ljw helloroomljw.config.ageroom99ljw.config.persistent truth # will not be injected # ljw.config.flag=true1# can see which debug=true5 is automatically configured. Run the program to print HelloService {name='ljw hellograms, age=99}

Conditional injection

If there is no spring-boot-starter-web dependency, service HelloService cannot be injected

If ljw.config.flag is configured, the value is not true, and the service HelloService; cannot be injected. If ljw.config.flag is not configured, it can be injected.

6. Check how the automatic configuration class takes effect

By enabling the debug=true property, let the console print the automatic configuration report, so you can easily know which automatic configuration classes are in effect.

HelloAutoConfiguration matched:-@ ConditionalOnClass found required class' com.ljw.starter.service.HelloService' (OnClassCondition)-@ ConditionalOnWebApplication (required) found 'session' scope (OnWebApplicationCondition)-@ ConditionalOnProperty (ljw.config.flag=true) matched (OnPropertyCondition) HelloAutoConfiguration#helloService matched:-@ ConditionalOnMissingBean (types: com.ljw.starter.service.HelloService; SearchStrategy: all) did not find any beans (OnBeanCondition) Thank you for reading! This is the end of this article on "how to customize SpringBoot Starter". I hope the above content can be of some help to you, so that you can learn more knowledge. if you think the article is good, you can share it out for more people to see!

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.