Forårsprofiler

1. Oversigt

I denne vejledning fokuserer vi på at introducere profiler om foråret.

Profiler er et kerneelement i rammen - giver os mulighed for at kortlægge vores bønner til forskellige profiler - for eksempel, dev, prøveog prod.

Vi kan derefter aktivere forskellige profiler i forskellige miljøer for kun at starte de bønner, vi har brug for.

2. Brug @Profil på en bønne

Lad os starte simpelt og se på, hvordan vi kan få en bønne til at høre til en bestemt profil. Vi bruger @Profil kommentar - vi kortlægger bønnen til den pågældende profil; annotationen tager simpelthen navnene på en (eller flere) profiler.

Overvej et grundlæggende scenarie: Vi har en bønne, der kun skal være aktiv under udvikling, men ikke implementeres i produktionen.

Vi kommenterer bønnen med en dev profil, og den vil kun være til stede i containeren under udvikling. I produktionen er den dev vil simpelthen ikke være aktiv:

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

Som en hurtig sidenote kan profilnavne også have forud for en NOT-operator, f.eks. ! dev, for at udelukke dem fra en profil.

I eksemplet aktiveres komponenten kun, hvis dev profilen er ikke aktiv:

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

3. Erklær profiler i XML

Profiler kan også konfigureres i XML. Det tag har en profiler attribut, som tager kommaseparerede værdier for de relevante profiler:

4. Indstil profiler

Det næste trin er at aktivere og indstille profilerne, så de respektive bønner registreres i beholderen.

Dette kan gøres på en række måder, som vi vil undersøge i de følgende afsnit.

4.1. Programmatisk via WebApplicationInitializer Interface

I webapplikationer, WebApplicationInitializer kan bruges til at konfigurere ServletContext programmatisk.

Det er også et meget praktisk sted at indstille vores 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å indstille profiler direkte på miljøet:

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

4.3. Kontekstparameter i web.xml

På samme måde kan vi definere de aktive profiler i web.xml fil til webapplikationen ved hjælp af en kontekstparameter:

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

4.4. JVM-systemparameter

Profilnavne kan også overføres via en JVM-systemparameter. Disse profiler aktiveres under opstart af applikationen:

-Dspring.profiles.active = dev

4.5. Miljøvariabel

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

eksport spring_profiles_active = dev

4.6. Maven-profil

Fjederprofiler kan også aktiveres via Maven-profiler af med angivelse af spring.profiles.active konfigurationsegenskab.

I hver Maven-profil kan vi indstille en spring.profiles.active ejendom:

  dev true dev prod 

Dens værdi vil blive brugt til at erstatte @ [e-mail-beskyttet] pladsholder i application.properties:

[e-mail-beskyttet] @

Nu skal vi aktivere ressourcefiltrering pom.xml:

   src / main / resources true ... 

og tilføj en -P parameter for at skifte hvilken Maven-profil der skal anvendes:

mvn ren pakke -Pprod

Denne kommando pakker applikationen til prod profil. Det gælder også spring.profiles.active værdi prod til denne applikation, når den kører.

4.7. @ActiveProfile i test

Test gør det meget nemt at specificere, hvilke profiler der er aktive ved hjælp af @ActiveProfile kommentar for at aktivere bestemte profiler:

@ActiveProfiles ("dev")

Indtil videre har vi set på flere måder at aktivere profiler på. Lad os nu se, hvilken der har prioritet frem for den anden, og hvad der sker, hvis vi bruger mere end en, fra højeste til laveste prioritet:

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

5. Standardprofilen

Enhver bønne, der ikke angiver en profil, hører til Standard profil.

Spring giver også en måde at indstille standardprofilen på, når ingen anden profil er aktiv - ved hjælp af spring.profiles.default ejendom.

6. Få aktive profiler

Forårs aktive profiler styrer adfærden hos @Profil kommentar til aktivering / deaktivering af bønner. Vi kan dog også ønske at få adgang til listen over aktive profiler programmatisk.

Vi har to måder at gøre det på, ved brug af Miljø eller spring.active.profile.

6.1. Ved brug af Miljø

Vi kan få adgang til de aktive profiler fra Miljø genstand ved at injicere det:

offentlig klasse ProfileManager {@Autowired privat miljø miljø; offentlig ugyldighed getActiveProfiles () {for (String profileName: environment.getActiveProfiles ()) {System.out.println ("Aktuelt aktiv profil -" + profilnavn); }}}

