Sind Sie es leid, es zu lernen, wie man einen Starter individuell anpasst?

Vor zwei Tagen wurde ein Freund während eines Interviews erneut nach Starter gefragt. Als ich ein Probeinterview für ihn führte, habe ich bewusst betont, dass ich selbst einen benutzerdefinierten Starter schreiben muss, und tatsächlich wurde er während des Interviews danach gefragt.

Vielleicht haben einige Leute noch keine Erfahrung mit dem Wechsel von Servlet zu Spring MVC. Wenn ja, wissen Sie, dass die Konfiguration ziemlich umständlich ist, sodass Spring Boot nicht enthalten ist.

Freunde, die Spring Boot studiert haben, sollten wissen, dass es ein Sprichwort gibt, das Spring Boot beschreibt:

Konvention ist wichtiger als Konfiguration

.

Warum heißt Spring Boot Konvention statt Konfiguration? Der Grund, warum Spring Boot „Konvention statt Konfiguration“ genannt wird, liegt darin, dass es das Designkonzept „Konvention statt Konfiguration“ übernimmt. Die herkömmliche Java-Entwicklung erfordert eine große Menge an Konfigurationen, z. B. XML-Dateien, Anmerkungen usw., und diese Konfigurationen müssen von den Entwicklern selbst angegeben werden. Spring Boot vereinfacht den Entwicklungsprozess durch die Bereitstellung einiger Standardkonfigurationen und -konventionen und reduziert so den manuellen Konfigurationsaufwand, den Entwickler durchführen müssen.

Spring Boot führt einige allgemeine Konfigurationsaufgaben automatisch über einige Standardkonfigurationseigenschaften und -konventionen aus, z. B. automatische Konfiguration von Datenquellen, automatische Konfiguration von Webservern, automatische Konfiguration von Protokollen usw. Entwickler müssen lediglich Code- und Konfigurationsdateien in einer vereinbarten Weise organisieren, um schnell eine funktionierende Anwendung zu erstellen.

Dieses Designkonzept, bei dem Konventionen vor Konfiguration stehen, ermöglicht es Entwicklern, nicht mehr auf einige herkömmliche Konfigurationsdetails achten zu müssen und sich mehr auf die Implementierung der Geschäftslogik zu konzentrieren. Gleichzeitig bietet Spring Boot auch einige erweiterbare Konfigurationsoptionen, die es Entwicklern ermöglichen, sie entsprechend ihren eigenen Anforderungen anzupassen und zu erweitern.

Im Allgemeinen ermöglicht das Designkonzept von Spring Boot, Konventionen vor Konfiguration zu setzen, Entwicklern eine schnellere und effizientere Entwicklung von Anwendungen und reduziert die Konfigurationskomplexität. Dies ist auch der Grund, warum Spring Boot zu einem der am weitesten verbreiteten Frameworks in der Java-Entwicklung werden kann.

Im Interview habe ich Sie gebeten, über das automatische Montageprinzip von Spring Boot zu sprechen. Wir können dies einfach beantworten:

Das automatische Montageprinzip von Spring Boot wird durch

Dateien implementiert.

@EnableAutoConfiguration注解是用来开启自动装配的功能，该注解通常放在应用的主类上。

spring.factories文件是一个位于META-INF目录下的配置文件，其中定义了各个自动装配类的全限定名。

当Spring Boot启动时，会加载classpath下的所有spring.factories文件，并根据其中定义的自动装配类的全限定名，将其实例化并添加到Spring应用上下文中。

自动装配类通常会通过@Configuration注解来标注，同时会使用各种注解（如@ComponentScan、@Import等）来实现相应的自动装配逻辑。

通过@EnableAutoConfiguration注解和spring.factories

Wenn Spring Boot startet, werden alle Spring. factorys-Datei erstellen, instanziieren und zum Spring-Anwendungskontext hinzufügen, basierend auf dem vollständig qualifizierten Namen der darin definierten automatisch verdrahteten Klasse.
Autowired-Klassen bestehen normalerweise @Import usw.), um die entsprechende automatische Assemblierungslogik zu implementieren.

@EnableAutoConfiguration Annotation und

