Veerprofielen

1. Overzicht

In deze tutorial zullen we ons concentreren op de introductie van profielen in het voorjaar.

Profielen zijn een kernkenmerk van het raamwerk - waardoor we onze bonen aan verschillende profielen kunnen toewijzen - bijvoorbeeld, dev, test, en prod.

We kunnen dan verschillende profielen in verschillende omgevingen activeren om alleen de bonen op te starten die we nodig hebben.

2. Gebruik @Profiel op een Boon

Laten we eenvoudig beginnen en kijken hoe we een boon tot een bepaald profiel kunnen laten behoren. Wij gebruiken de @Profiel annotatie - we wijzen de boon aan dat specifieke profiel; de annotatie neemt simpelweg de namen van een (of meerdere) profielen aan.

Overweeg een basisscenario: we hebben een boon die alleen actief zou moeten zijn tijdens de ontwikkeling, maar niet tijdens de productie.

We annoteren die boon met een dev profiel, en het zal alleen tijdens de ontwikkeling in de container aanwezig zijn. In productie is de dev zal gewoon niet actief zijn:

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

Als een snelle opmerking: profielnamen kunnen ook worden voorafgegaan door een NOT-operator, bijv. ! dev, om ze uit te sluiten van een profiel.

In het voorbeeld wordt de component alleen geactiveerd als dev profiel is niet actief:

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

3. Declareer profielen in XML

Profielen kunnen ook in XML worden geconfigureerd. De tag heeft een profielen attribuut, dat door komma's gescheiden waarden van de toepasselijke profielen accepteert:

4. Stel profielen in

De volgende stap is het activeren en instellen van de profielen zodat de respectievelijke bonen geregistreerd worden in de container.

Dit kan op verschillende manieren worden gedaan, die we in de volgende secties zullen onderzoeken.

4.1. Programmatisch via WebApplicationInitializer Koppel

In webapplicaties, WebApplicationInitializer kan worden gebruikt om de ServletContext programmatisch.

Het is ook een erg handige locatie om onze actieve profielen programmatisch in te stellen:

@Configuration openbare klasse MyWebApplicationInitializer implementeert WebApplicationInitializer {@Override public void onStartup (ServletContext servletContext) gooit ServletException {servletContext.setInitParameter ("spring.profiles.active", "dev"); }}

4.2. Programmatisch via Configureerbare omgeving

We kunnen ook profielen direct op de omgeving instellen:

@Autowired privé ConfigurableEnvironment env; ... env.setActiveProfiles ("someProfile");

4.3. Contextparameter in web.xml

Evenzo kunnen we de actieve profielen in het web.xml bestand van de webapplicatie, met behulp van een contextparameter:

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

4.4. JVM-systeemparameter

De profielnamen kunnen ook worden doorgegeven via een JVM-systeemparameter. Deze profielen worden geactiveerd tijdens het opstarten van de applicatie:

-Dspring.profiles.active = dev

4.5. Omgevingsvariabele

In een Unix-omgeving, profielen kunnen ook worden geactiveerd via de omgevingsvariabele:

export spring_profiles_active = dev

4.6. Maven Profiel

Veerprofielen kunnen ook worden geactiveerd via Maven-profielen, door specificeren van de spring.profiles.active configuratie-eigenschap.

In elk Maven-profiel kunnen we een spring.profiles.active eigendom:

  dev true dev prod prod 

De waarde ervan wordt gebruikt om de @ [e-mail beveiligd] tijdelijke aanduiding in application.properties:

[e-mail beveiligd] @

Nu moeten we het filteren van bronnen inschakelen pom.xml:

   src / main / resources waar ... 

en voeg een -P parameter om te schakelen welk Maven-profiel zal worden toegepast:

mvn schoon pakket -Pprod

Met deze opdracht wordt de applicatie verpakt voor prod profiel. Het is ook van toepassing op de spring.profiles.active waarde prik voor deze toepassing wanneer deze wordt uitgevoerd.

4.7. @ActiveProfile in tests

Tests maken het heel gemakkelijk om te specificeren welke profielen actief zijn met behulp van de @ActiveProfile annotatie om specifieke profielen in te schakelen:

@ActiveProfiles ("dev")

Tot nu toe hebben we gekeken naar verschillende manieren om profielen te activeren. Laten we nu eens kijken welke prioriteit heeft boven de andere en wat er gebeurt als we er meer dan één gebruiken, van de hoogste naar de laagste prioriteit:

  1. Contextparameter in web.xml
  2. WebApplicationInitializer
  3. JVM-systeemparameter
  4. Omgevingsvariabele
  5. Maven profiel

5. Het standaardprofiel

Elke bean die geen profiel specificeert, behoort tot de standaard profiel.

Spring biedt ook een manier om het standaardprofiel in te stellen wanneer er geen ander profiel actief is - door de spring.profiles.default eigendom.

6. Krijg actieve profielen

De actieve profielen van Spring sturen het gedrag van de @Profiel annotatie voor het in- / uitschakelen van bonen. Mogelijk willen we echter ook programmatisch toegang krijgen tot de lijst met actieve profielen.

We hebben twee manieren om het te doen, gebruik makend van Milieu of spring.active.profile.

6.1. Gebruik makend van Milieu

We hebben toegang tot de actieve profielen vanuit het Milieu object door het te injecteren:

