Java >> Java tutorial >  >> Tag >> Spring

Eksempel på fjederstøvleprofiler

Denne side vil gennemgå et eksempel på fjederstøvleprofiler. Spring giver @Profile annotation, hvormed vi opretter profiler. @Profile bruges med @Configuration og forårsstereotyper såsom @Component , @Service osv. Forskellige profiler er skabt til forskellige miljøer. For eksempel kan vi have miljø som produktion, udvikling og test. I udviklingsmiljø kan vi aktivere udviklingsprofil og i produktionsmiljø kan vi aktivere produktionsprofil og så videre. En profil kan aktiveres ved hjælp af egenskabsfilen .properties/.yml , kommandolinje og programmatisk. Vi kan også oprette en standardprofil, der fungerer, når der ikke er nogen aktiv profil. For at tilføje aktiv profil i ejendomsfilen skal vi konfigurere spring.profiles.active ejendom. Vi kan også konfigurere profil ved hjælp af spring.profiles.include som vil blive inkluderet for hver aktive profil. Når vi tilføjer aktiv profil ved hjælp af kommandolinjen, erstattes den aktive profil, der er tilføjet i ejendomsfilen. Vi kan tilføje aktiv profil og standardprofil programmatisk ved at bruge ConfigurableEnvironment . I forårets boottest kan vi tilføje aktiv profil ved at bruge @ActiveProfiles anmærkning. Vi kan oprette ejendomsfil ved hjælp af profilnavn ved hjælp af konventionen application-{profile}.properties . Fordelen ved denne tilgang er, at vi kan konfigurere egenskabsprofilspecifikke. Find nu det komplette eksempel på fjederstøvleprofiler trin for trin.



Opret forårsprofiler

I vores eksempel vil vi skabe profiler for to miljøer, nemlig udvikling og produktion. Profil er erklæret som @Profile("profile-name") kommenteret på klasseniveau. Vi opretter fire profiler, der er dev , prod , animal_dev og animal_prod . I vores eksempel opretter vi to komponenter, der konfigurerer serverport og kontekststi, og vi vil have to serviceklasser.
Find den komponent, der konfigurerer serverport og kontekststi til produktionsmiljøet.
ProdCustomizer.java
package com.concretepage.config;
import org.springframework.boot.context.embedded.ConfigurableEmbeddedServletContainer;
import org.springframework.boot.context.embedded.EmbeddedServletContainerCustomizer;
import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Component;
@Component
@Profile("prod")
public class ProdCustomizer implements EmbeddedServletContainerCustomizer {
	@Override
	public void customize(ConfigurableEmbeddedServletContainer container) {
		container.setContextPath("/spring-boot-prod");
		container.setPort(8585);
	}
}  
Find den komponent, der konfigurerer serverport og kontekststi til udviklingsmiljøet.
DevCustomizer.java
package com.concretepage.config;
import org.springframework.boot.context.embedded.ConfigurableEmbeddedServletContainer;
import org.springframework.boot.context.embedded.EmbeddedServletContainerCustomizer;
import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Component;
@Component
@Profile("dev")
public class DevCustomizer implements EmbeddedServletContainerCustomizer {
	@Override
	public void customize(ConfigurableEmbeddedServletContainer container) {
		container.setContextPath("/spring-boot-dev");
		container.setPort(8484);
	}
}  
Vi skaber også tjenester til prod- og dev-miljøer.
Animal.java
package com.concretepage.service;
public interface Animal {
	String getMessage();
} 
Elephant.java
package com.concretepage.service;
import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Service;
@Service
@Profile("animal_dev")
public class Elephant implements Animal {
	@Override
	public String getMessage() {
		return "Hello Elephant!";
	}

} 
Lion.java
package com.concretepage.service;
import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Service;
@Service
@Profile("animal_prod")
public class Lion implements Animal {
	@Override
	public String getMessage() {
		return "Hello Lion!";
	}
} 



Tilføj aktiv profil ved hjælp af egenskabsfil (.properties/.yml)

For at tilføje en aktiv profil giver fjederstøvlen spring.profiles.active ejendom. Antag, at vi vil aktivere dev og animal_dev profil, kan vi gøre som følger.
Ved at bruge application.properties
spring.profiles.active=dev, animal_dev 
Bruger application.yml
spring:
  profiles:
    active:
     - dev
     - animal_dev 

Opret controller og hovedklasse

