Analyse der SpringCloud-Spring Boot Starter-Nutzungstestinstanz

Was ist Spring Boot Starter?

Spring Boot Starter ist ein in der SpringBoot-Komponente vorgeschlagenes Konzept, das viele umständliche Konfigurationen vereinfacht. Durch die Einführung verschiedener Spring Boot Starter-Pakete können Sie schnell das Gerüst eines Projekts aufbauen.

Zum Beispiel einige von denen, die wir oft verwenden:

spring-boot-starter-web:

#🎜🎜 #spring-boot -starter-data-redis:

spring-boot-starter-data-mongodb:

spring-boot-starter-data-jpa: #🎜🎜 ##🎜🎜 #spring-boot-starter-activemq：

Im Allgemeinen ist Starter eine Synthese von Abhängigkeiten.

Vorheriger traditioneller Ansatz

Bevor es einen Starter gab, musste ich für traditionelle SSM-Projekte möglicherweise Folgendes tun, wenn ich JPA im Frühjahr verwenden wollte: #🎜🎜 #

Führen Sie zuerst die Abhängigkeiten der in Maven verwendeten Datenbank ein>>Führen Sie dann die Abhängigkeiten von jpa ein>>Konfigurieren Sie einige Attributinformationen in XML>>Debuggen Sie den Aufruf, bis er normal ausgeführt werden kann.

Der obige Vorgang weist einige Probleme auf, wie zum Beispiel:

Wenn der Prozess kompliziert ist, erhöht ein solcher Schritt-für-Schritt-Vorgang die Möglichkeit von Fehlern.

Die Konfiguration nimmt auch viel Zeit in Anspruch und ist für Anfänger und Anfänger nicht sehr benutzerfreundlich.

Nach der Verwendung von Spring Boot Starter

Der Hauptzweck des Starters besteht darin, die oben genannten Probleme zu lösen

Das Konzept des Starters:

# 🎜 🎜#starter enthält alle verwendeten Abhängigkeiten und vermeidet so die Probleme, die durch die Einführung von Abhängigkeiten durch Entwickler selbst verursacht werden. Es ist zu beachten, dass verschiedene Starter darauf ausgelegt sind, unterschiedliche Abhängigkeiten zu lösen, sodass ihre internen Implementierungen sehr unterschiedlich sein können. Beispielsweise können der Starter von JPA und der Starter von Redis unterschiedliche Implementierungen haben. Dies liegt daran, dass der Kern des Starters in der Synthesegröße liegt . Dies ist eine Abstraktionsebene auf logischer Ebene. Möglicherweise ähnelt dieses Konzept Docker, da beide eine „Paketierungs“-Operation durchführen. Wenn Sie wissen, welches Problem Docker lösen soll, können Sie möglicherweise Docker und Starter Make verwenden eine Analogie.

Starter-Implementierung:

Obwohl verschiedene Starter unterschiedliche Implementierungen haben, verwenden sie im Grunde die gleichen zwei Dinge: ConfigurationProperties und AutoConfiguration. Da Spring Boot fest an das Konzept „Konvention vor Konfiguration“ glaubt, verwenden wir ConfigurationProperties zum Speichern unserer Konfigurationen. Diese Konfigurationen können einen Standardwert haben. Das heißt, wenn wir die ursprüngliche Konfiguration nicht aktiv überschreiben, wird der Standardwert übernommen Effekt, der in vielen Situationen sehr nützlich ist. Darüber hinaus können mit den ConfigurationProperties des Starters auch alle Konfigurationseigenschaften in einer Datei zusammengefasst werden (normalerweise application.properties im Ressourcenverzeichnis), sodass wir uns im Spring-Projekt von der XML-Hölle verabschieden.

Der Behälter, von dem der oben genannte Starter abhängt, unterscheidet sich nicht von dem Behälter, von dem wir abhängig sind, wenn wir ihn manuell konfigurieren, sodass wir davon ausgehen können, dass der Starter tatsächlich verwendet wird Überlassen Sie einige mühsame Konfigurationsvorgänge sich selbst und überlassen Sie die Einfachheit den Benutzern. ConfigurationProperties hilft Benutzern nicht nur dabei, langwierige Build-Vorgänge zu eliminieren, sondern unterstützt sie auch dabei, unnötige Konfigurationsvorgänge im Rahmen des Konzepts „Konvention vor Konfiguration“ zu reduzieren. Und aufgrund der Existenz der Datei application.properties müssen alle Konfigurationen nur in einer Datei durchgeführt werden, selbst wenn eine benutzerdefinierte Konfiguration erforderlich ist, was sehr praktisch ist. Die verwendeten Starter sind alle oben aufgeführt.

Spring Boot Starter-Schritte erstellen

Starterprojekt erstellen

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.factoriesConfigurationProperties erstellen, um Konfigurationsinformationen zu speichern

#🎜🎜#AutoConfiguration, Referenz erstellen die definierten Konfigurationsinformationen #🎜🎜##🎜🎜# Implementieren Sie alle Vorgänge, die der Starter in AutoConfiguration ausführen soll, und fügen Sie diese Klasse zur Konfigurationsdatei spring.factories zur Deklaration hinzu #🎜🎜##🎜🎜#Die verpackten Elemente befinden sich in der SpringBoot-Projekt Führen Sie die Projektabhängigkeiten ein und verwenden Sie dann den Starter #🎜🎜##🎜🎜# Spezifische Schritte: #🎜🎜##🎜🎜# Erstellen Sie in der Idee ein neues Starterprojekt und führen Sie direkt den nächsten zu generierenden Schritt aus das Projekt. #🎜🎜##🎜🎜##🎜🎜##🎜🎜#Fügen Sie die folgende Konfigurationsdatei zu XML hinzu: #🎜🎜#

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

#🎜🎜#Proterties-Klasse erstellen, um Konfigurationsinformationen zu speichern #🎜🎜#

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

#🎜🎜#Business-Klasse erstellen: #🎜🎜 #rrreee#🎜🎜#Diese Business-Klasse enthält das Attribut url und eine Methode getHtml, mit der die HTML-Daten einer Webseite abgerufen werden#🎜🎜##🎜 🎜#AutoConfiguration erstellen# 🎜🎜#rrreee#🎜🎜#In der obigen AutoConfiguration haben wir unsere Anforderungen umgesetzt: Wir haben eine Bean der HttpClient-Klasse im Kontext von Spring erstellt und der Bean einen Parameter in den Eigenschaften zugewiesen. #🎜🎜##🎜🎜#Schließlich erstellen wir ein neues Verzeichnis META-INF unter dem Ordner resources und erstellen einen neuen spring.factories in der Verzeichnisdatei und konfigurieren Sie 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 中的数据确实被覆盖

Das obige ist der detaillierte Inhalt vonAnalyse der SpringCloud-Spring Boot Starter-Nutzungstestinstanz. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!