[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. スクリーンショット 2019-10-07 22.02.48.png

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.

Recommended Posts

Créez des projets Spring Boot par environnement avec Gradle
Comment démarrer par environnement avec Spring Boot de Maven
Construire un projet Java avec Gradle
◆ Spring Boot + note de construction de l'environnement gradle
Changer d'environnement avec l'argument de démarrage dans SpringBoot
Créer une image Spring Boot + Docker avec Gradle
(IntelliJ + gradle) Hello World avec Spring Boot
Créez un site Web avec Spring Boot + Gradle (jdk1.8.x)
Exécutez l'application Scala avec Spring Boot via Gradle
Mémo personnel Run Spring Boot + Projet Web Gradle avec Codenvy (Eclipse Che)
Environnement de développement-développement Spring Boot-
Conseils Java - Créez un projet Spring Boot avec Gradle
Je voulais classer la botte à ressort dans un multi-projet
Créer un environnement Spring Boot avec Windows + VS Code
Afficher la tâche Gradle dans le projet Spring Boot
Télécharger avec Spring Boot
Créer un environnement de développement Spring Boot avec docker
Changer d'environnement avec Spring Boot application.properties et l'annotation @Profile
Comment créer un environnement Docker avec Gradle pour IntelliJ
SSO avec GitHub OAuth dans l'environnement Spring Boot 1.5.x
Création d'un environnement de base de données avec Docker dans Spring Boot (IntellJ)
Hello World avec Spring Boot
Implémenter GraphQL avec Spring Boot
Démarrez avec Spring Boot
Bonjour tout le monde avec Spring Boot!
Multi-projets Spring Boot 2 avec Gradle
Exécutez LIFF avec Spring Boot
Connexion SNS avec Spring Boot
Téléchargement de fichiers avec Spring Boot
Spring Boot commençant par copie
Spring Boot à partir de Docker
Créer un environnement Docker avec WSL
Hello World avec Spring Boot
Définir des cookies avec Spring Boot
Utiliser Spring JDBC avec Spring Boot
Construction de l'environnement Docker × Spring Boot
Ajouter un module avec Spring Boot
Premiers pas avec Spring Boot
Créer un environnement Spring pour Android 2.0.0
Créer un micro service avec Spring Boot
Envoyer du courrier avec Spring Boot
Changez la cible d'injection pour chaque environnement avec Spring Boot 2
Créez un environnement de développement «Spring Thorough Introduction» avec IntelliJ IDEA
Créer un environnement de développement Web APP avec Java + Spring avec Visual Studio Code
[Java] Exemple de projet de développement d'applications Web avec Spring Boot
Utiliser l'authentification de base avec Spring Boot
Créer un environnement Node.js avec Docker
gRPC sur Spring Boot avec grpc-spring-boot-starter
Créer un environnement Tomcat 8.5 avec Pleiades 4.8
Créez une application avec Spring Boot 2
Déploiement à chaud avec le développement Spring Boot
Liaison de base de données avec doma2 (Spring boot)
Spring Boot: exemple de projet d'API Restful
Jusqu'à "Hello World" avec Spring Boot
Créer une application d'enquête avec Spring Boot