Utilisez Spring Boot Profile pour obtenir une configuration multi-environnement

1. Introduction

Dans le développement back-end d'applications Java, avec le développement continu du projet et le raffinement et l'ajout continus d'exigences d'application, le code dans le projet d'ingénierie est de plus en plus, la structure du projet est de plus en plus complexe et l'avancement du projet rencontrera divers problèmes :

• Le code des différents aspects est couplé les uns aux autres. À l'heure actuelle, une fois que l'application a un problème, il est difficile de localiser la cause du problème. Même si le problème est localisé, il est difficile de le résoudre. Il peut introduire plus de problèmes lors de la résolution du problème;
• Le code à plusieurs facettes est concentré dans une structure entière. Il est difficile pour les nouveaux développeurs de se joindre à l'équipe pour avoir une expérience intuitive du projet global, ce qui augmente le coût de la participation des novices au développement. Un développeur familiarisé avec l'ensemble du projet doit maintenir la structure de l'ensemble du projet ( Cela est généralement difficile à faire lorsque le projet est important et que le temps de développement est long).
• La limite du code dont les développeurs sont responsables pour eux-mêmes ou pour les autres est très vague. C'est la plus facile à rencontrer dans les projets complexes. Le résultat est que les développeurs peuvent facilement modifier le code dont d'autres personnes sont responsables et que le propriétaire du code ne le sait pas. .

Par conséquent, la division d'un projet complexe en plusieurs modules est une méthode importante pour résoudre les problèmes ci-dessus. La division de plusieurs modules peut réduire le couplage entre les codes (du couplage au niveau de la classe au couplage au niveau du bocal), et chacun Le positionnement fonctionnel du module est relativement clair (par le nom du module ou la documentation du module). En même temps, le module régule également la division de la frontière du code. Il est facile pour les développeurs de déterminer leur propre responsabilité via le module fonctionnel.

Cependant, certains problèmes seront introduits lors de la division multi-modules du projet. Il existe de nombreux fichiers de configuration liés à la configuration de l'application dans le projet. L'application peut avoir différentes configurations dans différents environnements, comme la connexion à la base de données, le niveau de journalisation, etc. Les tests et la production peuvent avoir des configurations différentes dans chaque environnement, ce qui causera beaucoup de problèmes au fonctionnement et à la maintenance du système.

Avec l'émergence et la large application du cadre de développement Spring Boot, Spring Boot est pris en charge et appliqué par la majorité des développeurs en raison de sa capacité à prendre en charge le développement et la configuration rapides des développeurs. Le profil de Spring Boot peut réaliser une commutation de configuration dans plusieurs scénarios, ce qui est pratique pour tester et déployer des environnements de production pendant le développement. Ce qui suit présentera brièvement comment utiliser le fichier de configuration du profil de démarrage Spring pour configurer les fichiers de configuration pour différents environnements.

2. Étapes de configuration de Spring Boot

1. Ajoutez l'élément de configuration application.yml dans application.yml ou application.properties sous le projet Spring Boot
   

spring:
  profiles:
    active: dev

application.properties

spring.profiles.active: dev

spring.profiles.active: dev signifie que la configuration par défaut est la configuration de l'environnement de développement. Si dev est remplacé par test, les propriétés de l'environnement de test seront chargées, etc.

Remarque: Si spring.profiles.active ne spécifie pas de valeur, seule la valeur qui ne spécifie pas le fichier spring.profiles sera utilisée, c'est-à-dire que seule la configuration commune sera chargée, c'est-à-dire que Spring Boot ne chargera que le fichier application.yml ou application.properties commun. Configuration.

2. Créez des fichiers de configuration dans différents environnements

Par exemple, l'environnement est divisé en environnement de développement, environnement de test et environnement de production, créez les fichiers suivants:

• Environnement de développement: application-dev.yml ou application-dev.properties
• Environnement de test: application-test.yml ou application-test.properties
• Environnement de production: le fichier application-prod.yml ou application-prod.properties
  application.yml est divisé en quatre parties, utilisez - comme délimiteur, la première partie de la partie de configuration commune, qui représente les propriétés communes des trois environnements, spécifiées avec spring.profiles Une valeur (développement pour dev, test pour test et production pour prod) s'affiche. Cette valeur indique dans quel profil la configuration doit être utilisée.

Par exemple, nous configurons différentes informations de base de données en fonction des différents environnements dans un projet:

• Environnement de développement

spring:
  datasource:
     name: druidDataSource
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      driver-class-name: com.mysql.jdbc.Driver
      url: jdbc:mysql://192.168.1.2:3306/myDB?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&failOverReadOnly=false&useSSL=false
      username: user1
      password: 123456
      filters: stat,wall,config
      max-active: 50
      initial-size: 1
      max-wait: 6000
      min-idle: 1
      time-between-eviction-runs-millis: 6000
      min-evictable-idle-time-millis: 30000
      validation-query: select 'x'
      test-while-idle: true
      test-on-borrow: false
      test-on-return: false
      pool-prepared-statements: true
      max-open-prepared-statements: 50
      max-pool-prepared-statement-per-connection-size: 20

