Vårprofiler

1. Oversikt

I denne opplæringen vil vi fokusere på å introdusere profiler om våren.

Profiler er et sentralt trekk ved rammeverket - slik at vi kan kartlegge bønnene våre til forskjellige profiler - for eksempel, dev, test, og prod.

Deretter kan vi aktivere forskjellige profiler i forskjellige miljøer for å starte bare bønner vi trenger.

2. Bruk @Profil på en bønne

La oss begynne enkelt og se på hvordan vi kan få en bønne til å høre til en bestemt profil. Vi bruker @Profil kommentar - vi kartlegger bønnen til den aktuelle profilen; merknaden tar ganske enkelt navnene på en (eller flere) profiler.

Tenk på et grunnleggende scenario: Vi har en bønne som bare skal være aktiv under utvikling, men ikke distribuert i produksjon.

Vi kommenterer bønnen med en dev profil, og den vil bare være tilstede i containeren under utvikling. I produksjon, den dev vil ganske enkelt ikke være aktiv:

@Component @Profile ("dev") offentlig klasse DevDatasourceConfig

Som en rask sidenote kan profilnavn også være foran en NOT-operator, f.eks. ! dev, for å ekskludere dem fra en profil.

I eksemplet er komponenten bare aktivert hvis dev profilen er ikke aktiv:

@Component @Profile ("! Dev") offentlig klasse DevDatasourceConfig

3. Deklarer profiler i XML

Profiler kan også konfigureres i XML. De tag har en profiler attributt, som tar kommadelte verdier for de aktuelle profilene:

4. Angi profiler

Neste trinn er å aktivere og sette profilene slik at de respektive bønnene blir registrert i beholderen.

Dette kan gjøres på en rekke måter, som vi vil utforske i de følgende avsnittene.

4.1. Programmatisk via WebApplicationInitializer Grensesnitt

I webapplikasjoner, WebApplicationInitializer kan brukes til å konfigurere ServletContext programmatisk.

Det er også et veldig praktisk sted å sette våre aktive profiler programmatisk:

@Configuration public class MyWebApplicationInitializer implementerer WebApplicationInitializer {@Override public void onStartup (ServletContext servletContext) kaster ServletException {servletContext.setInitParameter ("spring.profiles.active", "dev"); }}

4.2. Programmatisk via Konfigurerbart miljø

Vi kan også sette profiler direkte på miljøet:

@Autowired private ConfigurableEnvironment env; ... env.setActiveProfiles ("someProfile");

4.3. Kontekstparameter i web.xml

På samme måte kan vi definere de aktive profilene i web.xml filen til webapplikasjonen ved hjelp av en kontekstparameter:

 contextConfigLocation /WEB-INF/app-config.xml spring.profiles.active dev 

4.4. JVM-systemparameter

Profilnavnene kan også sendes inn via en JVM-systemparameter. Disse profilene aktiveres under oppstart av applikasjonen:

-Dspring.profiles.active = dev

4.5. Miljøvariabel

I et Unix-miljø, profiler kan også aktiveres via miljøvariabelen:

eksporter spring_profiles_active = dev

4.6. Maven-profil

Fjærprofiler kan også aktiveres via Maven-profiler, av spesifisere våren.profiler.aktiv konfigurasjonsegenskap.

I hver Maven-profil kan vi sette en våren.profiler.aktiv eiendom:

  dev true dev prod 

Verdien vil bli brukt til å erstatte @ [e-postbeskyttet] plassholder i application.properties:

[e-postbeskyttet] @

Nå må vi aktivere ressursfiltrering pom.xml:

   src / main / resources true ... 

og legg til a -P parameter for å bytte hvilken Maven-profil som skal brukes:

mvn ren pakke -Pprod

Denne kommandoen vil pakke applikasjonen for prod profil. Det gjelder også våren.profiler.aktiv verdi prod for dette programmet når det kjører.

4.7. @ActiveProfile i tester

Tester gjør det veldig enkelt å spesifisere hvilke profiler som er aktive ved hjelp av @ActiveProfile kommentar for å aktivere spesifikke profiler:

@ActiveProfiles ("dev")

Så langt har vi sett på flere måter å aktivere profiler på. La oss nå se hvilken som har prioritet fremfor den andre, og hva som skjer hvis vi bruker mer enn en, fra høyeste til laveste prioritet:

  1. Kontekstparameter i web.xml
  2. WebApplicationInitializer
  3. JVM-systemparameter
  4. Miljøvariabel
  5. Maven profil

5. Standardprofilen

Enhver bønne som ikke spesifiserer en profil, tilhører misligholde profil.

Spring gir også en måte å angi standardprofilen når ingen andre profiler er aktive - ved å bruke spring.profiles.default eiendom.

6. Få aktive profiler

Vårens aktive profiler driver oppførselen til @Profil kommentar for aktivering / deaktivering av bønner. Vi kan imidlertid også ønske å få tilgang til listen over aktive profiler programmatisk.

Vi har to måter å gjøre det på, ved hjelp av Miljø eller vår.aktiv.profil.

6.1. Ved hjelp av Miljø

Vi har tilgang til de aktive profilene fra Miljø gjenstand ved å injisere den:

offentlig klasse ProfileManager {@Autowired private Environment environment; offentlig ugyldig getActiveProfiles () {for (String profileName: environment.getActiveProfiles ()) {System.out.println ("Aktuell aktiv profil -" + profileName); }}}