Vores eksempel er et webprojekt, hvor vi har en controller. Inden for controlleren vil vores serviceklasse blive automatisk koblet på køretid på basis af den aktive profil.
HelloController.java
package com.concretepage.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import com.concretepage.service.Animal;
@RestController
public class HelloController {
   @Autowired
   private Animal animal;	
   @GetMapping("/")	
   public String getMessage() {
	   return animal.getMessage();
   }
} 
Kør demoen ved at bruge følgende klasse.
MyApplication.java
package com.concretepage;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
	SpringApplication.run(MyApplication.class, args);
    }       
} 
Få adgang til URL'en
http://localhost:8484/spring-boot-dev/ 
Find outputtet.
Hello Elephant! 

Tilføj aktive profiler ved hjælp af kommandolinjen

Vi kan tilføje aktive profiler ved hjælp af kommandolinjen med java kommando. I dette tilfælde vil den aktive profil, der er konfigureret i egenskabsfilen, blive erstattet af den aktive profil, der sendes på kommandolinjen. I vores ejendomsfil har vi tilføjet aktiv profil for dev miljø. Så som standard starter applikationen med dev miljø. Nu vil vi tilføje prod aktiv profil ved hjælp af kommandolinjen. Antag, at vi har eksekverbar JAR navngivet som spring-boot-demo-0.0.1-SNAPSHOT.jar . Vi sender argumentet som -Dspring.profiles.active=animal_prod .
java -jar -Dspring.profiles.active="prod, animal_prod" spring-boot-demo-0.0.1-SNAPSHOT.jar 
For enkelt profil kan vi bruge kommandoen som følger.
java -jar -Dspring.profiles.active=animal_prod spring-boot-demo-0.0.1-SNAPSHOT.jar 

Inkluder aktive profiler

Fjederstøvler kan inkludere et fælles sæt profiler for alle aktive profiler. Vi kan konfigurere spring.profiles.include ejendom i vores ejendomsmappe. Nu når vi tilføjer en aktiv profil ved hjælp af spring.profiles.active derefter som standard profiler konfigureret af spring.profiles.include vil også blive tilføjet. Hvis vi erstatter aktiv profil med kommandolinje, vil profilerne stadig være konfigureret af spring.profiles.include vil blive tilføjet som aktiv profil. Vi bruger det som følger.
Ved brug af application.properties
spring.profiles.active=dev
spring.profiles.include: animal_dev 
Dette vil tilføje to aktive profiler dev og animal_dev .
Bruger nu application.yml
spring:
  profiles:
    active: dev
    include: animal_dev 
Brug af kommandolinje
java -jar -Dspring.profiles.active=prod spring-boot-demo-0.0.1-SNAPSHOT.jar 
Ovenstående kommandolinje tilføjer to aktive profiler prod og animal_dev . animal_dev vil blive taget fra ejendomsfilen.


Aktiv profilenhedstest ved hjælp af @ActiveProfiles

Nu vil vi teste vores profil ved hjælp af unit test cases. Vi har oprettet to testmetoder, en til serviceklasser og en anden til tilpassede klasser for indlejret serverkonfiguration. For at tilføje en aktiv profil giver fjedertestrammerne @ActiveProfiles anmærkning. Find testklassen.
ActiveProfileTest.java
package com.concretepage;
import static org.assertj.core.api.Assertions.assertThat;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.junit4.SpringRunner;
import com.concretepage.service.Animal;
@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment=WebEnvironment.RANDOM_PORT)
@ActiveProfiles({"prod","animal_prod"})
public class ActiveProfileTest {
        @Autowired
        private Animal animal;	
	@Autowired
	private TestRestTemplate restTemplate;
	@Test
	public void serviceTest() {
		String message = animal.getMessage();
		assertThat(message).isEqualTo("Hello Lion!");
	}
	@Test
	public void webAppTest() {
		String url = "http://localhost:8585/spring-boot-prod/";
		String body = this.restTemplate.getForObject(url, String.class);
		assertThat(body).isEqualTo("Hello Lion!");
	}
} 
@SpringBootTest :Det bruges til at køre testcases til fjederstøvlebaseret applikation. Testklassen vil blive kommenteret med @SpringBootTest annotation.
@ActiveProfiles :Spring-testramme giver denne annotation for at bruge aktiv profil i vores testcases.
TestRestTemplate :Forårstestramme giver TestRestTemplate for at teste fjederstøvlebaseret REST webserviceapplikation. Vi kan direkte autowire denne klasse i vores testklasse. Men det fungerer kun, når vores testklasse er blevet kommenteret med @SpringBootTest ved hjælp af metadata webEnvironment=WebEnvironment.RANDOM_PORT .

