streamalism.org

1. Áttekintés

Ez az oktatóanyag megmutatja hogyan lehet a tulajdonságokat tavasszal beállítani és használni Java konfiguráción keresztül és @PropertySource.

Azt is megnézzük, hogyan működnek a tulajdonságok a Spring Boot-ban.

2. Regisztráljon egy tulajdonságfájlt kommentárokkal

A 3.1 tavasz szintén bemutatja az új @PropertySource annotáció mint kényelmes mechanizmus az ingatlanforrások hozzáadásához a környezethez.

Használhatjuk ezt az annotációt a @ Konfiguráció kommentár:

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

Az új tulajdonságfájl regisztrálásának másik nagyon hasznos módja a helyőrző használata, amely lehetővé teszi számunkra dinamikusan válassza ki a megfelelő fájlt futás közben:

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

2.1. Több tulajdon helyének meghatározása

A @PropertySource az annotáció megismételhető a Java 8 konvenciói szerint. Ezért, ha Java 8-at vagy újabbat használunk, akkor ezt a jegyzetet használhatjuk több tulajdonság helyének meghatározására:

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

Természetesen, használhatjuk a @PropertySources jelölést és adjon meg egy tömböt @PropertySource. Ez minden támogatott Java verzióban működik, nem csak Java 8 vagy újabb verzióban:

@PropertySources ({@PropertySource ("classpath: foo.properties"), @PropertySource ("classpath: bar.properties")}) nyilvános osztály PropertiesWithJavaConfig {// ...}

Mindkét esetben érdemes megjegyezni, hogy egy tulajdonnév ütközése esetén az utolsó olvasott forrás élvez elsőbbséget.

3. A Tulajdonságok használata / beadása

Tulajdonság beadása a @Érték annotáció magától érthetődő:

@Value ("$ {jdbc.url}") privát karakterlánc jdbcUrl;

Megadhatunk egy alapértelmezett értéket is a tulajdonsághoz:

@Value ("$ {jdbc.url: aDefaultUrl}") privát karakterlánc jdbcUrl;

Az új PropertySourcesPlaceholderConfigurer hozzáadva a 3.1 tavasszal oldja meg a $ {…} helyőrzőket a babdefiníció tulajdonságértékein belül és @Érték annotációk.

Végül megtehetjük a tulajdonság használatával megkapja az ingatlan értékét Környezet API:

@Autowired privát környezet env; ... dataSource.setUrl (env.getProperty ("jdbc.url"));

4. Tulajdonságok tavaszi csomagtartóval

Mielőtt a tulajdonságok fejlettebb konfigurációs lehetőségeivel foglalkoznánk, töltsünk el egy kis időt a Spring Boot új tulajdonságainak támogatásával.

Általában véve, ez az új támogatás kevesebb konfigurációt igényel a szokásos tavaszhoz képest, ami természetesen a Boot egyik fő célja.

4.1. application.properties: az Alapértelmezett tulajdonságfájl

A rendszerindítás a tulajdonságfájlokra alkalmazza a konfiguráció feletti megközelítést. Ez azt jelenti egyszerűen tehetünk egy alkalmazás.tulajdonságok fájl a mi src / main / resources könyvtárat, és automatikusan felismeri. Ezután bármilyen terhelt tulajdonságot beleadhatunk belőle a szokásos módon.

Tehát ennek az alapértelmezett fájlnak a használatával nem kell kifejezetten regisztrálnunk a PropertySource vagy akár egy tulajdonságfájl elérési útját is megadja.

Futás közben konfigurálhatunk egy másik fájlt is, ha szükséges, egy környezeti tulajdonság használatával:

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

A Spring Boot 2.3-tól helyettesítő karaktereket is megadhatunk a konfigurációs fájlokhoz.

Beállíthatjuk például a tavasz.konfig.hely tulajdonhoz config / * /:

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

Így a Spring Boot megkeresi a config / * / könyvtárminta a jar fájlunkon kívül. Ez jól jön, ha a konfigurációs tulajdonságoknak több forrása is van.

A verzió óta 2.4.0, A Spring Boot támogatja a több dokumentum tulajdonságfájljainak használatát, hasonlóan a YAML-hez, mint a tervezés:

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

Ne feledje, hogy a tulajdonságfájlok esetében a háromjeles jelölést egy megjegyzés karakter (#).

4.2. Környezetspecifikus tulajdonságok fájl

Ha különféle környezeteket kell megcéloznunk, akkor a Boot-ban erre van egy beépített mechanizmus.

Egyszerűen definiálhatunk egy alkalmazás- környezet.tulajdonságok fájl a src / main / resources könyvtárat, majd állítson be egy Spring profilt ugyanazzal a környezeti névvel.

Például, ha definiálunk egy „staging” környezetet, ez azt jelenti, hogy meg kell határoznunk a színpadra állítás profil majd alkalmazás- állomás.tulajdonságok.

Ez az env fájl betöltődik és elsőbbséget élvez az alapértelmezett tulajdonságfájllal szemben. Ne feledje, hogy az alapértelmezett fájl továbbra is betöltődik, csak ha tulajdonságütközés történik, akkor a környezettel kapcsolatos tulajdonságfájl élvez elsőbbséget.

4.3. Teszt-specifikus tulajdonságok fájl

Előfordulhat, hogy különböző tulajdonságértékek használatára is szükségünk van, amikor alkalmazásunk tesztelés alatt áll.

A Spring Boot ezt a számunkra úgy kezeli, hogy belenéz a sajátunkba src / test / resources könyvtárat egy tesztfuttatás során. Ismét az alapértelmezett tulajdonságok továbbra is injektálhatók a szokásos módon, de ütközés esetén ezek felülírják.

4.4. A @TestPropertySource Megjegyzés

Ha részletesebb ellenőrzésre van szükségünk a teszt tulajdonságai felett, akkor használhatjuk a @TestPropertySource annotáció.

Ez lehetővé teszi számunkra a teszt tulajdonságainak beállítását egy adott tesztkörnyezet számára, elsőbbséget élvezve az alapértelmezett tulajdonságforrásokkal szemben:

@RunWith (SpringRunner.class) @TestPropertySource ("/ foo.properties") public class FilePropertyInjectionUnitTest {@Value ("$ {foo}") private String foo; @Test public void whenFilePropertyProvided_thenProperlyInjected () {assertThat (foo) .isEqualTo ("bar"); }}

Ha nem akarunk fájlt használni, akkor közvetlenül megadhatunk neveket és értékeket:

@RunWith (SpringRunner.class) @TestPropertySource (properties = {"foo = bar"}) public class PropertyInjectionUnitTest {@Value ("$ {foo}") private String foo; @Test public void whenPropertyProvided_thenProperlyInjected () {assertThat (foo) .isEqualTo ("bar"); }}

Hasonló hatást is elérhetünk a tulajdonságait érvelése @SpringBootTest kommentár:

@RunWith (SpringRunner.class) @SpringBootTest (tulajdonságok = {"foo = bar"}, class = SpringBootPropertiesTestApplication.class) nyilvános osztály SpringBootPropertyInjectionIntegrationTest {@Value ("$ {foo}") privát karakterlánc foo; @Test public void whenSpringBootPropertyProvided_thenProperlyInjected () {assertThat (foo) .isEqualTo ("bar"); }}

4.5. Hierarchikus tulajdonságok

Ha vannak tulajdonságaik, amelyek csoportosítva vannak, akkor felhasználhatjuk a @ConfigurationProperties annotáció, amely ezeket a tulajdonság hierarchiákat Java objektumdiagramokba térképezi fel.

Vegyünk néhány tulajdonságot, amelyeket az adatbázis-kapcsolat konfigurálásához használunk:

database.url = jdbc: postgresql: / localhost: 5432 / instance database.username = foo database.password = bar

Ezután használjuk a kommentárokat egy adatbázis objektumhoz:

@ConfigurationProperties (prefix = "adatbázis") public class Database {String url; String felhasználónév; Karakterlánc jelszó; // szabványos mérőeszközök és beállítók}

A Spring Boot újra alkalmazza a konvenciókonfigurációs megközelítést, automatikusan leképezi a tulajdonságneveket és a megfelelő mezőket. Minden, amit meg kell adnunk, az ingatlan előtag.

Ha mélyebbre akarja ásni a konfigurációs tulajdonságokat, tekintse meg részletes cikkünket.

4.6. Alternatíva: YAML fájlok

A Spring a YAML fájlokat is támogatja.

Ugyanazok az elnevezési szabályok vonatkoznak a tesztspecifikus, a környezeti és az alapértelmezett tulajdonságfájlokra. Az egyetlen különbség a fájlkiterjesztés és annak függése, hogy a SnakeYAML könyvtár milyen osztályúton van.

A YAML különösen jó hierarchikus tulajdonságtárolásra; a következő tulajdonságfájl:

database.url = jdbc: postgresql: / localhost: 5432 / instance database.username = foo database.password = sáv titka: foo

szinonimája a következő YAML fájlnak:

adatbázis: url: jdbc: postgresql: / localhost: 5432 / instance felhasználónév: foo jelszó: bar secret: foo

Érdemes megemlíteni azt is, hogy a YAML fájlok nem támogatják a @PropertySource kommentár, tehát ha ezt a feliratot kell használnunk, akkor az egy tulajdonságfájl használatára kényszerít minket.

Egy másik figyelemre méltó tény, hogy a 2.4.0 verzióban a Spring Boot megváltoztatta a tulajdonságok betöltésének módját a több dokumentumot tartalmazó YAML fájlokból. Korábban a hozzáadásuk sorrendje a profil aktiválási sorrendjén alapult. Az új verzióval azonban a keretrendszer ugyanazokat a sorrendszabályokat követi, amelyeket korábban jeleztünk .tulajdonságok fájlok; a fájlban alacsonyabban deklarált tulajdonságok egyszerűen felülírják a magasabbakat.

Ezenkívül ebben a verzióban a profilok már nem aktiválhatók a profil-specifikus dokumentumokból, így az eredmény világosabb és kiszámíthatóbb.

4.7. További konfigurációs fájlok importálása

A 2.4.0 verzió előtt a Spring Boot engedélyezte további konfigurációs fájlok beépítését a tavasz.konfig.hely és spring.config.additional-location tulajdonságokkal, de voltak bizonyos korlátai. Például meg kellett határozni őket az alkalmazás elindítása előtt (környezeti vagy rendszertulajdonságokként, vagy parancssori argumentumok használatával), mivel a folyamat elején használták őket.

Az említett változatban használhatjuk a tavasz.konfig.import ingatlanon belül alkalmazás.tulajdonságok vagy alkalmazás.yml fájl, hogy további fájlokat könnyedén tartalmazzon. Ez a szálláshely néhány érdekes funkciót támogat:

• több fájl vagy könyvtár hozzáadása
• a fájlok az osztályútvonalról vagy egy külső könyvtárból tölthetők be
• jelzi, hogy az indítási folyamat kudarcot vall, ha egy fájl nem található, vagy opcionális fájl
• kiterjesztés nélküli fájlok importálása

Lássunk egy érvényes példát:

spring.config.import = classpath: additional-application.properties, classpath: additional-application [.yml], opcionális: file: ./ external.properties, classpath: additional-application-properties /

Megjegyzés: itt csak az érthetőség kedvéért formáztuk ezt a tulajdonságot sortörésekkel.

A tavasz az importot új dokumentumként kezeli, amelyet közvetlenül a behozatali nyilatkozat alá helyeznek be.

4.8. Tulajdonságok a parancssori argumentumokból

A fájlok használata mellett a tulajdonságokat közvetlenül a parancssorba is átadhatjuk:

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

Megtehetjük ezt a rendszer tulajdonságain keresztül is, amelyek a -befőttes üveg parancsot, nem pedig utána:

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

4.9. Tulajdonságok a környezeti változóktól

A Spring Boot a környezeti változókat is felismeri, tulajdonságként kezelve:

export név = érték java -jar app.jar 

4.10. A vagyoni értékek véletlenszerűsítése

Ha nem akarunk determinista tulajdonságértékeket, használhatjuk RandomValuePropertySource a tulajdonságok értékeinek randomizálása:

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

4.11. Az ingatlanforrások további típusai

A Spring Boot az ingatlanforrások sokaságát támogatja, és átgondolt megrendelést hajt végre az ésszerű felülírás érdekében. Érdemes megismerni a hivatalos dokumentációt, amely túlmutat e cikk terjedelmén.

5. Konfigurálás nyers bab felhasználásával - a PropertySourcesPlaceholderConfigurer

A tulajdonságok Springbe történő bevitelének kényelmes módszerei mellett manuálisan is meghatározhatjuk és újra megadhatjuk a tulajdonságkonfigurációs komponenst.

A PropertySourcesPlaceholderConfigurer teljes kontrollt ad nekünk a konfiguráció felett, azzal a hátránnyal, hogy bőbeszédűbbek vagyunk és legtöbbször feleslegesek vagyunk.

Nézzük meg, hogyan definiálhatjuk ezt a babot a Java konfigurációval:

@Bean public static PropertySourcesPlaceholderConfigurer tulajdonságok () {PropertySourcesPlaceholderConfigurer pspc = new PropertySourcesPlaceholderConfigurer (); Erőforrás [] erőforrások = új ClassPathResource [] {új ClassPathResource ("foo.properties")}; pspc.setLocations (források); pspc.setIgnoreUnresolvablePlaceholder (true); return pspc; }

6. Tulajdonságok a szülő-gyermek összefüggésekben

Ez a kérdés újra és újra felmerül: Mi történik, ha a mi a webalkalmazásnak van szülő és gyermek kontextusa? A szülői környezetnek lehet néhány közös alapfunkciója és babja, majd egy (vagy több) gyermekkörnyezet, amely esetleg tartalmaz Servlet-specifikus babot.

Ebben az esetben hogyan lehet a legjobban meghatározni a tulajdonságfájlokat és beilleszteni ezeket az összefüggéseket? És hogyan lehet a legjobban kinyerni ezeket a tulajdonságokat tavasszal?

Egyszerű bontást adunk.

Ha a fájl a szülői környezetben definiálva:

• @Érték ben működik Gyermek kontextus: IGEN

• @Érték ben működik Szülői kontextus: IGEN

• környezet.getProperty ban ben Gyermek kontextus: IGEN

• környezet.getProperty ban ben Szülői kontextus: IGEN

Ha a fájl a gyermek összefüggésében definiálva:

• @Érték ben működik Gyermek kontextus: IGEN

• @Érték ben működik Szülői kontextus: NEM

• környezet.getProperty ban ben Gyermek kontextus: IGEN

• környezet.getProperty ban ben Szülői kontextus: NEM

7. Következtetés

Ez a cikk több példát mutatott be a tulajdonságokkal és tulajdonságfájlokkal tavasszal történő munkára.

Mint mindig, a cikket támogató teljes kód elérhető a GitHubon.