Spring @PropertySource

Spring @PropertySource annotation est utilisée pour fournir un fichier de propriétés à l’environnement Spring. Cette annotation est utilisée avec les classes @Configuration. L’annotation Spring PropertySource est répétable, ce qui signifie que vous pouvez avoir plusieurs PropertySource sur une classe Configuration. Cette fonctionnalité est disponible si vous utilisez Java 8 ou une version ultérieure.

Exemple de Spring PropertySource

Passons rapidement par une application Spring simple où nous lirons les détails de configuration de la base de données à partir du fichier de propriétés et créerons la connexion à la base de données. Nous imprimerons quelques informations de métadonnées de la base de données sur la console. Créez un projet maven simple et ajoutez les dépendances Spring et MySQL. Vous pouvez également utiliser une autre base de données pour l’exemple, il suffit de modifier les configurations en conséquence.

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-context</artifactId>
	<version>5.0.6.RELEASE</version>
</dependency>
<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
	<version>5.1.46</version>
</dependency>

L’image ci-dessous montre la structure finale de notre projet, nous passerons en revue tous les composants importants un par un. Voici notre classe pour créer la connexion à la base de données.

package com.journaldev.spring;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class DBConnection {

	private String driverClass;
	private String dbURL;
	private String userName;
	private char[] password;
	private Connection con;

	public DBConnection(String driverClass, String dbURL, String userName, char[] password) {
		this.driverClass = driverClass;
		this.dbURL = dbURL;
		this.userName = userName;
		this.password = password;
	}

	public Connection getConnection() {
		if (this.con != null)
			return con;

		Connection con = null;
		try {
			System.out.println("Creating DB Connection");
			Class.forName(driverClass);
			con = DriverManager.getConnection(dbURL, userName, String.valueOf(password));
			System.out.println("Successfully Created DB Connection");
		} catch (ClassNotFoundException | SQLException e) {
			e.printStackTrace();
		}
		this.con = con;
		return con;
	}

	public void close() {
		System.out.println("DBConnection close called");
		if (this.con != null) {
			try {
				con.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}
}

NOTE : Si vous créez une application du monde réel, vous pouvez utiliser Spring ORM. De cette manière, Spring se chargera de la gestion de la connexion à la base de données et vous pourrez vous concentrer sur l’écriture de la logique métier. Maintenant, créons la classe de configuration Spring où nous utiliserons l’annotation PropertySource.

package com.journaldev.spring;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;

@Configuration
@PropertySource("classpath:db.properties")
@PropertySource("classpath:root.properties")
public class DBConfiguration {

	@Autowired
    Environment env;
	
	@Bean
    public DBConnection getDBConnection() {
		System.out.println("Getting DBConnection Bean for App: "+env.getProperty("APP_NAME"));
		DBConnection dbConnection = new DBConnection(env.getProperty("DB_DRIVER_CLASS"), env.getProperty("DB_URL"), env.getProperty("DB_USERNAME"), env.getProperty("DB_PASSWORD").toCharArray());
        return dbConnection;
    }
	
}

Remarquez que je charge plusieurs fichiers de propriétés dans l’environnement Spring. Examinons le contenu de ces fichiers de propriétés. db.properties

# Configurations de la base de données MYSQL
DB_DRIVER_CLASS=com.mysql.jdbc.Driver
DB_URL=jdbc:mysql://localhost:3306/Test
DB_USERNAME=journaldev
DB_PASSWORD=journaldev

root.properties

APP_NAME=PropertySource Example

Créons la classe principale et obtenons les détails de la base de données.

package com.journaldev.spring;

import java.sql.Connection;
import java.sql.SQLException;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class SpringMainClass {

	public static void main(String[] args) throws SQLException {
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
		context.scan("com.journaldev.spring");
		context.refresh();

		DBConnection dbConnection = context.getBean(DBConnection.class);

		Connection con = dbConnection.getConnection();

		System.out.println(con.getMetaData().getDatabaseProductName());
		System.out.println(con.getMetaData().getDatabaseProductVersion());

		// fermer le contexte Spring
		context.close();
	}

}

Exécutez simplement la classe ci-dessus en tant qu’application Java, elle produira la sortie suivante.

Getting DBConnection Bean for App: PropertySource Example
Creating DB Connection
Successfully Created DB Connection
MySQL
5.7.18
DBConnection close called

Pour une meilleure lisibilité, j’ai supprimé les messages de débogage produits par Spring qui s’affichent dans la console.

Spring @PropertySource Fichiers Multiples – @PropertySources

Il existe une autre manière de charger plusieurs fichiers de propriétés pour une classe de configuration.

@PropertySources({
@PropertySource("classpath:db.properties"),
@PropertySource("classpath:root.properties")})
public class DBConfiguration {
}

À partir de Java 8, l’annotation PropertySource est devenue répétable. Pour les versions antérieures de Java, @PropertySources était la manière de fournir plusieurs fichiers de propriétés à la classe de configuration.

Remplacer les valeurs de PropertySource de Spring

Nous pouvons charger plusieurs fichiers de propriétés dans l’environnement Spring. Si des clés identiques sont présentes dans plusieurs fichiers, alors le dernier fichier de propriétés chargé remplacera les valeurs précédentes. Donc, si vous obtenez des valeurs indésirables pour votre propriété, vérifiez si la même clé est présente dans un autre fichier de propriétés et quel est l’ordre de chargement de ces fichiers de propriétés.

PropriétéSource externe de Spring

Parfois, nos fichiers de configuration sont situés à un emplacement spécifique et ne font pas partie du classpath du projet. Nous pouvons configurer PropertySource pour charger des fichiers de propriétés également à partir du système de fichiers.

@PropertySource("file:/Users/pankaj/db.properties")

Variable d’environnement PropertySource de Spring

Remarquez que la configuration ci-dessus pour lire le fichier de propriétés depuis l’emplacement externe fonctionnera pour mon système local, mais pas pour quelqu’un d’autre ou sur le serveur. Nous pouvons également lire les variables système dans PropertySource, donc la configuration ci-dessous fonctionnera pour tout le monde.

@PropertySource("file:${HOME}/db.properties")

Spring PropertySource ignore FileNotFoundException

Si le fichier de propriétés n’est pas trouvé, alors nous obtiendrons FileNotFoundException. Parfois, nous ne voulons pas déclencher d’exception car notre application peut fonctionner avec des valeurs par défaut aussi. Nous pouvons utiliser PropertySource ignoreResourceNotFound à true pour indiquer au framework Spring de ne pas déclencher d’exception si le fichier n’est pas trouvé.

@PropertySource(value = "classpath:root.properties", ignoreResourceNotFound=true)

C’est tout pour l’exemple de Spring PropertySource. Vous pouvez consulter le code source et le projet Maven depuis notre dépôt GitHub.

Projet Spring PropertySource