6.2. Ved hjelp av vår.aktiv.profil

Alternativt kunne vi få tilgang til profilene ved å injisere eiendommen våren.profiler.aktiv:

@Value ("$ {spring.profiles.active}") privat streng activeProfile;

Her, vår activeProfile variabel vil inneholde navnet på profilen som er aktiv for øyeblikket, og hvis det er flere, inneholder den navnene deres atskilt med komma.

Men vi burde vurdere hva som ville skje hvis det ikke er noen aktiv profil i det hele tatt. Med koden vår ovenfor, vil fraværet av en aktiv profil forhindre at applikasjonskonteksten blir opprettet. Dette vil resultere i en IllegalArgumentException på grunn av den manglende plassholderen for å injisere i variabelen.

For å unngå dette kan vi definere en standardverdi:

@Value ("$ {spring.profiles.active:}") privat streng activeProfile;

Nå, hvis ingen profiler er aktive, vår activeProfile vil bare inneholde en tom streng.

Og hvis vi ønsker å få tilgang til listen over dem akkurat som i forrige eksempel, kan vi gjøre det ved å dele activeProfile variabel:

offentlig klasse ProfileManager {@Value ("$ {spring.profiles.active:}") private String activeProfiles; public String getActiveProfiles () {for (String profileName: activeProfiles.split (",")) {System.out.println ("Aktuell profil -" + profilnavn); }}}

7. Eksempel: Separate datakildekonfigurasjoner ved hjelp av profiler

Nå som det grunnleggende er ute av veien, la oss se på et reelt eksempel.

Tenk på et scenario der Vi må opprettholde datakildekonfigurasjonen for både utviklings- og produksjonsmiljøer.

La oss lage et felles grensesnitt DatasourceConfig som må implementeres av begge datakildeimplementeringene:

offentlig grensesnitt DatasourceConfig {oppsett av offentlig tomrom (); }

Følgende er konfigurasjonen for utviklingsmiljøet:

@Component @Profile ("dev") offentlig klasse DevDatasourceConfig implementerer DatasourceConfig {@Override public void setup () {System.out.println ("Sette opp datakilde for DEV-miljø."); }}

Og konfigurasjon for produksjonsmiljøet:

@Component @Profile ("produksjon") offentlig klasse ProductionDatasourceConfig implementerer DatasourceConfig {@Override public void setup () {System.out.println ("Sette opp datakilde for PRODUCTION-miljø."); }}

La oss nå lage en test og injisere DatasourceConfig-grensesnittet; avhengig av den aktive profilen, vil Spring injisere DevDatasourceConfig eller ProductionDatasourceConfig bønne:

offentlig klasse SpringProfilesWithMavenPropertiesIntegrationTest {@Autowired DatasourceConfig datasourceConfig; public void setupDatasource () {datasourceConfig.setup (); }}

Når dev profilen er aktiv, våren injiserer DevDatasourceConfig objekt, og når du ringer da oppsett () metode, er følgende utdata:

Sette opp datakilde for DEV-miljø.

8. Profiler i vårstøvel

Spring Boot støtter all profilkonfigurasjonen som er skissert så langt, med noen ekstra funksjoner.

Initialiseringsparameteren våren.profiler.aktiv, introdusert i avsnitt 4, kan også settes opp som en egenskap i Spring Boot for å definere aktive profiler. Dette er en standardegenskap som Spring Boot henter automatisk:

spring.profiles.active = dev

For å sette profiler programmatisk, kan vi også bruke SpringApplication klasse:

SpringApplication.setAdditionalProfiles ("dev");

For å sette profiler ved hjelp av Maven i Spring Boot, kan vi spesifisere profilnavn under spring-boot-maven-plugin i pom.xml:

  org.springframework.boot spring-boot-maven-plugin dev ... 

og utfør det Spring Boot-spesifikke Maven-målet:

mvn spring-boot: run

Men den viktigste profilerelaterte funksjonen som Spring Boot bringer er profilspesifikke egenskapsfiler. Disse må navngis i formatet applikasjon- {profil} .egenskaper.

Spring Boot vil automatisk laste inn egenskapene i en application.properties fil for alle profiler, og de som er profilspesifikke .eiendommer filer bare for den angitte profilen.

For eksempel kan vi konfigurere forskjellige datakilder for dev og produksjon profiler ved å bruke to filer som heter application-ev.properties og applikasjonsproduksjon.egenskaper:

I applikasjonsproduksjon.egenskaper fil, kan vi sette opp en MySql datakilde:

spring.datasource.driver-class-name = com.mysql.cj.jdbc.Driver spring.datasource.url = jdbc: mysql: // localhost: 3306 / db spring.datasource.username = root spring.datasource.password = root

Da kan vi konfigurere de samme egenskapene for dev profil i application-ev.properties fil, for å bruke et minne H2 database:

spring.datasource.driver-class-name = org.h2.Driver spring.datasource.url = jdbc: h2: mem: db; DB_CLOSE_DELAY = -1 spring.datasource.username = sa spring.datasource.password = sa

På denne måten kan vi enkelt tilby forskjellige konfigurasjoner for forskjellige miljøer.

9. Konklusjon

I denne artikkelen diskuterte vi hvordan definere en profil på en bønne og hvordan da aktivere de rette profilene i søknaden vår.

Til slutt validerte vi vår forståelse av profiler med et enkelt, men virkelig eksempel.

Implementeringen av denne veiledningen finner du i GitHub-prosjektet.