Analyse de l'instance de test d'utilisation SpringCloud-Spring Boot Starter

Qu'est-ce que Spring Boot Starter ?

Spring Boot Starter est un concept proposé dans le composant SpringBoot, qui simplifie de nombreuses configurations lourdes en introduisant divers packages Spring Boot Starter, vous pouvez rapidement créer l'échafaudage d'un projet.

Par exemple, certains de ceux que nous utilisons souvent :

spring-boot-starter-web :

spring-boot-starter-data-redis :

spring-boot-starter-data-mongodb :

spring-boot -starter-data-jpa :

spring-boot-starter-activemq :

De manière générale, starter est une synthèse de dépendances.

Approche traditionnelle précédente

Avant qu'il y ait un starter, pour les projets SSM traditionnels, si je voulais utiliser jpa au Spring, je devrais peut-être faire ce qui suit :

Introduire d'abord les dépendances de la base de données utilisée dans Maven>> Ensuite, introduisez la dépendance de jpa>> Configurez certaines informations d'attribut dans XML>> Déboguez l'appel jusqu'à ce qu'il puisse s'exécuter normalement.

L'opération ci-dessus posera certains problèmes, tels que :

Si le processus est compliqué, une telle opération étape par étape augmentera le risque d'erreurs.

Cela prend également beaucoup de temps lors de la configuration, et n'est pas très convivial pour les novices et les novices.

Après avoir utilisé Spring Boot Starter, l'objectif principal du starter est de résoudre les problèmes ci-dessus. Le concept du starter :

starter inclura toutes les dépendances utilisées, évitant ainsi aux développeurs d'avoir à introduire eux-mêmes des dépendances. Il convient de noter que différents starters sont conçus pour résoudre différentes dépendances, leurs implémentations internes peuvent donc être très différentes. Par exemple, le starter de jpa et le starter de Redis peuvent avoir des implémentations différentes. En effet, l'essence du starter réside dans la taille de synthèse. . Il s'agit d'une couche d'abstraction au niveau logique. Peut-être que ce concept est quelque peu similaire à Docker, car ils effectuent tous deux une opération de "packaging". Si vous savez quel problème Docker doit résoudre, vous pouvez peut-être utiliser Docker et starter Make. une analogie.

Implémentation du démarreur :

Bien que différents démarreurs aient des implémentations différentes, ils utilisent essentiellement les deux mêmes éléments : ConfigurationProperties et AutoConfiguration. Parce que Spring Boot croit fermement au concept de « convention sur configuration », nous utilisons ConfigurationProperties pour enregistrer nos configurations, et ces configurations peuvent avoir une valeur par défaut, c'est-à-dire que si nous n'écrasons pas activement la configuration d'origine, la valeur par défaut prendra effet, ce qui est très utile dans de nombreuses situations. De plus, ConfigurationProperties du démarreur permet également de rassembler toutes les propriétés de configuration dans un seul fichier (généralement application.properties dans le répertoire des ressources), nous disons donc adieu à l'enfer XML dans le projet Spring.

Les jars sur lesquels s'appuie le démarreur ci-dessus ne sont pas différents des jars sur lesquels nous comptons lors de la configuration manuelle, nous pouvons donc penser que le démarreur se confie en fait ces opérations de configuration fastidieuses et laisse la simplicité à l'utilisateur . En plus d'aider les utilisateurs à éliminer les opérations de construction fastidieuses, ConfigurationProperties les aide également à réduire les opérations de configuration inutiles selon le concept de « convention sur la configuration ». Et grâce à l'existence du fichier application.properties, même si une configuration personnalisée est requise, toutes les configurations ne doivent être effectuées que dans un seul fichier, ce qui est très pratique à utiliser. Les starters adoptés sont tous listés ci-dessus.

Étapes pour créer Spring Boot Starter

Créer un projet de démarrage application.properties文件的存在，即使需要自定义配置，所有的配置也只需要在一个文件中进行，使用起来非常方便。采用的starter都上面都给大家列出来了。

创建Spring Boot Starter步骤

创建starter 项目

创建ConfigurationProperties 用来保存配置信息

创建AutoConfiguration，引用定义好的配置信息

在 AutoConfiguration 实现所有 starter 应该完成的操作，并且把这个类加入 spring.factories 配置文件中进行声明

打包项在 SpringBoot 项目中引入该项目依赖，然后就可以使用该 starter 了

具体操作步骤：

在idea新建一个starter项目、直接执行下一步即可生成项目。

在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>

创建 proterties 类来保存配置信息

@ConfigurationProperties(prefix = "http") 
@Getter
public class HttpProperties {
 
    // 如果配置文件中配置了http.url属性，则该默认属性会被覆盖
    private String url = "https://blog.csdn.net/weixin_39709134?type=blog";
 
}

创建业务类：

@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";
    }
 
}

这个业务类包含了url属性和一个getHtml方法，用于获取一个网页HTML 数据

创建 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;
    }
 
}

在上面的 AutoConfiguration 中我们实现了自己要求：在 Spring 的上下文中创建了一个 HttpClient 类的 bean，并且我们把 properties 中的一个参数赋给了该 bean。

最后，我们在resources文件夹下新建目录META-INF，在目录中新建spring.factories文件，并且在spring.factories

Créer des propriétés de configuration pour enregistrer les informations de configuration 🎜🎜Créer une configuration automatique et référencer les informations de configuration définies🎜🎜Dans la configuration automatique, implémentez toutes les opérations que le démarreur doit effectuer et ajoutez cette classe à spring Déclarez dans le fichier de configuration .factories🎜🎜L'élément du package introduit la dépendance du projet dans le projet SpringBoot, puis vous pouvez utiliser le starter🎜🎜Étapes spécifiques :🎜🎜Créez un nouveau projet de démarrage dans l'idée et exécutez directement le suivant étape pour générer le projet. 🎜🎜🎜🎜en XML Ajoutez le fichier de configuration suivant : 🎜

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

🎜 Créez une classe de propriétés pour enregistrer les informations de configuration 🎜

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

🎜 Créez une classe métier : 🎜rrreee🎜 Cette classe métier contient l'attribut url et un getHtml code> Méthode, utilisée pour obtenir les données HTML d'une page Web🎜🎜Create AutoConfiguration🎜rrreee🎜Dans l'AutoConfiguration ci-dessus, nous avons implémenté nos exigences : créé un bean de la classe HttpClient dans le contexte de Spring, et nous avons attribué un paramètre dans les propriétés du bean. 🎜🎜Enfin, nous créons un nouveau répertoire <code>META-INF sous le dossier resources, créons un nouveau fichier spring.factories dans le répertoire, et ajoutez-le dans Configure 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 中的数据确实被覆盖

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!