[JAVA] Créez des projets Spring Boot par environnement avec Gradle

Il existe plusieurs façons d'exécuter une compilation sur Gradle par environnement, Cette fois, je vais vous présenter comment sortir le fichier war après avoir réécrit les paramètres de application.properties de Spring Boot.

L'outil de développement utilisé est STS et il est supposé que Gradle Buildship fonctionne.

Finalement, la partie entourée par le cadre rouge a été ajoutée aux tâches Gradle, En l'exécutant, vous pourrez sortir le fichier war pour chaque environnement.

Préparation

Spring Initializr Pour créer un modèle pour le projet. Sélectionnez Gradle Project dans Project, sélectionnez Packaging et appuyez sur le bouton Generate pour télécharger. Cette fois, nous allons le déplacer en supposant que la guerre sera sortie.

Après le téléchargement, décompressez le fichier zip Importez-le dans STS en tant que projet Gradle.

Structure du répertoire

demo
│  build.gradle                     //Ajouter un script de construction ici
│  application_template.properties  //Créer un nouveau
│
├─.gradle
├─.settings
├─bin
├─gradle
└─src
    ├─main
    │  ├─java
    │  │  └─com
    │  │      └─example
    │  │          └─demo
    │  │                DemoApplication.java  //Réparer
    │  │
    │  └─resources
    │          application-dev.properties     //Créer un nouveau
    │          application-product.properties //Créer un nouveau
    │          application.properties         //Réparer
    │
    └─test

fichier de configuration

Dans Spring Boot, préparez un fichier appelé nom d'environnement d'application. Vous pouvez appliquer les paramètres pour chaque environnement en définissant le nom de l'environnement dans application.properties. Alors, veuillez préparer les trois fichiers suivants sous ressources.

application.properties

spring.profiles.active=dev

application-dev.properties

sample_data=Development Environment

application-product.properties

sample_data=Production Environment

Exemple d'application

Cette fois, je vais exécuter une application très simple qui affiche le contenu du fichier de paramètres pour chaque environnement. Réécrivons Application.java comme suit.

DemoApplication.java

package com.example.demo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class DemoApplication {
	
	@Value("${sample_data}")
	private String data;  //Cette valeur est l'exemple du fichier de paramètres_Lire à partir de la valeur des données

	public static void main(String[] args) {
		ConfigurableApplicationContext ctx = SpringApplication.run(DemoApplication.class, args);
		DemoApplication demo = ctx.getBean(DemoApplication.class);
		demo.run();
	}
	
	private void run() {
		System.out.println(data);
	}
}

Lors de son exécution, le fichier défini dans application.properties doit être lu et la valeur correspondant à l'environnement doit être affichée.

Résultat de l'exécution (journal Spring omis)

Development Environment

Ecrire un script de construction

Cette fois, exécutez la tâche pour chaque environnement à partir de la vue Gradle Tasks de STS et sortez la guerre. Tout d'abord, exécutez le processus de remplacement de application.properties par celui pour lequel l'environnement à générer est défini. Créons le fichier de modèle application.properties suivant.

application_template.properties

spring.profiles.active=${buildEnv}

Ensuite, écrivez une tâche pour remplacer application.properties par un fichier qui remplace la partie $ {buildEnv} du fichier modèle. Ajoutons-le à build.gradle. De plus, puisque nous utiliserons la commande war cette fois, n'oubliez pas de décrire les paramètres de la commande war.

build.gradle

plugins {
	// (Omission)
}
//Ajout des paramètres de commande de guerre
war {
	enabled = true
	archiveName 'sample.war'
}

// (Omission)

//Chaque nom de fichier
def templateFile = 'application_template.properties'
def configFile = 'application.properties'
//Nom de l'environnement cible (remplacez une valeur plus tard)
def targetEnv = ''

