propriétés avec Spring et Spring Boot

aperçu

Ce tutoriel va montrer comment configurer et utiliser les propriétés dans Spring via Java configuration et @PropertySource.

nous verrons également comment les propriétés fonctionnent dans Spring Boot.

enregistrer un fichier de propriétés via des Annotations

Spring 3.1 introduit également la nouvelle annotation @PropertySource comme un mécanisme pratique pour ajouter des sources de propriétés à l’environnement.,

Nous pouvons utiliser cette annotation en conjonction avec l’annotation @Configuration:

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

Une autre façon très utile d’enregistrer un nouveau fichier de propriétés est d’utiliser un espace réservé, ce qui nous permet de sélectionner dynamiquement le bon fichier lors de l’exécution:

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

2.1. Définition de plusieurs emplacements de propriétés

L’annotation @PropertySource peut être répétée selon les conventions Java 8., Par conséquent, si nous utilisons Java 8 ou supérieur, nous pouvons utiliser cette annotation pour définir plusieurs emplacements de propriétés:

bien sûr, nous pouvons également utiliser l’annotation @PropertySources et spécifier un tableau de @PropertySource. Cela fonctionne dans n’importe quelle version Java prise en charge, pas seulement dans Java 8 ou supérieur:

dans les deux cas, il convient de noter qu’en cas de collision de nom de propriété, la dernière source lue a priorité.,

utiliser/injecter des propriétés

injecter une propriété avec l’annotation @Value est simple:

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

Nous pouvons également spécifier une valeur par défaut pour la propriété:

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

le nouveau PropertySourcesPlaceholderConfigurer ajouté dans Spring 3.1, résolvez les espaces réservés $ {}} dans les valeurs de propriété de définition de Bean et les annotations @value.,

enfin, nous pouvons obtenir la valeur d’une propriété en utilisant L’API de L’environnement:

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

propriétés avec Spring Boot

avant d’entrer dans des options de configuration plus avancées pour les propriétés, passons un peu de temps à regarder les nouvelles propriétés

de manière générale, ce nouveau support implique moins de configuration par rapport au Spring standard, ce qui est bien sûr l’un des principaux objectifs de Boot.

4.1. application.,propriétés: le fichier de propriétés par défaut

Boot applique sa convention typique sur l’approche de configuration aux fichiers de propriétés. Cela signifie que nous pouvons simplement mettre une application.fichier de propriétés dans notre répertoire src / main / resources, et il sera détecté automatiquement. Nous pouvons ensuite injecter toutes les propriétés chargées à partir de celui-ci comme d’habitude.

donc, en utilisant ce fichier par défaut, nous n’avons pas besoin d’enregistrer explicitement une PropertySource ou même de fournir un chemin d’accès à un fichier de propriété.,

nous pouvons également configurer un fichier différent à l’exécution si nous en avons besoin, en utilisant une propriété d’environnement:

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

à partir de Spring Boot 2.3, nous pouvons également spécifier des emplacements génériques pour les fichiers de configuration.

Par exemple, nous pouvons définir le printemps.config.location property to config/*/:

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

de cette façon, Spring Boot recherchera les fichiers de configuration correspondant au modèle de répertoire config/*/ en dehors de notre fichier jar. Cela est utile lorsque nous avons plusieurs sources de propriétés de configuration.

Depuis la version 2.4.,0, Spring Boot prend en charge l’utilisation de fichiers de propriétés multi-documents, de la même manière que YAML le fait par conception:

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

