Injecter une carte à partir d'un fichier YAML avec Spring

1. Vue d'ensemble

Dans ce tutoriel rapide, nous allons examiner de près comment injecter une carte à partir d'un fichier YAML dans Spring Boot .

Tout d'abord, nous allons commencer par un petit aperçu des fichiers YAML dans Spring Framework. Ensuite, nous montrerons, à travers un exemple pratique, comment lier des propriétés YAML à une carte .

2. Fichiers YAML dans Spring Framework

L'utilisation de fichiers YAML pour stocker des données de configuration externes est une pratique courante chez les développeurs Spring. Fondamentalement, Spring prend en charge les documents YAML comme alternative aux propriétés et utilise SnakeYAML sous le capot pour les analyser .

Sans plus tarder, voyons à quoi ressemble un fichier YAML typique:

server: port: 8090 application: name: myapplication url: //myapplication.com

Comme nous pouvons le voir, le fichier YAML est explicite et plus lisible par l'homme. En fait, YAML fournit un moyen sophistiqué et concis de stocker des données de configuration hiérarchiques.

Par défaut, Spring Boot lit les propriétés de configuration depuis application.properties ou application.yml au démarrage de l'application. Cependant, nous pouvons utiliser @PropertySource pour charger un fichier YAML personnalisé.

Maintenant que nous savons ce qu'est un fichier YAML, voyons comment injecter des propriétés YAML en tant que carte dans Spring Boot.

3. Comment injecter une carte à partir d'un fichier YAML

Spring Boot a fait passer l' externalisation des données au niveau supérieur en fournissant une annotation pratique appelée @ConfigurationProperties. Cette annotation est introduite pour injecter facilement des propriétés externes à partir de fichiers de configuration directement dans des objets Java .

Dans cette section, nous allons expliquer en détail comment lier les propriétés YAML dans une classe de bean à l'aide de l' annotation @ConfigurationProperties .

Tout d'abord, définissons quelques propriétés clé-valeur dans application.yml :

server: application: name: InjectMapFromYAML url: //injectmapfromyaml.dev description: How To Inject a map from a YAML File in Spring Boot config: ips: - 10.10.10.10 - 10.10.10.11 - 10.10.10.12 - 10.10.10.13 filesystem: - /dev/root - /dev/md2 - /dev/md4 users: root: username: root password: rootpass guest: username: guest password: guestpass

Dans cet exemple, nous allons essayer de mapper l' application dans une simple carte. De même, nous injecterons les détails de la configuration sous forme de carte , et les utilisateurs sous forme de carte avec des clés de chaîne et des objets appartenant à une classe définie par l'utilisateur - Credential - en tant que valeurs .

Deuxièmement, créons une classe de bean - ServerProperties - pour encapsuler la logique de liaison de nos propriétés de configuration aux Map s:

@Component @ConfigurationProperties(prefix = "server") public class ServerProperties { private Map application; private Map
    
      config; private Map users; // getters and setters public static class Credential { private String username; private String password; // getters and setters } }
    

Comme on peut le voir, nous avons décoré la ServerProperties classe avec @ConfigurationProperties. De cette façon, nous demandons à Spring de mapper toutes les propriétés avec le préfixe spécifié à un objet de ServerProperties .

Rappelez-vous que notre application doit également être activée pour les propriétés de configuration, bien que cela se fasse automatiquement dans la plupart des applications Spring Boot.

Enfin, testons si nos propriétés YAML sont correctement injectées en tant que Map s:

@RunWith(SpringRunner.class) @SpringBootTest class MapFromYamlIntegrationTest { @Autowired private ServerProperties serverProperties; @Test public void whenYamlFileProvidedThenInjectSimpleMap() { assertThat(serverProperties.getApplication()) .containsOnlyKeys("name", "url", "description"); assertThat(serverProperties.getApplication() .get("name")).isEqualTo("InjectMapFromYAML"); } @Test public void 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 @Value

Maintenant, faisons une comparaison rapide de @ConfigurationProperties et @Value.

Bien que les deux annotations puissent être utilisées pour injecter des propriétés à partir de fichiers de configuration , elles sont assez différentes. La principale différence entre ces deux annotations est que chacune sert un objectif différent.

En bref, @V alue nous permet d'injecter directement une valeur de propriété particulière par sa clé. Cependant, l' annotation @ConfigurationProperties lie plusieurs propriétés à un objet particulier et permet d'accéder aux propriétés via l'objet mappé.

En général, Spring recommande d'utiliser @ConfigurationProperties sur @Value lorsqu'il s'agit d'injecter des données de configuration . @ConfigurationProperties offre un excellent moyen de centraliser et de regrouper les propriétés de configuration dans un objet structuré que nous pouvons injecter ultérieurement dans d'autres beans.

5. Conclusion

Pour résumer, nous avons d'abord expliqué comment injecter une carte à partir d'un fichier YAML dans Spring Boot. Ensuite, nous avons mis en évidence la différence entre @ConfigurationProperties et @Value.

Comme d'habitude, le code source complet de l'article est disponible à l'adresse over sur GitHub.