Wenn Sie es einmal auswendig lernen, können Sie es in zwei Tagen vergessen, aber wenn Sie es erneut auswendig lernen, können Sie es vielleicht ungefähr merken.

Solange wir wissen, wie man einen Starter individuell anpasst, wird es tatsächlich viel einfacher sein, die oben genannten Fragen zu beantworten.

🎜🎜Wenn wir Spring Boot zum Entwickeln verwenden, sind verschiedene Starter am häufigsten. 🎜🎜Häufige Starter🎜🎜Es gibt viele häufig verwendete Starter in Spring Boot. Hier sind einige gängige Starter: 🎜

• spring-boot-starter-web: Starter zum Erstellen von Webanwendungen, einschließlich Spring MVC und Tomcat-Server. Es bietet Funktionen zur Verarbeitung von HTTP-Anfragen und -Antworten.
• spring-boot-starter-data-jpa: Starter für die Interaktion mit relationalen Datenbanken, einschließlich Spring Data JPA und Hibernate. Es vereinfacht die Interaktion mit der Datenbank und bietet allgemeine CRUD-Operationen.
• spring-boot-starter-security: Ein Starter zum Hinzufügen von Sicherheitsfunktionen, einschließlich Spring Security und OAuth2. Es bietet Authentifizierungs-, Autorisierungs- und Sicherheitskonfigurationsfunktionen.
• spring-boot-starter-test: Starter zum Schreiben von Unit-Tests und Integrationstests, einschließlich JUnit und Spring Test. Es bietet ein Test-Framework und Tools zur Erleichterung von Unit-Tests und Integrationstests.
• spring-boot-starter-actuator: Ein Starter für die Überwachung und Verwaltung von Anwendungen, einschließlich Gesundheitsprüfung, Indikatorerfassung und Fernverwaltungsfunktionen. Es bietet die Funktionalität zur Überwachung des Ausführungsstatus von Anwendungen.
• spring-starter-cache: Starter zum Hinzufügen von Cache-Unterstützung, einschließlich Spring Cache und Ehcache. Es bietet die Möglichkeit, Daten zwischenzuspeichern und die Anwendungsleistung zu verbessern.
• spring-boot-starter-data-redis: Ein Starter für die Interaktion mit Redis-Datenbanken, einschließlich Spring Data Redis. Es vereinfacht die Interaktion mit Redis und bietet allgemeine Betriebsmethoden.
• spring-boot-starter-mail: Starter zum Versenden von E-Mails, einschließlich JavaMail und Spring Mail. Es bietet Funktionen zum Versenden von E-Mails.
• spring-boot-starter-log4j2: Starter für die Protokollierung mit Log4j2. Es bietet Protokollierungsfunktionen, um das Debuggen und die Fehlerverfolgung zu erleichtern.
• spring-boot-starter-thymeleaf: Starter für die Verwendung der Thymeleaf-Template-Engine. Es bietet Funktionen für das Rendern von Seiten mit Thymeleaf.
• ......

Diese Starter können entsprechend den Anforderungen der Anwendung ausgewählt und verwendet werden. Sie bieten verschiedene Funktionen und Annehmlichkeiten und vereinfachen den Anwendungsentwicklungs- und Konfigurationsprozess.

Sie finden anhand der Benennung: spring-boot-starter开头的spring-boot-starter-xxx。

但，我们在项目中也简单过这样的：mybatis-spring-boot-starter

Allerdings haben wir in unserem Projekt auch einfach Folgendes verwendet: Eigentlich nennen wir normalerweise xxx -spring-boot-starterDieses Format wurde von mir selbst erstellt, es dient nur der Benennung. spring-boot-starter-xxx是spring官方给咱们搞的，xxx-spring-boot-starter这种格式就是自己搞的，只是个命名而已。

我们为何不能自己也来搞个starter过过瘾呗，哈哈哈，开搞。

自定义starter

我们来搞一个redisson的starter。

第一步创建一个Spring Boot项目，命名为：redisson-spring-boot-starter。

其中，pom依赖重点：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
        <version>2.3.1.RELEASE</version>
        <!-- 不让jar进行传递 避免jar包冲突-->
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.redisson</groupId>
        <artifactId>redisson</artifactId>
        <version>3.13.1</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-configuration-processor</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

创建配置解析类：RedissonProperties

