egenskaper med Spring and Spring Boot

översikt

den här handledningen visar hur du ställer in och använder egenskaper på våren via Java-konfiguration och @PropertySource.

Vi ser också hur egenskaper fungerar vid Vårstart.

Registrera en egenskapsfil via anteckningar

Spring 3.1 introducerar också den nya @PropertySource-anteckningen som en bekväm mekanism för att lägga till egenskapskällor i miljön.,

vi kan använda denna anteckning i samband med @Configuration annotation:

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

ett annat mycket användbart sätt att registrera en ny egenskapsfil använder en platshållare, vilket gör det möjligt för oss att dynamiskt välja rätt fil vid körning:

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

2.1. Definiera flera Egenskapsplatser

anteckningen @PropertySource kan upprepas enligt Java 8-konventioner., Om vi använder Java 8 eller senare kan vi därför använda denna anteckning för att definiera flera egenskapsplatser:

naturligtvis kan vi också använda @PropertySources-anteckningen och ange en array med @PropertySource. Detta fungerar i alla Java-versioner som stöds, inte bara i Java 8 eller högre:

i båda fallen är det värt att notera att vid kollision med ett egenskapsnamn har den sista källläsningen företräde.,

använda/injicera egenskaper

injicera en egenskap med @Value annotation är enkel:

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

Vi kan också ange ett standardvärde för egenskapen:

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

den nya PropertySourcesPlaceholderConfigurer läggs till våren 3.1 lösa ${…} platshållare inom Bean definition fastighetsvärden och @Value anteckningar.,

slutligen kan vi få värdet av en egenskap med hjälp av Environment API:

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

egenskaper med Spring Boot

innan vi går in i mer avancerade konfigurationsalternativ för egenskaper, låt oss spendera lite tid på att titta på det nya egenskapsstödet i Spring Boot.

generellt sett innebär detta nya stöd mindre konfiguration jämfört med Standardfjädern, vilket naturligtvis är ett av huvudmålen för Boot.

4.1. ansökan.,egenskaper: Standardegenskapsfilen

Boot tillämpar sin typiska konvention över konfigurationsmetod för egenskapsfiler. Det innebär att vi helt enkelt kan göra en ansökan.egenskaper fil i vår src / main / resources katalog, och det kommer att automatiskt detekteras. Vi kan sedan injicera alla laddade egenskaper från det som vanligt.

så genom att använda den här standardfilen behöver vi inte uttryckligen registrera en PropertySource eller ens tillhandahålla en sökväg till en egenskapsfil.,

Vi kan också konfigurera en annan fil vid körning om vi behöver använda en miljöegenskap:

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

Från och med Spring Boot 2.3 kan vi också ange jokertecken för konfigurationsfiler.

till exempel kan vi ställa in våren.konfiguration.läge property to config/*/:

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

På så sätt kommer Spring Boot att leta efter konfigurationsfiler som matchar config/*/ katalogmönstret utanför vår jar-fil. Detta är praktiskt när vi har flera källor till konfigurationsegenskaper.

Sedan version 2.4.,0, Våren stövelstöd med hjälp av multi-document properties-filer, på samma sätt som YAML gör genom design:

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