6.2. Ved brug af spring.active.profile

Alternativt kunne vi få adgang til profilerne ved at injicere ejendommen spring.profiles.active:

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

Her, vores aktivProfil variabel indeholder navnet på den profil, der aktuelt er aktiv, og hvis der er flere, indeholder den deres navne adskilt med et komma.

Det skal vi dog overvej hvad der ville ske, hvis der overhovedet ikke er nogen aktiv profil. Med vores kode ovenfor ville fraværet af en aktiv profil forhindre, at applikationskonteksten oprettes. Dette ville resultere i en IllegalArgumentException på grund af den manglende pladsholder til injektion i variablen.

For at undgå dette kan vi definer en standardværdi:

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

Nu, hvis ingen profiler er aktive, vores aktivProfil vil bare indeholde en tom streng.

Og hvis vi ønsker at få adgang til listen over dem ligesom i det foregående eksempel, kan vi gøre det ved at opdele aktivProfil variabel:

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

7. Eksempel: Separate datakildekonfigurationer ved hjælp af profiler

Nu hvor det grundlæggende er ude af vejen, lad os se på et rigtigt eksempel.

Overvej et scenario hvor Vi er nødt til at opretholde datakildekonfigurationen til både udviklings- og produktionsmiljøer.

Lad os oprette en fælles grænseflade DatasourceConfig der skal implementeres af begge datakildeimplementeringer:

offentlig grænseflade DatasourceConfig {offentlig tomrumsopsætning (); }

Følgende er konfigurationen til udviklingsmiljøet:

@Component @Profile ("dev") public class DevDatasourceConfig implementerer DatasourceConfig {@Override public void setup () {System.out.println ("Opsætning af datakilde til DEV-miljø."); }}

Og konfiguration til produktionsmiljøet:

@Component @Profile ("produktion") offentlig klasse ProductionDatasourceConfig implementerer DatasourceConfig {@Override public void setup () {System.out.println ("Opsætning af datakilde til PRODUCTION-miljø."); }}

Lad os nu oprette en test og indsprøjte vores DatasourceConfig interface; afhængigt af den aktive profil, vil Spring injicere DevDatasourceConfig eller ProductionDatasourceConfig bønne:

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

Når dev profilen er aktiv, foråret injiceres DevDatasourceConfig objekt, og når du ringer derefter Opsætning() metode er følgende output:

Opsætning af datakilde til DEV-miljø.

8. Profiler i Spring Boot

Spring Boot understøtter alle de hidtil skitserede profilkonfigurationer med et par ekstra funktioner.

Initialiseringsparameteren spring.profiles.active, introduceret i afsnit 4, kan også oprettes som en egenskab i Spring Boot til at definere aktuelt aktive profiler. Dette er en standardegenskab, som Spring Boot afhenter automatisk:

spring.profiles.active = dev

For at indstille profiler programmatisk kan vi også bruge SpringApplication klasse:

SpringApplication.setAdditionalProfiles ("dev");

For at indstille profiler ved hjælp af Maven i Spring Boot kan vi specificere profilnavne under spring-boot-maven-plugin i pom.xml:

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

og udfør det Spring Boot-specifikke Maven-mål:

mvn spring-boot: løb

Men den vigtigste profilerelaterede funktion, som Spring Boot bringer, er profilspecifikke egenskabsfiler. Disse skal navngives i formatet applikations- {profil} .ejendomme.

Spring Boot indlæser automatisk egenskaberne i en application.properties fil til alle profiler, og dem i profilspecifikke .ejendomme filer kun til den angivne profil.

For eksempel kan vi konfigurere forskellige datakilder til dev og produktion profiler ved hjælp af to navngivne filer application-ev.properties og applikations- produktion.egenskaber:

I applikations- produktion.egenskaber fil, kan vi oprette 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

Derefter kan vi konfigurere de samme egenskaber til dev profil i application-ev.properties fil, for at bruge en hukommelse 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åde kan vi nemt levere forskellige konfigurationer til forskellige miljøer.

9. Konklusion

I denne artikel diskuterede vi, hvordan man gør det definere en profil på en bønne og hvordan man derefter aktiver de rigtige profiler i vores ansøgning.

Endelig validerede vi vores forståelse af profiler med et simpelt, men virkeligt eksempel.

Implementeringen af ​​denne vejledning kan findes i GitHub-projektet.