Indstil aktive profiler programmatisk ved hjælp af SpringApplication.setAdditionalProfiles(...)

Vi kan indstille aktive profiler programmatisk ved hjælp af SpringApplication.setAdditionalProfiles(...) som følger.
MyApplication.java
package com.concretepage;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
	SpringApplication application = new SpringApplication(MyApplication.class);
	application.setAdditionalProfiles("dev","animal_dev");
	application.run(args);
    }       
} 
Vi skal ringe til setAdditionalProfiles() metode før run() metode. Her har vi tilføjet aktive profiler dev og animal_dev .

Indstil aktive profiler programmatisk ved hjælp af ConfigurableEnvironment.setActiveProfiles(...)

Vi kan indstille aktive profiler programmatisk ved hjælp af ConfigurableEnvironment.setActiveProfiles(...) .
MyApplication.java
package com.concretepage;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.core.env.StandardEnvironment;
@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
	SpringApplication application = new SpringApplication(MyApplication.class);
	ConfigurableEnvironment environment = new StandardEnvironment();
	environment.setActiveProfiles("dev","animal_dev");
	application.setEnvironment(environment);
	application.run(args);
    }       
} 
ConfigurableEnvironment giver mulighed for at indstille aktive profiler og standardprofiler. For at indstille aktiv profil, setActiveProfiles(...) metode anvendes. ConfigurableEnvironment er en grænseflade, og der er mange implementeringer af den. Vi bruger her StandardEnvironment det er implementeringsklassen ConfigurableEnvironment .

Indstil standardprofiler

Der bør være en standardprofil, der skal indlæses, hvis ingen profil er aktiveret. Vi kan indstille standardprofiler, der vil blive brugt af spring boot-applikationen, når vi ikke har konfigureret nogen aktiv profil.
Vi kan indstille standardprofiler ved hjælp af setDefaultProfiles(...) metode til ConfigurableEnvironment som følger.
MyApplication.java
package com.concretepage;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.core.env.StandardEnvironment;
@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
	SpringApplication application = new SpringApplication(MyApplication.class);
	ConfigurableEnvironment environment = new StandardEnvironment();
	environment.setDefaultProfiles("dev","animal_dev");
	application.setEnvironment(environment);
	application.run(args);
    }       
} 

Profilspecifik egenskabsfil

Vi kan have egenskabsfil specifik for en profil med konventionen application-{profile}.properties . På denne måde kan vi have separat ejendomsfil for forskellige miljøer. Hvis vi har tilføjet en aktiv profil, vil kun den tilsvarende egenskabsfil blive brugt af vores spring boot-applikation. Vi kan også have en egenskabsfil til standardprofil.
Antag, at vi har profiler som dev til udviklingsmiljø og prod til produktionsmiljø. Så kan vi have profilspecifikke egenskaber som følger.
application-dev.properties
logging.level.org.springframework.web= DEBUG
logging.level.com.concretepage= DEBUG 
application-prod.properties
logging.level.org.springframework.web= ERROR
logging.level.com.concretepage= INFO

logging.path = concretepage/logs 
application-default.properties
logging.level.org.springframework.web= INFO
logging.level.com.concretepage= INFO 
Hvis vi nu tilføjer aktiv profil dev som følger
application.properties
spring.profiles.active=dev, animal_dev 
Derefter application-dev.properties samt application.properties vil blive brugt af vores spring boot-applikation.
Hvis vi tilføjer aktiv profil prod som følger
application.properties
spring.profiles.active=prod, animal_prod 
Derefter application-prod.properties samt application.properties vil blive brugt af vores spring boot-applikation.

Hvis standardprofilen er aktiv, så application-default.properties samt application.properties vil blive brugt af vores spring boot-applikation.
Find printskærmen.
På samme måde kan vi bruge .yml med konventionen application-{profile}.yml . For profilerne dev og prod vi kan have .yml filer som følger.
application-dev.yml
application-prod.yml
application-default.yml
application.yml

Jeg er færdig nu . God forårsstøvlelæring!

Reference

Fjederstøvlefunktioner:Profiler

Download kildekode

spring-boot-profiles-example.zip
Java tag