Observera att egenskaper för filer, tre streck notation föregås av en kommentar tecken (#).

4.2. Miljöspecifika egenskaper fil

om vi behöver rikta olika miljöer, det finns en inbyggd mekanism för det i Boot.

Vi kan helt enkelt definiera en applikationsmiljö.egenskaper fil i src / main / resources katalogen, och sedan ställa in en Fjäderprofil med samma miljönamn.,

om vi till exempel definierar en ”staging”-miljö måste vi definiera en staging-profil och sedan programmera.fastigheter.

den här env-filen laddas och kommer att ha företräde framför standardegenskapsfilen. Observera att standardfilen fortfarande laddas, det är bara det att när det finns en egenskapskollision har den miljöspecifika egenskapsfilen företräde.

4.3. Testspecifika egenskaper fil

Vi kan också ha ett krav på att använda olika egenskapsvärden när vår ansökan är under test.,

Spring Boot hanterar detta för oss genom att titta i vår src/test / resources katalog under en testkörning. Återigen kommer standardegenskaperna fortfarande att vara injicerbara som vanligt men kommer att åsidosättas av dessa om det finns en kollision.

4.4. Anteckningen @TestPropertySource

om vi behöver mer granulär kontroll över testegenskaper kan vi använda @TestPropertySource-anteckningen.,

detta gör det möjligt för oss att ställa in testegenskaper för ett specifikt testsammanhang, med företräde framför standardegenskapskällorna:

om vi inte vill använda en fil kan vi ange namn och värden direkt:

Vi kan också uppnå en liknande effekt med hjälp av egenskapsargumentet för @SpringBootTest-anteckningen:

4.5. Hierarkiska egenskaper

om vi har egenskaper som är grupperade tillsammans kan vi använda anteckningen @ConfigurationProperties, som kommer att kartlägga dessa egenskapshierarkier i Java-objektdiagram.,

låt oss ta några egenskaper som används för att konfigurera en databasanslutning:

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

och låt oss sedan använda anteckningen för att mappa dem till ett databasobjekt:

Spring Boot tillämpar sin konvention över konfigurationsmetod igen, automatiskt mappa mellan egendomsnamn och deras motsvarande fält. Allt vi behöver leverera är fastighetsprefixet.

om du vill gräva djupare i konfigurationsegenskaper, ta en titt på vår djupgående artikel.

4. 6. Alternativ: YAML-filer

Spring stöder även YAML-filer.,

alla samma namnregler gäller för testspecifika, miljöspecifika och standardegenskapsfiler. Den enda skillnaden är filändelsen och ett beroende av SnakeYAML biblioteket är på vår classpath.,

YAML är särskilt bra för hierarkisk fastighetslagring; följande egenskapsfil:

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

är synonymt med följande YAML-fil:

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

det är också värt att nämna att YAML-filer inte stöder @PropertySource-anteckningen, så om vi behöver använda den här anteckningen skulle det begränsa oss till att använda en egenskapsfil.

en annan anmärkningsvärd punkt är att i version 2.4.0 ändrade Spring Boot sättet på vilket egenskaper laddas från flera dokument YAML-filer., Tidigare baserades den ordning i vilken de tillsattes på profilaktiveringsordningen. Med den nya versionen följer ramverket samma orderregler som vi angav tidigare för .egenskaper filer; egenskaper som deklareras lägre i filen kommer helt enkelt att åsidosätta de högre upp.

dessutom kan profiler i den här versionen inte längre aktiveras från profilspecifika dokument, vilket gör resultatet tydligare och mer förutsägbart.

4, 7. Importera ytterligare konfigurationsfiler

före version 2.4.,0, våren Boot tillåtet inklusive ytterligare konfigurationsfiler med hjälp av våren.konfiguration.plats och vår.konfiguration.ytterligare-plats egenskaper, men de hade vissa begränsningar. Till exempel måste de definieras innan programmet startas (som miljö-eller Systemegenskaper eller använda kommandoradsargument) eftersom de användes tidigt i processen.

i den nämnda versionen kan vi använda våren.konfiguration.importera egendom inom programmet.Egenskaper eller tillämpning.yml fil för att enkelt inkludera ytterligare filer., Den här egenskapen stöder några intressanta funktioner:

• lägga till flera filer eller kataloger
• filerna kan laddas antingen från classpath eller från en extern katalog
• indikerar om startprocessen ska misslyckas om en fil inte hittas, eller om det är en valfri fil
• importera extensionless filer

låt oss se ett giltigt exempel:

Obs: här formaterade vi den här egenskapen med raster bara för tydlighetens skull.

våren kommer att behandla importen som ett nytt dokument som infogas omedelbart under importdeklarationen.

4. 8., Egenskaper från kommandoradsargument

förutom att använda filer kan vi skicka egenskaper direkt på kommandoraden:

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

Vi kan också göra detta via Systemegenskaper, som tillhandahålls före kommandot-jar snarare än efter det:

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

4.9. Egenskaper från miljövariabler

Spring Boot kommer också att upptäcka miljövariabler, behandla dem som egenskaper:

export name=valuejava -jar app.jar

4.10., Randomisering av egenskapsvärden

om vi inte vill ha deterministiska egenskapsvärden kan vi använda RandomValuePropertySource för att randomisera värdena för egenskaper:

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

4.11. Ytterligare typer av Egenskapskällor

Spring Boot stöder en mängd egenskapskällor och implementerar en väl genomtänkt beställning för att tillåta förnuftig åsidosättande. Det är värt att konsultera den officiella dokumentationen, som går längre än omfattningen av denna artikel.,

konfiguration med råa bönor-PropertySourcesPlaceholderConfigurer

förutom de praktiska metoderna för att få egenskaper till våren kan vi också definiera och regitera egenskapskonfigurationsbönan manuellt.

att arbeta med PropertySourcesPlaceholderConfigurer ger oss full kontroll över konfigurationen, med nackdelen att vara mer utförlig och för det mesta onödig.,

Låt oss se hur vi kan definiera den här bönan med Java-konfiguration:

egenskaper i föräldra-barn sammanhang

den här frågan kommer upp om och om igen: vad händer när vår webbapplikation har en förälder och ett barnsammanhang? Förälderkontexten kan ha några vanliga kärnfunktioner och bönor, och sedan ett (eller flera) barnkontexter, kanske innehållande servlet-specifika bönor.

i så fall, vad är det bästa sättet att definiera egenskapsfiler och inkludera dem i dessa sammanhang? Och hur man bäst hämtar dessa egenskaper från våren?

vi ger en enkel uppdelning.,

om filen definieras i det överordnade sammanhanget:

• @värdet fungerar i underordnat sammanhang: ja

• @värdet fungerar i överordnat sammanhang: ja

• miljö.getProperty i barn sammanhang: ja

• miljö.getProperty i överordnat sammanhang: ja

om filen definieras i underordnat sammanhang:

• @värdet fungerar i underordnat sammanhang: ja

• @värdet fungerar i överordnat sammanhang: Nej

• miljö.getProperty i barn sammanhang: ja

• miljö.,getProperty i överordnat sammanhang: Nej

slutsats

den här artikeln visade flera exempel på att arbeta med egenskaper och egenskapsfiler under våren.

som alltid är hela koden som stöder artikeln tillgänglig över på GitHub.