/**
 * @author tianwc  公众号：java后端技术全栈、面试专栏
 * @version 1.0.0
 * @date 2023年07月20日 11:35
 * 在线刷题 1200+题和1000+篇干货文章：<a href="http://woaijava.cc/">博客地址</a>
 * 
 * 解析配置项
 */
@ConfigurationProperties(prefix = "tian.redisson")
public class RedissonProperties {

    private String host="localhost";
    private int port=6379;
    private int timeout;

    //get set 省略
}

自动装配类：RedissonAutoConfiguration

/**
 * @author tianwc  公众号：java后端技术全栈、面试专栏
 * @version 1.0.0
 * @date 2023年07月20日 11:27
 * 在线刷题 1200+题和1000+篇干货文章：<a href="http://woaijava.cc/">博客地址</a>
 */
//（条件装配）只有在我们的classpath目录下有Redisson.class 我们才自动装配RedissonClient bean
//@ConditionalOnClass(Redisson.class)
@EnableConfigurationProperties(RedissonProperties.class)
@Configuration
public class RedissonAutoConfiguration {
    private static final String PREFIX="redis://";
    @Bean
    public RedissonClient redissonClient(RedissonProperties redissonProperties){
        Config config=new Config();
        //redis单机模式
        config.useSingleServer().setAddress(PREFIX+redissonProperties.getHost()+":"+redissonProperties.getPort())
                .setConnectTimeout(redissonProperties.getTimeout());
        return Redisson.create(config);
    }
}

然后，在resources目录下创建：META-INF目录，在这个目录下创建spring.factories文件，文件内容：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.tian.RedissonAutoConfiguration

完事，这么就搞定了。是不是还没缓过神来？

使用自定义starter

再创建个spring Boot项目，把我们自定义的starter引入进来。

<dependency>
    <groupId>com.tian</groupId>
    <artifactId>charge-sms-spring-boot-starter</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

由于我们在RedissonProperties

Warum können wir nicht einfach selbst einen Starter starten, um Spaß zu haben, hahaha, lasst es uns tun.

Benutzerdefinierter Starter

uns Fangen wir an ein Redisson-Starter.

Der erste Schritt besteht darin, ein Spring Boot-Projekt mit dem Namen zu erstellen: redisson-spring-boot-starter.

Unter diesen sind die wichtigsten Punkte der Pom-Abhängigkeit:

tian.redisson.host=localhost
tian.redisson.port=6379
tian.redisson.timeout=1000

Erstellen Sie eine Konfigurations-Parsing-Klasse: RedissonProperties

{
  "properties": [
    {
      "name": "tian.redisson.host",
      "type": "java.lang.String",
      "description": "redis服务地址ip",
      "defaultValue": "localhost"
    },
    {
      "name": "tian.redisson.port",
      "type": "java.lang.Integer",
      "description": "redis服务端口号",
      "defaultValue": 6379
    },
    {
      "name": "tian.redisson.timeout",
      "type": "java.lang.Integer",
      "description": "redis连接超时时间",
      "defaultValue": 1000
    }
  ]
}

🎜Auto-Wiring-Klasse: RedissonAutoConfiguration🎜

@Slf4j
@RestController
@RequestMapping("/test")
public class TestController {

    @Resource
    private RedissonClient redissonClient; 

    @GetMapping("/redisson")
    public String redisson() {
        RBucket bucket = redissonClient.getBucket("name");
        if(bucket.get()==null){
            bucket.set("公众号：java后端技术全栈");
        } 
        return bucket.get().toString();
    }
}

🎜Dann erstellen Sie: META-INF-Verzeichnis im Ressourcenverzeichnis, erstellen Sie spring.factories Datei, Dateiinhalt: 🎜rrreee🎜Es ist fertig, das war's. Sind Sie noch nicht genesen? 🎜

Benutzerdefinierten Starter verwenden