task replaceConfig {
	description 'Replace application.properties environment.'

	doLast {
		println '　　　　start replacing :' + targetEnv
		//Copier la partie exécution
		copy {
			// from:Spécifiez le répertoire contenant les fichiers à copier
			from '.'
			// include:Cette fois, je spécifie le nom du fichier à copier
			include templateFile
			// into:Copier le répertoire de destination
			into 'src/main/resources'
			// application.Renommer en propriétés
			rename(templateFile, configFile)
			
			// ${buildEnv}Remplacer
			expand([
				buildEnv: targetEnv
			])
			println "　　　　replacing finished"
		}
	}
	//Lorsque la tâche de remplacement est terminée, utilisez la commande war pour afficher war (s'il s'agit d'un fichier jar, faites-en un fichier jar)
	finalizedBy {
		war
	}
}

La tâche de guerre est maintenant exécutée après l'exécution du processus de copie. Cependant, avec cela seul, la valeur de targetEnv est toujours un caractère vide, décrivez donc la partie à définir. J'ajouterai plus.

build.gradle

//(Omis)

def templateFile = 'application_template.properties'
def configFile = 'application.properties'
def targetEnv = ''

task replaceConfig {
	// (Omission)
}

task warProduct {
	//En définissant le groupe, il sera affiché dans la construction de la vue Tâches Gradle
	group = 'build'
	description 'Create war file for product environment.'

	doLast {
		//Définir targetEnv
		targetEnv = 'product'
	}
	//Après avoir défini targetEnv, exécutez la tâche replaceConfig
	finalizedBy {
		replaceConfig
	}
}

//dev est le même que Product
task warDev {
	group = 'build'
	description 'Create war file for dev environment.'
	
	doLast {
		targetEnv = 'dev'
	}
	finalizedBy {
		replaceConfig
	}

}

J'ai écrit pour exécuter la tâche replaceConfig après avoir défini targetEnv dans chaque tâche. Cela devrait fonctionner. Ce qui suit est la version non coupée.

build.gradle

plugins {
	id 'org.springframework.boot' version '2.1.9.RELEASE'
	id 'io.spring.dependency-management' version '1.0.8.RELEASE'
	id 'java'
	id 'war'
}
war {
	enabled = true
	archiveName 'sample.war'
}

group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '1.8'

repositories {
	mavenCentral()
}

dependencies {
	implementation 'org.springframework.boot:spring-boot-starter'
	testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

//Chaque nom de fichier
def templateFile = 'application_template.properties'
def configFile = 'application.properties'
//Nom de l'environnement cible (remplacez une valeur plus tard)
def targetEnv = ''

task replaceConfig {
	description 'Replace application.properties environment.'

	doLast {
		println '　　　　start replacing :' + targetEnv
		//Copier la partie exécution
		copy {
			// from:Spécifiez le répertoire contenant les fichiers à copier
			from '.'
			// include:Cette fois, je spécifie le nom du fichier à copier
			include templateFile
			//Copier le répertoire de destination
			into 'src/main/resources'
			// application.Renommer en propriétés
			rename(templateFile, configFile)
			
			// application_Dans le modèle${buildEnv}Remplacer
			expand([
				buildEnv: targetEnv
			])
			println "　　　　replacing finished"
		}
	}
	//Lorsque la tâche de remplacement est terminée, war est sorti avec la commande war.
	finalizedBy {
		war
	}
}

task warProduct {
	//En définissant le groupe, il sera affiché dans la construction de la vue Tâches Gradle
	group = 'build'
	description 'Create war file for product environment.'

	doLast {
		//Définir targetEnv
		targetEnv = 'product'
	}
	//Après avoir défini targetEnv, exécutez la tâche replaceConfig
	finalizedBy {
		replaceConfig
	}
}

//dev est le même que Product
task warDev {
	group = 'build'
	description 'Create war file for dev environment.'
	
	doLast {
		targetEnv = 'dev'
	}
	finalizedBy {
		replaceConfig
	}
}

C'est tout ce qu'on peut en dire. Si vous exécutez warDev ou warProduct à partir des tâches Gradle, un fichier war sera créé dans build / lib. Si vous décompressez le fichier war et cochez application.properties, il devrait s'agir du paramètre de chaque environnement.