Une introduction détaillée à la configuration des propriétés et à la configuration des propriétés personnalisées de la série Spring Boot

Lors du processus d'utilisation de Spring Boot, vous pouvez constater que le projet nécessite très peu de configuration pour compléter les fonctions correspondantes. Cela est dû à la configuration modulaire de Spring Boot. Chaque Starter qui en dépend dans pom.xml a une valeur par défaut. les configurations sont suffisantes pour le développement normal des fonctions.

Si vous devez modifier la configuration personnalisée ou par défaut, Spring Boot propose une méthode très simple. Il vous suffit d'ajouter et de modifier la configuration correspondante dans application.properties. (La configuration par défaut de application.properties sera lue au démarrage du Spring Boot)

1. Modifier la configuration par défaut

Exemple 1. Lorsque Spring Boot développe des applications Web, le port de démarrage par défaut de Tomcat. est Il s'agit de 8080. Si vous devez modifier le port par défaut, vous devez ajouter l'enregistrement suivant dans application.properties :

server.port=8888

Redémarrez le projet et vous pourrez voir le journal de démarrage : Tomcat démarré sur le port (s) : 8888 (http) Le port de démarrage est 8888 et vous pouvez accéder normalement à http://localhost:8888 dans le navigateur.

Exemple 2, configuration des informations de connexion à la base de données dans le développement Spring Boot (ici en utilisant le druide de com.alibaba), ajoutez les enregistrements suivants dans application.properties :

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

Les deux exemples ci-dessus, Il explique que si vous devez modifier la configuration par défaut dans le module de démarrage, il vous suffit d'ajouter la configuration qui doit être modifiée dans application.properties.

2. Configuration des propriétés personnalisées

En plus de modifier la configuration par défaut dans application.properties, nous pouvons également configurer ici des propriétés personnalisées et les charger dans le bean entité.

1. Ajoutez une configuration de propriété personnalisée dans application.properties

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

2. Écrivez la classe Bean et chargez les propriétés

La classe Sam doit ajouter l'annotation @Component, laissez Spring analyse cette classe au démarrage et l'ajoute au conteneur Spring.

Le premier : utilisez @Value() pris en charge par Spring pour charger

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
}

Le second : utilisez @ConfigurationProperties(prefix="") pour définir le préfixe, aucune annotation n'est nécessaire sur les propriétés.

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. Injectez et utilisez le Sam Bean dans le contrôleur.

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

}

Accès navigateur : http://localhost:8080/index, la console imprime le contenu de sam normalement.

3. Explication détaillée de la configuration de la propriété application.properties

1. Référence des paramètres et utilisation de la méthode des nombres aléatoires

Dans application.properties, vous pouvez directement référencer d'autres objets via ${} La valeur de l'attribut est la suivante :

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

Si vous devez obtenir un nombre aléatoire dans application.properties, vous pouvez utiliser ${random}, comme suit :

#获取随机字符串
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. Configuration multi-environnements

Dans le développement réel, il peut y avoir différents environnements, notamment un environnement de développement, un environnement de test et un environnement de production. Les configurations associées peuvent être différentes pour chaque environnement, telles que les informations de base de données, la configuration du port, la configuration du chemin local, etc.

Si application.properties doit être modifié à chaque fois que vous passez à un environnement différent, l'opération sera très lourde. La configuration multi-environnements est fournie dans Spring Boot, ce qui nous permet de changer facilement d'environnement.

Créez trois nouveaux fichiers dans le même répertoire que application.properties :

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

Les trois fichiers ci-dessus correspondent respectivement au contenu de configuration du développement, des tests et de la production. choisir Ces configurations sont référencées.

Ajoutez application.properties :

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

Ajoutez spring.profiles.active=dev et démarrez l'application. Vous constaterez que les informations de configuration de dev sont référencées.

On peut voir que les trois fichiers de configuration ci-dessus sont conformes au format application-{profile}.properties, et le dev dans spring.profiles.active=dev ajouté dans application.properties est exactement le profil dans le fichier de configuration ci-dessus. Basculez instantanément en fonction de l'environnement spécifique.

Lorsque vous utilisez la commande pour exécuter le package jar pour démarrer l'application, vous pouvez spécifier la configuration correspondante.

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

Pièce jointe : méthode de configuration et priorité

这些方式优先级如下：
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指定的默认属性

Remarque : les paramètres de ligne de commande, une manière de démarrer une application en spécifiant des paramètres dans un package jar, peuvent être dangereux. Nous pouvons le configurer pour interdire le démarrage de l'application de cette manière, comme suit :

. 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);
    }
}

Supplémentaire :

En plus de prendre en charge application.properties, la configuration dans Spring Boot prend également en charge la méthode de configuration de application.yml, comme suit :

Créez un nouveau fichier application.yml à la place de application.properties

server:
  port: 9999

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

Remarque : Il y a des espaces au milieu du port : 9999. Pour la syntaxe yml, veuillez vous référer à : yml utilisation du fichier de configuration

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!