eigenschappen met Spring en Spring Boot

overzicht

Deze tutorial laat zien hoe u Eigenschappen in het voorjaar kunt instellen en gebruiken via Java configuration en @PropertySource.

We zullen ook zien hoe eigenschappen werken in Spring Boot.

Registreer een eigenschappenbestand via annotaties

Spring 3.1 introduceert ook de nieuwe @PropertySource annotatie als een handig mechanisme voor het toevoegen van eigenschappenbronnen aan de omgeving.,

we kunnen deze annotatie gebruiken in combinatie met de @Configuration annotatie:

@Configuration@PropertySource("classpath:foo.properties")public class PropertiesWithJavaConfig { //...}

een andere zeer nuttige manier om een nieuw eigenschappenbestand te registreren is het gebruik van een plaatshouder, die ons in staat stelt om dynamisch het juiste bestand te selecteren tijdens runtime:

@PropertySource({ "classpath:persistence-${envTarget:mysql}.properties"})...

2.1. Het definiëren van meerdere Eigenschappenlocaties

De @ PropertySource annotatie is herhaalbaar volgens Java 8 conventies., Daarom, als we Java 8 of hoger gebruiken, kunnen we deze annotatie gebruiken om meerdere eigenschaplocaties te definiëren:

natuurlijk kunnen we ook de @PropertySources annotatie gebruiken en een array van @PropertySource specificeren. Dit werkt in elke ondersteunde Java-versie, niet alleen in Java 8 of hoger:

in beide gevallen is het vermeldenswaard dat in het geval van een eigenschap naam botsing, de laatste bron gelezen heeft voorrang.,

het gebruik van/inspuiten eigenschappen

het injecteren van een eigenschap met de @Value annotatie is eenvoudig:

@Value( "${jdbc.url}" )private String jdbcUrl;

We kunnen ook een standaardwaarde voor de eigenschap opgeven:

@Value( "${jdbc.url:aDefaultUrl}" )private String jdbcUrl;

de nieuwe PropertySourcesPlaceholderConfigurer toegevoegd in het voorjaar 3.1 resolve ${…} placeholders binnen Bean definitie eigenschapswaarden en @Value annotaties.,

tot slot kunnen we de waarde van een eigenschap verkrijgen met behulp van de Environment API:

@Autowiredprivate Environment env;...dataSource.setUrl(env.getProperty("jdbc.url"));

Properties met Spring Boot

voordat we verder gaan met meer geavanceerde configuratie opties voor eigenschappen, laten we wat tijd besteden aan het bekijken van de nieuwe eigenschappen ondersteuning in Spring Boot.

over het algemeen heeft deze nieuwe ondersteuning minder configuratie nodig dan standaard Spring, wat natuurlijk een van de belangrijkste doelen van het opstarten is.

4.1. toepassing.,eigenschappen: het standaard eigenschappenbestand

Boot past zijn typische Conventie over configuratie benadering toe op eigenschappenbestanden. Dit betekent dat we gewoon een aanvraag kunnen plaatsen.eigenschappen bestand in onze src / main / resources directory, en het zal automatisch worden gedetecteerd. Wij kunnen dan om het even welke geladen eigenschappen van het injecteren zoals normaal.

dus, door dit standaard bestand te gebruiken, hoeven we niet expliciet een PropertySource te registreren of zelfs een pad naar een propertysource te geven.,

we kunnen ook een ander bestand tijdens runtime configureren als dat nodig is, met behulp van een omgevingseigenschap:

java -jar app.jar --spring.config.location=classpath:/another-location.properties

vanaf Spring Boot 2.3 kunnen we ook jokertekens opgeven voor configuratiebestanden.

bijvoorbeeld, we kunnen de lente instellen.configuratiebestand.locatie-eigenschap naar config/*/:

java -jar app.jar --spring.config.location=config/*/

op deze manier zal Spring Boot zoeken naar configuratiebestanden die overeenkomen met het config/*/ directory patroon buiten ons jar bestand. Dit is handig als we meerdere bronnen van configuratie-eigenschappen hebben.

sinds versie 2.4.,0, Spring Boot ondersteunt het gebruik van multi-document eigenschappen bestanden, net als YAML doet door ontwerp:

baeldung.customProperty=defaultValue#---baeldung.customProperty=overriddenValue

merk op dat Voor eigenschappen bestanden, de drie-streepjes notatie wordt voorafgegaan door een commentaar teken (#).

4.2. Omgevingsspecifiek eigenschappenbestand

als we verschillende omgevingen moeten targeten, is er een ingebouwd mechanisme voor dat in het opstarten.

We kunnen eenvoudig een application-environment definiëren.eigenschappenbestand in de map src / main / resources en stel vervolgens een Springprofiel in met dezelfde omgevingsnaam.,

bijvoorbeeld, als we een “staging” omgeving definiëren, betekent dat dat we een staging profiel moeten definiëren en dan application-staging.eigenschappen.

dit env-bestand zal worden geladen en zal voorrang hebben op het standaard eigenschappenbestand. Merk op dat het standaard bestand nog steeds wordt geladen, het is gewoon dat wanneer er een eigenschap botsing, de omgeving-specifieke eigenschap bestand heeft voorrang.

4.3. Test-specifiek eigenschappenbestand

We kunnen ook een vereiste hebben om verschillende eigenschappenwaarden te gebruiken wanneer onze toepassing wordt getest.,

Spring Boot behandelt dit voor ons door te kijken in onze src/test/resources directory tijdens een test run. Nogmaals, Standaard eigenschappen zullen nog steeds injecteerbaar zijn als normaal, maar zullen worden overschreven door deze als er een botsing.

4.4. De @ TestPropertySource annotatie

als we meer gedetailleerde controle over testeigenschappen nodig hebben, dan kunnen we de @TestPropertySource annotatie gebruiken.,

Hiermee kunnen we testeigenschappen instellen voor een specifieke testcontext, die voorrang hebben op de standaard eigenschappenbronnen:

als we geen bestand willen gebruiken, kunnen we direct namen en waarden opgeven:

We kunnen ook een vergelijkbaar effect bereiken met het eigenschappen argument van de @SpringBootTest annotatie:

4.5. Hiërarchische eigenschappen

als we eigenschappen hebben die gegroepeerd zijn, kunnen we gebruik maken van de annotatie @ ConfigurationProperties, die deze eigenschappenhiërarchieën zal toewijzen in Java-objectgrafieken.,

laten we een aantal eigenschappen nemen die gebruikt worden om een databaseverbinding te configureren:

database.url=jdbc:postgresql:/localhost:5432/instancedatabase.username=foodatabase.password=bar

en laten we dan de annotatie gebruiken om ze toe te wijzen aan een databaseobject:

Spring Boot past zijn Conventie over configuratiebenadering opnieuw toe, automatisch mapping tussen eigenschapsnamen en hun overeenkomstige velden. Alles wat we moeten leveren is het voorvoegsel van de eigenschap.

Als u dieper wilt graven in de configuratie-eigenschappen, neem dan een kijkje in ons artikel.

4.6. Alternatief: YAML-bestanden

Spring ondersteunt ook YAML-bestanden.,

alle dezelfde naamgevingsregels zijn van toepassing op test-specifieke, omgevingsspecifieke en standaardeigenschapsbestanden. Het enige verschil is de bestandsextensie en een afhankelijkheid van de SnakeYAML bibliotheek op onze classpath.,

YAML is bijzonder goed voor hiërarchische eigenschappenopslag; het volgende eigenschappenbestand:

database.url=jdbc:postgresql:/localhost:5432/instancedatabase.username=foodatabase.password=barsecret: foo

is synoniem met het volgende YAML-bestand:

database: url: jdbc:postgresql:/localhost:5432/instance username: foo password: barsecret: foo

Het is ook vermeldenswaard dat YAML-bestanden de @PropertySource annotatie niet ondersteunen, dus als we deze annotatie nodig hebben, zou het ons beperken om een eigenschappen bestand.

een ander opmerkelijk punt is dat in versie 2.4.0 Spring Boot de manier veranderde waarop eigenschappen worden geladen uit multi-document YAML bestanden., Voorheen was de volgorde waarin ze werden toegevoegd gebaseerd op de profielactiveringsvolgorde. Met de nieuwe versie, echter, het kader volgt dezelfde orderregels die we eerder aangegeven voor .eigenschappen bestanden; eigenschappen gedeclareerd lager in het bestand zal gewoon overschrijven die hoger.

bovendien kunnen in deze versie profielen niet meer worden geactiveerd vanuit profielspecifieke documenten, waardoor de uitkomst duidelijker en voorspelbaarder wordt.

4.7. Importeer extra configuratiebestanden

Voor Versie 2.4.,0, Spring Boot toegestaan inclusief extra configuratiebestanden met behulp van de lente.configuratiebestand.locatie en lente.configuratiebestand.extra-locatie eigenschappen, maar ze hadden bepaalde beperkingen. Bijvoorbeeld, ze moesten worden gedefinieerd voordat de toepassing te starten (als omgeving of Systeemeigenschappen, of met behulp van command-line argumenten) als ze vroeg in het proces werden gebruikt.

in de genoemde versie kunnen we de lente gebruiken.configuratiebestand.eigenschap importeren binnen de toepassing.Eigenschappen of toepassing.yml-bestand om eenvoudig extra bestanden op te nemen., Deze eigenschap ondersteunt enkele interessante functies:

• meerdere bestanden of mappen toevoegen
• de bestanden kunnen worden geladen vanuit de classpath of vanuit een externe map
• wat aangeeft of het opstartproces mislukt als een bestand niet wordt gevonden, of als het een optioneel bestand is
• importeren van extensieloze bestanden

laten we een geldig voorbeeld bekijken:

opmerking: hier hebben we deze eigenschap geformatteerd met behulp van regels breken gewoon voor de duidelijkheid.

Spring zal de invoer behandelen als een nieuw document dat onmiddellijk onder de invoeraangifte wordt ingevoegd.

4.8., Eigenschappen van opdrachtregelargumenten

naast het gebruik van bestanden, kunnen we eigenschappen direct doorgeven op de opdrachtregel:

java -jar app.jar --property="value"

We kunnen dit ook doen via Systeemeigenschappen, die voor het-jar Commando worden gegeven in plaats van Erna:

java -Dproperty.name="value" -jar app.jar

4.9. Eigenschappen van omgevingsvariabelen

Spring Boot zal ook omgevingsvariabelen detecteren, ze behandelen als eigenschappen:

export name=valuejava -jar app.jar

4.10., Randomisatie van eigenschapswaarden

als we geen deterministische eigenschapswaarden willen, kunnen we RandomValuePropertySource gebruiken om de waarden van eigenschappen te randomiseren:

random.number=${random.int}random.long=${random.long}random.uuid=${random.uuid}

4.11. Extra typen Eigenschappenbronnen

Spring Boot ondersteunt een veelheid aan eigenschappenbronnen, waarbij een goed doordachte volgorde wordt geïmplementeerd om zinvolle overschrijvingen mogelijk te maken. Het is de moeite waard om de officiële documentatie te raadplegen, die verder gaat dan de reikwijdte van dit artikel.,

configuratie met behulp van Raw Beans – de PropertySourcesPlaceholderConfigurer

naast de handige methoden om eigenschappen in het voorjaar te krijgen, kunnen we ook handmatig de eigenschapsconfiguratie bean definiëren en regiter.

werken met de PropertySourcesPlaceholderConfigurer geeft ons volledige controle over de configuratie, met als nadeel dat het uitgebreider en meestal overbodig is.,

laten we eens kijken hoe we deze bean kunnen definiëren met behulp van Java-configuratie:

eigenschappen in Ouder-Kind contexten

deze vraag komt steeds weer naar voren: wat gebeurt er als onze webapplicatie een ouder-en een dochter context heeft? De ouder context kan een aantal gemeenschappelijke kern functionaliteit en beans, en dan een (of meerdere) dochter contexten, misschien met servlet-specifieke beans.

In dat geval, wat is de beste manier om eigenschappen bestanden te definiëren en in deze contexten op te nemen? En hoe deze eigenschappen het beste uit de lente te halen?

We geven een eenvoudige uitsplitsing.,

als het bestand is gedefinieerd in de bovenliggende context:

• @Value werkt in onderliggende context: ja

• @Value werkt in bovenliggende context: ja

• omgeving.getProperty in Dochtercontext: ja

• omgeving.getProperty in Parent context: YES

als het bestand is gedefinieerd in de Child context:

• @Value werkt in Child context: YES

• @Value werkt in Parent context: NO

• omgeving.getProperty in Dochtercontext: ja

• omgeving.,getProperty in Parent context: NO

conclusie

Dit artikel toonde verschillende voorbeelden van het werken met eigenschappen en eigenschappen bestanden in het voorjaar.

Zoals altijd is de volledige code achter het artikel beschikbaar op GitHub.