Dans ce tutoriel, vous allez apprendre à définir des properties spring et à les utiliser dans votre projet Java. Ce tutoriel suppose que vous avez déjà un projet avec Spring boot fonctionnel et des bases de programmation en Java.
Qu’est-ce que les applications properties Spring ?
Plus communément appelées properties, elles sont des valeurs accessibles dans toute votre application.
Spring les utilise pour de nombreux paramètres, la plupart possèdent des valeurs par défaut, mais que vous pouvez aussi redéfinir par vous-même. Vous pouvez retrouver la liste complète de ces paramètres ici.
Vous pouvez également créer vos propres properties pour vos besoins spécifiques.
Définir une property Spring
Fichier par défaut
Que ce soit pour définir les différents paramètres de spring ou vos propres
properties, Spring recherche par défaut les properties dans le fichier
application.properties ou application.yaml
Ces fichiers sont recherchés dans les dossiers suivants :
- La racine du classpath
- Le package /config du classpath
- Le repertoire courant
- Le sous repertoire /config du repertoire courant
- Les sous repertoires directes du sous repertoire /config
Si vous utilisez le Standard Directory Layout, que ce soit avec Maven ou Gradle,
les fichiers sont généralement mis dans src/main/resources. Puisqu’on peut y accéder depuis le classpath.
Définir ses propres fichiers
Si vous voulez accéder à des properties définies dans un fichier comportant un
autre nom, c’est très simple. Il suffit d’utiliser l’annotation @PropertySource
comme ci-dessous :
@Configuration
@PropertySource("classpath:foo.properties")
@PropertySource("classpath:toto.properties")
public class PropertiesWithJavaConfig {
//...
}
Il est impératif de l’utiliser avec l’annotation @Configuration.
Comme vous avez pu le remarquer la même annotation est défini deux fois. On peut définir l’annotation autant de fois qu’on le souhaite pour définir autant de fichiers. Une autre façon de définir plusieurs fichiers est la suivante :
@PropertySources({
@PropertySource("classpath:foo.properties"),
@PropertySource("classpath:toto.properties")
})
public class PropertiesWithJavaConfig {
//...
}
Il est intéressant de noter qu’en cas de conflit de nom, c’est la dernière property lue qui est utilisée.
Si vous voulez configurer les noms de vos fichiers, c’est possible. Pour cela, il faut utiliser les placeholders.
@PropertySource({
"classpath:persistence-${db.provider:mysql}.properties"
})
public class PropertiesWithJavaConfig {
//...
}
Dans ce cas, si la property db.provider a été préalablement défini par mongodb par
exemple, le fichier persistence-mongodb.properties sera chargé. Si elle n’est pas
définie, ce sera la valeur après le ‘:’ qui sera utilisée. À savoir qu’utiliser le
‘:’ est optionnel, mais si la property n’est jamais déclarée une exception sera levée.
Les différents formats de fichier
Il existe deux formats de fichiers possibles pour définir les properties :
- Le format properties java :
app.name=MyApp app.description=${app.name} is a Spring Boot application - Le format Yaml :
app: name: "MyApp" description: "${app.name} is a Spring Boot application"
Attention, les fichiers Yaml ne sont pas disponibles avec l’annotation @PropertySource.
Property Placeholders
Comme vous l’avez peut-être remarqué dans les exemples précédents, nous avons utilisé ${app.name}.
Cette syntaxe permet dans une property de référer à une autre.
Utiliser les properties en Java
Il existe principalement trois manières différentes d’accéder aux properties depuis un code Java.
L’annotation @Value
On peut accéder à une property très facilement en l’injectant via l’annotation @Value. Ici par exemple si on veut accéder à la property keycloak.url, il faudra marquer :
@Value( "${keycloak.url}" )
private String keycloakUrl;
On peut également définir une valeur par défaut de cette façon :
@Value( "${keycloak.url:UnUrlParDéfaut}" )
private String keycloakUrl;
L’objet Environment
Il est aussi possible d’injecter un objet environnement qui vous permet ensuite d’accéder à n’importe quelle property via une méthode comme suit :
@Autowired
private Environment env;
...
keycloakUrl = env.getProperty("keycloak.url");
Mapping d’objet java
Dans le cas de properties groupées ensemble, on peut utiliser l’annotation @ConfigurationProperties pour les mapper avec un objet Java.
Prenons l’exemple de properties pour configurer la connection à une base de données :
database.url=jdbc:postgresql:/localhost:5432/instance
database.username=foo
database.password=bar
Il suffit ensuite d’utiliser l’annotation sur une classe pour les mapper.
@ConfigurationProperties(prefix = "database")
public class Database {
String url;
String username;
String password;
// standard getters and setters
}
Conclusion
Comme nous l’avons vu Spring offre un panel de possibilités assez large pour déclarer et utiliser très facilement les properties selon les besoins de votre application.