• Environnement de test

spring:
  datasource:
     name: druidDataSource
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      driver-class-name: com.mysql.jdbc.Driver
      url: jdbc:mysql://192.168.20.2:3306/myTestDB?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&failOverReadOnly=false&useSSL=false
      username: user1
      password: 123456
      filters: stat,wall,config
      max-active: 150
      initial-size: 1
      max-wait: 10000
      min-idle: 1
      time-between-eviction-runs-millis: 20000
      min-evictable-idle-time-millis: 100000
      validation-query: select 'x'
      test-while-idle: true
      test-on-borrow: false
      test-on-return: false
      pool-prepared-statements: true
      max-open-prepared-statements: 100
      max-pool-prepared-statement-per-connection-size: 20

Environnement de production

spring:
  datasource:
     name: druidDataSource
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      driver-class-name: com.mysql.jdbc.Driver
      url: jdbc:mysql://172.1.16.2:3306/myProdDB?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&failOverReadOnly=false&useSSL=false
      username: prod1
      password: prod1234!@#
      filters: stat,wall,config
      max-active: 100
      initial-size: 1
      max-wait: 60000
      min-idle: 1
      time-between-eviction-runs-millis: 60000
      min-evictable-idle-time-millis: 300000
      validation-query: select 'x'
      test-while-idle: true
      test-on-borrow: false
      test-on-return: false
      pool-prepared-statements: true
      max-open-prepared-statements: 50
      max-pool-prepared-statement-per-connection-size: 20

3. Après avoir conditionné l'application, démarrez l'application

S'il est déployé sur le serveur, nous l'emballons normalement dans un package jar. Au démarrage de l'application, Spring Boot charge les informations de configuration de l'environnement concerné via l' élément de configuration spring.profiles.active dans le fichier application.yml ou application.properties . De plus, nous pouvons contrôler quelle configuration d'environnement est chargée par –spring.profiles.active = xxx , la commande de référence est la suivante:

# 表示使用开发环境的配置
java -jar xxx.jar --spring.profiles.active=dev 

# 表示使用测试环境的配置
java -jar xxx.jar --spring.profiles.active=test 

# 表示使用生产环境的配置
java -jar xxx.jar --spring.profiles.active=prod 

4. Ajouter des informations de profil étendues

Dans les projets complexes, nous devrons peut-être ajouter des informations de configuration étendues supplémentaires. Spring Boot prend en charge le projet pour ajouter des fichiers de configuration étendus. Supposons que nous configurions un fichier de configuration application-ldap qui nécessite une authentification LDAP dans un module fonction ouragan -ldap. yml , nous pouvons modifier l' élément de configuration spring.profiles.active dans le fichier application.yml ou application.properties comme suit:

 spring:
     profiles:
        active: dev,ldap

3. Emballage de configuration multi-environnement via Mavan

1. Ajouter une configuration multi-environnement dans le fichier pom.xml

<!-- Application Environment Setting -->
<profiles>
     <profile>
         <id>dev</id>
         <activation>
             <!-- Default Active Without Assign Parameter -->
             <activeByDefault>true</activeByDefault>
         </activation>
         <properties>
             <profileActive>dev</profileActive>
         </properties>
     </profile>
     <profile>
         <id>test</id>
         <properties>
             <profileActive>test</profileActive>
         </properties>
     </profile>
     <profile>
         <id>prod</id>
         <properties>
             <profileActive>prod</profileActive>
         </properties>
     </profile>
</profiles>

Remarque: Dans le fichier de configuration, ajoutez la configuration des trois environnements de développement, de test et de production, qui doivent prêter attention à l'élément de configuration personnalisé profileActive. Cet élément de configuration indique le nom du fichier de configuration d'application. Cet élément de configuration sera appliqué dans application.yml ou application.properties .

2. Modifiez les éléments de configuration applcation.yml ou application.properties

Modifiez les éléments de configuration applcation.yml ou application.properties pour remplacer les éléments de configuration spring.profies.active comme suit:

spring:
    profiles:
       active: @profileActive@，ldap

Remarque: @ profileActive @ est un élément de configuration personnalisé configuré dans le fichier pom.xml à l'étape précédente. Ce paramètre peut être nommé et configuré selon les habitudes du développeur.

Utilisez la commande maven pour créer un package d'application de l'environnement correspondant

#生产环境
mvn clean package -Pprod -U  
# 或者
mvn clean package -DprofileActive=prod -U
#########################################
#测试环境
mvn clean package -Ptest -U  
# 或者
mvn clean package -DprofileActive=test -U
#########################################
#开发环境
mvn clean package -Pdev -U  
# 或者
mvn clean package -DprofileActive=dev -U

Auteur: garyond
lien: https: //www.jianshu.com/p/07bd7720b0c4
Source: Jane livres
sont la propriété de l'auteur. Pour la reproduction commerciale, veuillez contacter l'auteur pour autorisation, et pour la reproduction non commerciale, veuillez indiquer la source.