What is Spring Boot Starter?

Spring Boot Starter is a concept proposed in the SpringBoot component, which simplifies many cumbersome configurations. By introducing various Spring Boot Starter packages, you can quickly build the scaffolding of a project.

For example, some of the ones we often use:

spring-boot-starter-web：

spring-boot-starter-data-redis：

spring-boot-starter-data-mongodb：

spring-boot-starter-data-jpa：

spring-boot-starter-activemq：

In general, starter is a synthesis of dependencies.

Previous traditional approach

Before there was no starter, for traditional SSM projects, if I wanted to use jpa in Spring, I might need to do the following:

First of all, Introduce the dependencies of the database used in Maven>>Then introduce the dependencies of jpa>>Configure some attribute information in xml>>Debug the call until it can run normally.

The above operation will have some problems, such as:

If the process is complicated, such step-by-step operation will increase the possibility of errors.

It also takes a lot of time during configuration, and is not very friendly to novices and novices.

After using Spring Boot Starter

The main purpose of starter is to solve the above problems

The concept of starter:

starter will use all All dependencies are included, avoiding the trouble caused by developers themselves introducing dependencies. It should be noted that different starters are designed to solve different dependencies, so their internal implementations may be very different. For example, the starter of jpa and the starter of Redis may have different implementations. This is because the essence of starter lies in synthesissize. This is a layer of abstraction at the logical level. Maybe this concept is somewhat similar to Docker, because they are both doing a "packaging" operation. If you know what problem Docker is to solve, maybe you can use Docker and starter Make an analogy.

Implementation of starter:

Although different starters have different implementations, they basically use the same two things: ConfigurationProperties and AutoConfiguration. Because Spring Boot firmly believes in the concept of "convention over configuration", we use ConfigurationProperties to save our configurations, and these configurations can have a default value, that is, if we do not actively overwrite the original configuration, the default value will takes effect, which is very useful in many situations. In addition, the starter's ConfigurationProperties also allows all configuration properties to be gathered into one file (usually application.properties in the resources directory), so we say goodbye to the XML hell in the Spring project.

The jar that the above starter relies on is no different from the jar that we rely on when configuring it manually, so we can think that the starter actually handles these tedious configuration operations. Leave it to yourself and leave simplicity to the users. In addition to helping users eliminate tedious build operations, ConfigurationProperties also helps users reduce unnecessary configuration operations under the concept of "convention over configuration". And because of the existence of the application.properties file, even if customized configuration is required, all configurations only need to be performed in one file, which is very convenient to use. The adopted starters are all listed above.

Create Spring Boot Starter steps

Create starter project

Create ConfigurationProperties to save configuration information

Create AutoConfiguration and reference the defined configuration information

Implement all the operations that the starter should complete in AutoConfiguration, and add this class to the spring.factories configuration file for declaration

The package item introduces the project dependency into the SpringBoot project, and then you can use the starter

Specific steps:

Create a new starter project in idea, and directly execute the next step to generate the project.

Add the following configuration file to the xml:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <artifactId>http-starter</artifactId>
    <version>0.0.1-SNAPSHOT</version>
 
    <!-- 自定義starter都應(yīng)該繼承自該依賴 -->
    <!-- 如果自定義starter本身需要繼承其它的依賴，可以參考 https://stackoverflow.com/a/21318359 解決 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starters</artifactId>
        <version>1.5.2.RELEASE</version>
    </parent>
 
    <dependencies>
        <!-- 自定義starter依賴此jar包 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <!-- lombok用于自動生成get、set方法 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.10</version>
        </dependency>
    </dependencies>
 
</project>

Create the properties class to save the configuration information

@ConfigurationProperties(prefix = "http") 
@Getter
public class HttpProperties {
 
    // 如果配置文件中配置了http.url屬性，則該默認(rèn)屬性會被覆蓋
    private String url = "https://blog.csdn.net/weixin_39709134?type=blog";
 
}

Create the business class:

@Setter
@Getter
public class HttpClient {
 
    private String url;
 
    // 根據(jù)url獲取網(wǎng)頁數(shù)據(jù)
    public String getHtml() {
        try {
            URL url = new URL(this.url);
            URLConnection urlConnection = url.openConnection();
            BufferedReader br = new BufferedReader(new InputStreamReader(urlConnection.getInputStream(), "utf-8"));
            String line = null;
            StringBuilder sb = new StringBuilder();
            while ((line = br.readLine()) != null) {
                sb.append(line).append("\n");
            }
            return sb.toString();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "error";
    }
 
}

This business class contains the url attribute and a getHtml method, used to obtain a web page HTML data

Create AutoConfiguration

@Configuration
@EnableConfigurationProperties(HttpProperties.class)
public class HttpAutoConfiguration {
 
    @Resource
    private HttpProperties properties; // 使用配置
 
    // 在Spring上下文中創(chuàng)建一個對象
    @Bean
    @ConditionalOnMissingBean
    public HttpClient init() {
        HttpClient client = new HttpClient();
 
        String url = properties.getUrl();
        client.setUrl(url);
        return client;
    }
 
}

In the above AutoConfiguration, we implemented our requirements: we created a bean of the HttpClient class in the Spring context, and we assigned a parameter in the properties to the bean.

Finally, we create a new directory META-INF under the resources folder, create a new spring.factories file in the directory, and # Configuring AutoConfiguration in ##spring.factories:

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.nosuchfield.httpstarter.HttpAutoConfiguration

最后使用 Maven 打包該項目。之后創(chuàng)建一個 SpringBoot 項目，在項目中添加我們之前打包的 starter 作為依賴，然后使用 SringBoot 來運行我們的 starter

測試如下：

@Component
public class RunIt {
 
    @Resource
    private HttpClient httpClient;
 
    public void hello() {
        System.out.println(httpClient.getHtml());
    }
 
}

之后可以在 application.properties中修改配置來進(jìn)行測試證明 properties 中的數(shù)據(jù)確實被覆蓋

The above is the detailed content of SpringCloud-Spring Boot Starter usage test instance analysis. For more information, please follow other related articles on the PHP Chinese website!