SpringCloud-Spring Boot Starter usage test instance analysis

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都应该继承自该依赖 -->
    <!-- 如果自定义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属性，则该默认属性会被覆盖
    private String url = "https://blog.csdn.net/weixin_39709134?type=blog";

}

Create the business class:

@Setter
@Getter
public class HttpClient {

    private String url;

    // 根据url获取网页数据
    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上下文中创建一个对象
    @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 打包该项目。之后创建一个 SpringBoot 项目，在项目中添加我们之前打包的 starter 作为依赖，然后使用 SringBoot 来运行我们的 starter

测试如下：

@Component
public class RunIt {

    @Resource
    private HttpClient httpClient;

    public void hello() {
        System.out.println(httpClient.getHtml());
    }

}

之后可以在 application.properties中修改配置来进行测试证明 properties 中的数据确实被覆盖

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!