notez que pour les fichiers de propriétés, la notation à trois tirets est précédée d’un caractère de commentaire (#).

4.2. Fichier de propriétés spécifiques à l’environnement

Si nous devons cibler différents environnements, il existe un mécanisme intégré pour cela au démarrage.

nous pouvons simplement définir un environnement d’application.fichier de propriétés dans le répertoire src/main / resources, puis définissez un profil Spring avec le même nom d’environnement.,

par exemple, si nous définissons un environnement « staging”, cela signifie que nous devrons définir un profil staging, puis une application staging.propriété.

Ce fichier env sera chargé et aura priorité sur le fichier de propriétés par défaut. Notez que le fichier par défaut sera toujours chargé, c’est juste que lorsqu’il y a une collision de propriétés, le fichier de propriétés spécifique à l’environnement a la priorité.

4.3. Fichier de propriétés spécifiques au Test

Nous pourrions également avoir besoin d’utiliser différentes valeurs de propriété lorsque notre application est en cours de test.,

Spring Boot gère cela pour nous en regardant dans notre répertoire src/test / resources pendant un test. Encore une fois, les propriétés par défaut seront toujours injectables normalement, mais seront remplacées par celles-ci en cas de collision.

4.4. L’Annotation @ TestPropertySource

Si nous avons besoin d’un contrôle plus granulaire sur les propriétés de test, nous pouvons utiliser l’annotation @TestPropertySource.,

cela nous permet de définir des propriétés de test pour un contexte de test spécifique, en ayant priorité sur la propriété par défaut sources:

Si nous ne voulons pas utiliser un fichier, Nous pouvons spécifier des noms et des valeurs directement:

Nous pouvons également obtenir un effet similaire en utilisant l’argument properties de Propriétés hiérarchiques

Si nous avons des propriétés regroupées, nous pouvons utiliser l’annotation @ConfigurationProperties, qui mappera ces hiérarchies de propriétés dans des graphiques D’objets Java.,

prenons quelques propriétés utilisées pour configurer une connexion à une base de données:

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

puis utilisons l’annotation pour les mapper à un objet de base de données:

Spring Boot applique à nouveau sa convention sur l’approche de configuration, mappant automatiquement entre les noms de propriétés et leurs champs correspondants. Tout ce que nous devons fournir est le préfixe de propriété.

Si vous souhaitez approfondir les propriétés de configuration, consultez notre article détaillé.

4.6. Alternative: fichiers YAML

Spring prend également en charge les fichiers YAML.,

toutes les mêmes règles de nommage s’appliquent pour les fichiers de propriétés spécifiques au test, spécifiques à l’environnement et par défaut. La seule différence est l’extension de fichier et une dépendance sur la bibliothèque SnakeYAML étant sur notre chemin de classe.,

YAML est particulièrement utile pour le stockage hiérarchique de propriétés; le fichier de propriétés suivant:

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

est synonyme du fichier YAML suivant:

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

Il convient également de mentionner que les fichiers YAML ne supportent pas l’annotation @ PropertySource, donc si nous avons besoin d’utiliser cette annotation, utilisation d’un fichier de propriétés.

un autre point remarquable est que dans la version 2.4.0 Spring Boot a changé la façon dont les propriétés sont chargées à partir de fichiers YAML multi-documents., Auparavant, l’ordre dans lequel ils ont été ajoutés était basé sur l’ordre d’activation du profil. Avec la nouvelle version, cependant, le cadre suit les mêmes règles de commande que nous avons indiquées précédemment pour .fichiers de propriétés; les propriétés déclarées plus bas dans le fichier remplaceront simplement celles plus élevées.

de plus, dans cette version, les profils ne peuvent plus être activés à partir de documents spécifiques au profil, ce qui rend le résultat plus clair et plus prévisible.

4.7. Importer des fichiers de Configuration supplémentaires

avant la version 2.4.,0, Spring Boot autorisé, y compris les fichiers de configuration supplémentaires à l’aide du ressort.config.emplacement et printemps.config.propriétés supplémentaires-emplacement, mais ils avaient certaines limitations. Par exemple, ils devaient être définis avant de démarrer l’application (en tant que propriétés d’environnement ou de système, ou en utilisant des arguments de ligne de commande) car ils étaient utilisés au début du processus.

dans la version mentionnée, nous pouvons utiliser le ressort.config.importer une propriété dans l’application.Propriétés ou application.fichier yml pour inclure facilement des fichiers supplémentaires., Cette propriété prend en charge quelques fonctionnalités intéressantes:

• ajout de plusieurs fichiers ou répertoires
• les fichiers peuvent être chargés à partir du chemin de classe ou d’un répertoire externe
• indiquant si le processus de démarrage doit échouer si un fichier est introuvable, ou s’il s’agit d’un fichier facultatif
• importation de fichiers sans extension

voyons un exemple valide:

Note: ici, nous avons formaté cette propriété en utilisant des sauts de ligne juste pour plus de clarté.

Spring traitera les importations comme un nouveau document inséré immédiatement en dessous de la déclaration d’importation.

4.8., Propriétés à partir des Arguments de ligne de commande

en plus d’utiliser des fichiers, nous pouvons passer des propriétés directement sur la ligne de commande:

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

Nous pouvons également le faire via les propriétés système, qui sont fournies avant la commande-jar plutôt qu’après:

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

4.9. Propriétés des Variables D’environnement

Spring Boot détectera également les variables d’environnement, les traitant comme des propriétés:

export name=valuejava -jar app.jar

4.10., Randomisation des valeurs de propriétés

Si nous ne voulons pas de valeurs de propriétés déterministes, nous pouvons utiliser RandomValuePropertySource pour randomiser les valeurs des propriétés:

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

4.11. Types supplémentaires de sources de propriété

Spring Boot prend en charge une multitude de sources de propriété, implémentant un ordre bien pensé pour permettre un remplacement raisonnable. Cela vaut la peine de consulter la documentation officielle, qui va plus loin que la portée de cet article.,

Configuration utilisant des Beans bruts — le PropertySourcesPlaceholderConfigurer

outre les méthodes pratiques d’obtenir des propriétés dans Spring, nous pouvons également définir et regiter manuellement le bean de configuration de propriété.

travailler avec PropertySourcesPlaceholderConfigurer nous donne un contrôle total sur la configuration, avec l’inconvénient d’être plus verbeux et la plupart du temps, inutile.,

voyons comment définir ce bean en utilisant la configuration Java:

Propriétés dans des contextes Parent-enfant

cette question revient encore et encore: que se passe-t-il lorsque notre application web a un contexte parent et un contexte enfant? Le contexte parent peut avoir des fonctionnalités de base et des beans communs, puis un (ou plusieurs) contextes enfants, contenant peut-être des beans spécifiques à la servlet.

dans ce cas, quelle est la meilleure façon de définir les fichiers de propriétés et de les inclure dans ces contextes? Et comment récupérer au mieux ces propriétés du printemps?

nous allons donner une ventilation simple.,

Si le fichier est défini dans le contexte Parent:

• @Value travaux dans le contexte Enfant: OUI

• @Value travaux dans le contexte Parent: OUI

• l’environnement.getProperty dans le contexte enfant: Oui

• environnement.getProperty dans le contexte Parent: OUI

Si le fichier est défini dans le contexte Enfant:

• @Value travaux dans le contexte Enfant: OUI

• @Value travaux dans le contexte Parent: NON

• l’environnement.getProperty dans le contexte enfant: Oui

• environnement.,getProperty dans le contexte Parent: no

Conclusion

Cet article a montré plusieurs exemples de travail avec des propriétés et des fichiers de propriétés au printemps.

Comme toujours, l’intégralité du code sauvegardant l’article est disponible sur GitHub.