Injecteer een kaart vanuit een YAML-bestand met Spring

1. Overzicht

In deze korte tutorial gaan we die van dichtbij bekijken hoe u een kaart uit een YAML-bestand in Spring Boot kunt injecteren.

Eerst beginnen we met een klein beetje inzicht in YAML-bestanden in Spring Framework. Vervolgens laten we aan de hand van een praktisch voorbeeld zien hoe u YAML-eigenschappen aan een Kaart.

2. YAML-bestanden in Spring Framework

Het gebruik van YAML-bestanden om externe configuratiegegevens op te slaan is een gangbare praktijk onder Spring-ontwikkelaars. Eigenlijk, Spring ondersteunt YAML-documenten als alternatief voor eigenschappen en gebruikt SnakeYAML onder de motorkap om ze te ontleden.

Laten we zonder verder oponthoud eens kijken hoe een typisch YAML-bestand eruitziet:

server: poort: 8090 applicatie: naam: myapplication url: //myapplication.com

Zoals we kunnen zien, is de YAML-bestand spreekt voor zich en is beter leesbaar voor mensen. In feite biedt YAML een mooie en beknopte manier om hiërarchische configuratiegegevens op te slaan.

Spring Boot leest standaard configuratie-eigenschappen uit application.properties of application.yml bij het opstarten van de applicatie. We kunnen echter gebruiken @PropertySource om een ​​aangepast YAML-bestand te laden.

Nu we bekend zijn met wat een YAML-bestand is, gaan we kijken hoe we YAML-eigenschappen kunnen injecteren als een Kaart in Spring Boot.

3. Hoe injecteert u een Kaart uit een YAML-bestand

Spring Boot heeft gegevensexternalisatie naar een hoger niveau getild door een handige annotatie te bieden met de naam @ConfigurationProperties. Deze annotatie wordt geïntroduceerd om eenvoudig externe eigenschappen uit configuratiebestanden rechtstreeks in Java-objecten te injecteren.

In deze sectie gaan we dieper ingaan op het binden van YAML-eigenschappen in een bean-klasse met behulp van de @ConfigurationProperties annotatie.

Laten we eerst enkele sleutelwaarde-eigenschappen definiëren in application.yml:

server: applicatie: naam: InjectMapFromYAML url: //injectmapfromyaml.dev beschrijving: Hoe een kaart vanuit een YAML-bestand in Spring Boot-configuratie te injecteren: ips: - 10.10.10.10 - 10.10.10.11 - 10.10.10.12 - 10.10.10.13 bestandssysteem: - / dev / root - / dev / md2 - / dev / md4 gebruikers: root: gebruikersnaam: root wachtwoord: rootpass guest: gebruikersnaam: guest wachtwoord: guestpass

In dit voorbeeld zullen we proberen om in kaart te brengen toepassing in een eenvoudig Kaart. Evenzo zullen we injecteren config details als een Kaart, en gebruikers als een Kaart met Draad sleutels en objecten die behoren tot een door de gebruiker gedefinieerde klasse - Referentie - als waarden.

Ten tweede, laten we een bonenklasse maken - ServerProperties - om de logica van het binden van onze configuratie-eigenschappen aan Kaarts:

@Component @ConfigurationProperties (prefix = "server") openbare klasse ServerProperties {privé-kaarttoepassing; privékaart config; particuliere kaartgebruikers; // getters en setters openbare statische klasse Credential {private String gebruikersnaam; privé String-wachtwoord; // getters en setters}}

Zoals we kunnen zien, hebben we de Servereigenschappen les met @ConfigurationProperties. Op die manier vertellen we Spring om alle eigenschappen met het opgegeven voorvoegsel toe te wijzen aan een object van Servereigenschappen.

Bedenk dat onze app ook moet worden ingeschakeld voor configuratie-eigenschappen, hoewel dit automatisch gebeurt in de meeste Spring Boot-applicaties.

Laten we tot slot testen of onze YAML-eigenschappen correct zijn geïnjecteerd als Kaarts:

@RunWith (SpringRunner.class) @SpringBootTest klasse MapFromYamlIntegrationTest {@Autowired private ServerProperties serverProperties; @Test openbare leegte whenYamlFileProvidedThenInjectSimpleMap () {assertThat (serverProperties.getApplication ()) .containsOnlyKeys ("naam", "url", "beschrijving"); assertThat (serverProperties.getApplication () .get ("naam")). isEqualTo ("InjectMapFromYAML"); } @Test openbare leegte whenYamlFileProvidedThenInjectComplexMap () {assertThat (serverProperties.getConfig ()). HasSize (2); assertThat (serverProperties.getConfig () .get ("ips") .get (0)). isEqualTo ("10.10.10.10"); assertThat (serverProperties.getUsers () .get ("root") .getUsername ()). isEqualTo ("root"); }}

4. @ConfigurationProperties vs @Waarde

Laten we nu een snelle vergelijking maken van @ConfigurationProperties en @Waarde.

Ondanks het feit dat beide annotaties kunnen worden gebruikt om eigenschappen uit configuratiebestanden te injecteren, ze zijn heel verschillend. Het belangrijkste verschil tussen deze twee annotaties is dat ze allemaal een ander doel dienen.

Kortom, @Value stelt ons in staat om rechtstreeks een bepaalde eigenschap te injecteren waarde door zijn sleutel. Echter, @ConfigurationProperties annotatie bindt meerdere eigenschappen naar een bepaald object en geeft toegang tot de eigenschappen via het in kaart gebrachte object.

Over het algemeen raadt Spring aan om te gebruiken @ConfigurationProperties over- @Waarde als het gaat om het injecteren van configuratiegegevens. @ConfigurationProperties biedt een geweldige manier om configuratie-eigenschappen te centraliseren en te groeperen in een gestructureerd object dat we later in andere bonen kunnen injecteren.

5. Conclusie

Om het samen te vatten, hebben we eerst uitgelegd hoe u een injecteert Kaart uit een YAML-bestand in Spring Boot. Vervolgens hebben we het verschil tussen @ConfigurationProperties en @Waarde.

Zoals gewoonlijk is de volledige broncode voor het artikel beschikbaar op GitHub.