openbare klasse ProfileManager {@Autowired privéomgevingomgeving; openbare ongeldige getActiveProfiles () {voor (String profileName: environment.getActiveProfiles ()) {System.out.println ("Momenteel actief profiel -" + profielnaam); }}}

6.2. Gebruik makend van spring.active.profile

Als alternatief kunnen we toegang krijgen tot de profielen door de eigenschap te injecteren spring.profiles.active:

@Value ("$ {spring.profiles.active}") private String activeProfile;

Hier, onze activeProfile variabele bevat de naam van het profiel dat momenteel actief is, en als er meerdere zijn, worden de namen ervan gescheiden door een komma.

We zouden echter moeten overweeg wat er zou gebeuren als er helemaal geen actief profiel is. Met onze bovenstaande code zou de afwezigheid van een actief profiel voorkomen dat de toepassingscontext wordt gemaakt. Dit zou resulteren in een IllegalArgumentException vanwege de ontbrekende tijdelijke aanduiding voor het injecteren in de variabele.

Om dit te voorkomen, kunnen we definieer een standaardwaarde:

@Value ("$ {spring.profiles.active:}") private String activeProfile;

Als er nu geen profielen actief zijn, is onze activeProfile bevat alleen een lege string.

En als we toegang willen hebben tot de lijst ervan, net als in het vorige voorbeeld, kunnen we dat doen door de activeProfile variabele:

openbare klasse ProfileManager {@Value ("$ {spring.profiles.active:}") privé String activeProfiles; openbare String getActiveProfiles () {voor (String profileName: activeProfiles.split (",")) {System.out.println ("Momenteel actief profiel -" + profileName); }}}

7. Voorbeeld: afzonderlijke gegevensbronconfiguraties met behulp van profielen

Nu de basis uit de weg is, laten we eens kijken naar een echt voorbeeld.

Overweeg een scenario waarin we moeten de gegevensbronconfiguratie onderhouden voor zowel de ontwikkel- als de productieomgevingen.

Laten we een gemeenschappelijke interface maken DatasourceConfig dat moet worden geïmplementeerd door beide gegevensbronimplementaties:

openbare interface DatasourceConfig {openbare leegte setup (); }

Hieronder volgt de configuratie voor de ontwikkelomgeving:

@Component @Profile ("dev") openbare klasse DevDatasourceConfig implementeert DatasourceConfig {@Override public void setup () {System.out.println ("Gegevensbron instellen voor DEV-omgeving."); }}

En configuratie voor de productieomgeving:

@Component @Profile ("productie") public class ProductionDatasourceConfig implementeert DatasourceConfig {@Override public void setup () {System.out.println ("Datasource instellen voor PRODUCTIE-omgeving."); }}

Laten we nu een test maken en onze DatasourceConfig-interface injecteren; afhankelijk van het actieve profiel zal Spring injecteren DevDatasourceConfig of ProductionDatasourceConfig Boon:

openbare klasse SpringProfilesWithMavenPropertiesIntegrationTest {@Autowired DatasourceConfig datasourceConfig; openbare ongeldige setupDatasource () {datasourceConfig.setup (); }}

Wanneer de dev profiel is actief, Spring injecteert DevDatasourceConfig object, en bij het bellen dan opstelling() methode, het volgende is de output:

Gegevensbron instellen voor DEV-omgeving.

8. Profielen in Spring Boot

Spring Boot ondersteunt alle tot nu toe geschetste profielconfiguraties, met een paar extra functies.

De initialisatieparameter spring.profiles.active, geïntroduceerd in Sectie 4, kan ook worden ingesteld als een eigenschap in Spring Boot om momenteel actieve profielen te definiëren. Dit is een standaard eigenschap die Spring Boot automatisch oppikt:

spring.profiles.active = dev

Om profielen programmatisch in te stellen, kunnen we ook de SpringApplication klasse:

SpringApplication.setAdditionalProfiles ("dev");

Om profielen in te stellen met Maven in Spring Boot, kunnen we profielnamen specificeren onder spring-boot-maven-plugin in pom.xml:

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

en voer het Spring Boot-specifieke Maven-doel uit:

mvn spring-boot: run

Maar de belangrijkste profielgerelateerde functie die Spring Boot biedt, is profielspecifieke eigenschappenbestanden. Deze moeten in het formaat worden genoemd applicatie- {profiel} .properties.

Spring Boot laadt automatisch de eigenschappen in een application.properties bestand voor alle profielen, en die in profielspecifiek .eigendommen bestanden alleen voor het opgegeven profiel.

We kunnen bijvoorbeeld verschillende databronnen configureren voor dev en productie profielen met behulp van twee bestanden met de naam application-dev.properties en application-production.properties:

In de application-production.properties bestand, kunnen we een MySql databron:

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

Vervolgens kunnen we dezelfde eigenschappen configureren voor het dev profiel in het application-dev.properties bestand, om een ​​in-memory 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

Op deze manier kunnen we eenvoudig verschillende configuraties bieden voor verschillende omgevingen.

9. Conclusie

In dit artikel hebben we besproken hoe definieer een profiel op een boon en hoe dan schakel de juiste profielen in in onze applicatie.

Ten slotte hebben we ons begrip van profielen gevalideerd met een eenvoudig maar realistisch voorbeeld.

De implementatie van deze tutorial is te vinden in het GitHub-project.