🎜 Erstellen Sie einen anderen Spring Boot-Projekt und stellen Sie unseren maßgeschneiderten Starter vor. 🎜rrreee🎜Da wir 35, 0,05 verwenden);font-family: „Operator Mono“, Consolas, Monaco, Menlo, monospace;word-break: break-all;color: rgb(239, 112, 96);“> RedissonProperties-Klasse Standardwerte werden Host und Port zugewiesen. Wenn wir also keine Parameter in der Datei application.properties konfigurieren, verwenden wir die Standardwerte. 🎜🎜Wenn es konfiguriert ist, lautet es wie folgt:🎜rrreee🎜Wenn Sie jedoch wirklich so spielen, werden Sie feststellen, dass wir bei der Konfiguration normalerweise etwas dazu auffordern, z. B.: 🎜🎜🎜🎜🎜Ist das nicht so? Schnell genug? Fühlen Sie sich gut? 🎜

要想有这个提示，还得在redisson-spring-boot-starter中搞点事情。

相关jar上面都已经引入了这里不再赘述。

同样是在META-INF下面创建一个文件(文件名需要注意不要写错)：additional-spring-configuration-metadata.json

内容如下：

{
  "properties": [
    {
      "name": "tian.redisson.host",
      "type": "java.lang.String",
      "description": "redis服务地址ip",
      "defaultValue": "localhost"
    },
    {
      "name": "tian.redisson.port",
      "type": "java.lang.Integer",
      "description": "redis服务端口号",
      "defaultValue": 6379
    },
    {
      "name": "tian.redisson.timeout",
      "type": "java.lang.Integer",
      "description": "redis连接超时时间",
      "defaultValue": 1000
    }
  ]
}

properties对应一个数组，每个配置项占一个。

• name：就是我们的配置项
• type：配置项类型
• description：配置项的描述
• defaultValue：默认值

重新打包，在使用的项目里执行Reload All Maven。

接着，再去properties文件里配置，就会有对应的提示了。

我们写一个controller来使用：

@Slf4j
@RestController
@RequestMapping("/test")
public class TestController {

    @Resource
    private RedissonClient redissonClient; 

    @GetMapping("/redisson")
    public String redisson() {
        RBucket bucket = redissonClient.getBucket("name");
        if(bucket.get()==null){
            bucket.set("公众号：java后端技术全栈");
        } 
        return bucket.get().toString();
    }
}

执行结果：

到这里，我们就搞定了一个自定义starter。

在实际项目中，在自定义starter时，可能还会用到下面这些注解，请注意收藏：

@Conditional：按照一定的条件进行判断，满足条件给容器注册bean

@ConditionalOnMissingBean：给定的在bean不存在时,则实例化当前Bean

@ConditionalOnProperty：配置文件中满足定义的属性则创建bean，否则不创建

@ConditionalOnBean：给定的在bean存在时,则实例化当前Bean

@ConditionalOnClass：当给定的类名在类路径上存在，则实例化当前Bean

@ConditionalOnMissingClass

;Hintergrundfarbe: RGBA (27, 31, 35, 0,05);Schriftfamilie: „Operator Mono“, Consolas, Monaco, Menlo, Monospace;Wortumbruch: Break-All;Farbe: RGB(239, 112, 96 );">@ConditionalOnMissingBean

: Wenn die angegebene Bean nicht existiert, instanziieren Sie die aktuelle Bean

@ConditionalOnProperty: Wenn die definierten Eigenschaften in der Konfigurationsdatei erfüllt sind, wird die Bean erstellt, andernfalls wird sie nicht erstellt@ConditionalOnBean: Wenn die angegebene Bean existiert, instanziieren Sie die aktuelle Bean

Wir haben oben gerade eine eigenständige Version erstellt. Tatsächlich können wir auch verschiedene Versionen von Master-Slave erstellen. Sentinel, Cluster usw., oder wir können den SSL-Zugriff ermöglichen.

Da Sie nun wissen, wie Sie es anpassen können, ist es an der Zeit, es in tatsächlichen Projekten zu verwenden. Wir können nicht immer bei der Demo bleiben. Die einzige Möglichkeit besteht darin, es im Projekt zu verwenden.

🎜Im Ladesäulenprojekt habe ich einen benutzerdefinierten Starter in der SMS-Sendefunktion und auch das Vorlagenmethodenmuster verwendet. 🎜🎜🎜🎜🎜🎜🎜🎜

Das obige ist der detaillierte Inhalt vonSind Sie es leid, es zu lernen, wie man einen Starter individuell anpasst?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!