Eine detaillierte Einführung in die Eigenschaftenkonfiguration und die benutzerdefinierte Eigenschaftskonfiguration der Spring Boot-Serie

Bei der Verwendung von Spring Boot können Sie feststellen, dass das Projekt nur sehr wenig Konfiguration erfordert, um die entsprechenden Funktionen auszuführen. Dies liegt an der modularen Konfiguration in pom.xml, die davon abhängt Konfigurationen sind für eine normale Funktionsentwicklung ausreichend.

Wenn Sie die benutzerdefinierte oder Standardkonfiguration ändern müssen, bietet Spring Boot eine sehr einfache Methode. Sie müssen lediglich die entsprechende Konfiguration in application.properties hinzufügen und ändern. (Die Standardkonfiguration von application.properties wird beim Start von Spring Boot gelesen)

1. Ändern Sie die Standardkonfiguration

Beispiel 1. Wenn Spring Boot Webanwendungen entwickelt, ist der Standard-Startport von Tomcat ist Es ist 8080. Wenn Sie den Standardport ändern müssen, müssen Sie den folgenden Eintrag in application.properties hinzufügen:

server.port=8888

Starten Sie das Projekt neu und Sie können das Startprotokoll sehen: Tomcat wurde auf Port gestartet (s): 8888 (http) Der Startport ist 8888, und Sie können darauf normal zugreifen, indem Sie im Browser auf http://localhost:8888 zugreifen.

Beispiel 2, Datenbankverbindungsinformationskonfiguration in der Spring-Boot-Entwicklung (hier mit Druid von com.alibaba), fügen Sie die folgenden Datensätze in application.properties hinzu:

druid.url=jdbc:mysql://192.168.0.20:3306/test
druid.driver-class=com.mysql.jdbc.Driver
druid.username=root
druid.password=123456
druid.initial-size=1
druid.min-idle=1
druid.max-active=20
druid.test-on-borrow=true

Die beiden oben genannten Beispiele: Darin wird erklärt, dass Sie, wenn Sie die Standardkonfiguration im Startermodul ändern müssen, nur die Konfiguration hinzufügen müssen, die geändert werden muss, in application.properties.

2. Benutzerdefinierte Eigenschaftskonfiguration

Zusätzlich zur Änderung der Standardkonfiguration in application.properties können wir hier auch benutzerdefinierte Eigenschaften konfigurieren und diese in die Entity-Bean laden.

1. Benutzerdefinierte Eigenschaftskonfiguration in application.properties hinzufügen

com.sam.name=sam
com.sam.age=11
com.sam.desc=magical sam

2. Bean-Klasse schreiben und Eigenschaften laden

Sam-Klasse muss @Component-Anmerkung hinzufügen, lassen Sie Spring scannt diese Klasse beim Start und fügt sie dem Spring-Container hinzu.

Der erste: Verwenden Sie @Value() unterstützt von Spring zum Laden

package com.sam.demo.conf;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

/**
 * @author sam
 * @since 2017/7/15
 */
@Component
public class Sam {

    //获取application.properties的属性
    @Value("${com.sam.name}")
    private String name;

    @Value("${com.sam.age}")
    private int age;

    @Value("${com.sam.desc}")
    private String desc;
    
    //getter & setter
}

Der zweite: Verwenden Sie @ConfigurationProperties(prefix=""), um das Präfix festzulegen, es sind keine Anmerkungen vorhanden auf den Grundstücken benötigt.

package com.sam.demo.conf;

import org.springframework.stereotype.Component;

/**
 * @author sam
 * @since 2017/7/15
 */
@Component
@ConfigurationProperties(prefix = "com.sam")
public class Sam {

    private String name;

    private int age;

    private String desc;

    //getter & setter
}

3. Injizieren und verwenden Sie die Sam Bean im Controller.

package com.sam.demo.controller;

import com.sam.demo.conf.Sam;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author sam
 * @since 2017/7/14
 */
@RestController
public class IndexController {

    @Autowired
    private Sam sam;

    @RequestMapping("/index")
    public String index() {
        System.out.println(sam.getName() + " " + sam.getAge() + " " + sam.getDesc());
        return "index";
    }

}

Browserzugriff: http://localhost:8080/index, die Konsole druckt den Inhalt von Sam normal aus.

3. Detaillierte Erläuterung der application.properties-Eigenschaftskonfiguration

1. Parameterreferenz und Verwendung der Zufallszahlenmethode

In application.properties können Sie direkt auf andere Objekte verweisen ${} Der Wert des Attributs ist wie folgt:

com.sam.name=sam
com.sam.age=11
com.sam.desc=${name} is ${age} years old.

Wenn Sie eine Zufallszahl in application.properties erhalten müssen, können Sie ${random} wie folgt verwenden:

#获取随机字符串
com.sam.randomValue=${random.value}

#获取随机字符串：${random.value}
#获取随机int：${random.int}
#获取10以内的随机数：${random.int(10)}
#获取10-20的随机数：${random.int[10,20]}
#获取随机long：${random.long}
#获取随机uuid：${random.uuid}

2. Multi-Umgebungskonfiguration

In der tatsächlichen Entwicklung kann es unterschiedliche Umgebungen geben, einschließlich Entwicklungsumgebung, Testumgebung und Produktionsumgebung. Zugehörige Konfigurationen können für jede Umgebung unterschiedlich sein, z. B. Datenbankinformationen, Portkonfiguration, lokale Pfadkonfiguration usw.

Wenn application.properties jedes Mal geändert werden muss, wenn Sie in eine andere Umgebung wechseln, ist der Vorgang sehr umständlich. Spring Boot bietet eine Konfiguration für mehrere Umgebungen, sodass wir problemlos zwischen Umgebungen wechseln können.

Erstellen Sie drei neue Dateien im selben Verzeichnis wie application.properties:

application-dev.properties      //开发环境的配置文件
application-test.properties     //测试环境的配置文件
application-prod.properties     //生产环境的配置文件

Die oben genannten drei Dateien entsprechen dem Konfigurationsinhalt von Entwicklung, Test und Produktion. Der nächste Schritt ist, wie zur Auswahl Diese Konfigurationen werden referenziert.

Anwendung.properties hinzufügen:

spring.profiles.active=dev
#引用测试的配置文件
#spring.profiles.active=test
#引用生产的配置文件
#spring.profiles.active=prod

Spring.profiles.active=dev hinzufügen und die Anwendung starten. Sie werden feststellen, dass auf die Konfigurationsinformationen von dev verwiesen wird.

Es ist ersichtlich, dass die oben genannten drei Konfigurationsdateien dem Format application-{profile}.properties entsprechen und der in application.properties hinzugefügte dev in spring.profiles.active=dev genau das Profil in ist obige Konfigurationsdatei. Wechseln Sie je nach Umgebung sofort.

Wenn Sie den Befehl zum Ausführen des JAR-Pakets verwenden, um die Anwendung zu starten, können Sie die entsprechende Konfiguration angeben.

java -jar demo-0.0.1-SNAPSHOT.jar --spring.profiles.active=dev

Anhang: Konfigurationsmethode und Priorität

这些方式优先级如下：
a. 命令行参数
b. 来自java:comp/env的JNDI属性
c. Java系统属性（System.getProperties()）
d. 操作系统环境变量
e. RandomValuePropertySource配置的random.*属性值
f. jar外部的application-{profile}.properties或application.yml(带spring.profile)配置文件
g. jar内部的application-{profile}.properties或application.yml(带spring.profile)配置文件
h. jar外部的application.properties或application.yml(不带spring.profile)配置文件
i. jar内部的application.properties或application.yml(不带spring.profile)配置文件
j. @Configuration注解类上的@PropertySource
k. 通过SpringApplication.setDefaultProperties指定的默认属性

Hinweis: Befehlszeilenparameter, eine Möglichkeit zum Starten von Anwendungen durch Angabe von Parametern in JAR-Paketen, können unsicher sein. Wir können das Starten von Anwendungen auf diese Weise wie folgt verhindern:

springApplication.setAddCommandLineProperties (false);

package com.sam.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
//        SpringApplication.run(DemoApplication.class, args);
        SpringApplication springApplication = new SpringApplication(DemoApplication.class);
        //禁止命令行设置参数
        springApplication.setAddCommandLineProperties(false);
        springApplication.run(args);
    }
}

Ergänzung:

Zusätzlich zur Unterstützung von application.properties unterstützt die Konfiguration in Spring Boot auch die Konfigurationsmethode von application.yml wie folgt:

Erstellen Sie eine neue application.yml anstelle von application.properties

server:
  port: 9999

com:
  sam:
    name: sam
    age: 11
    desc: magical sam

Hinweis: In der Mitte des Ports befinden sich Leerzeichen: 9999. Informationen zur YML-Syntax finden Sie unter: Verwendung der YML-Konfigurationsdatei

Das obige ist der detaillierte Inhalt vonEine detaillierte Einführung in die Eigenschaftenkonfiguration und die benutzerdefinierte Eigenschaftskonfiguration der Spring Boot-Serie. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!