Spring @PropertySource

La annotazione @PropertySource di Spring viene utilizzata per fornire un file di proprietà all’ambiente Spring. Questa annotazione viene utilizzata con le classi @Configuration. L’annotazione Spring PropertySource è ripetibile, il che significa che è possibile avere più PropertySource in una classe di configurazione. Questa funzionalità è disponibile se si sta utilizzando Java 8 o una versione successiva.

Esempio di Spring PropertySource

Esaminiamo rapidamente un’applicazione Spring semplice in cui leggeremo i dettagli di configurazione del database dal file di proprietà e creeremo la connessione al database. Stamperemo alcune informazioni di metadata del database sulla console. Crea un semplice progetto Maven e aggiungi le dipendenze di Spring e MySQL. Puoi utilizzare anche un altro database per l’esempio, basta modificare le configurazioni di conseguenza.

<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’immagine seguente mostra la struttura finale del nostro progetto. Esamineremo tutti i componenti importanti uno per uno. Ecco la nostra classe per creare la connessione al database.

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();
			}
		}
	}
}

NOTA: Se stai creando un’applicazione del mondo reale, puoi utilizzare Spring ORM. In questo modo, Spring si occuperà della gestione della connessione al database e potrai concentrarti sulla scrittura della logica di business. Ora creiamo la classe di configurazione di Spring in cui utilizzeremo l’annotazione 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;
    }
	
}

Nota che sto caricando più file di proprietà nell’ambiente Spring. Esaminiamo i contenuti di questi file di proprietà. db.properties

# Configurazioni del database 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

Creiamo la classe principale e otteniamo i dettagli del database.

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());

		// chiudi il contesto Spring
		context.close();
	}

}

Esegui semplicemente la classe sopra come applicazione Java, produrrà l’output seguente.

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

Per una migliore leggibilità, ho rimosso i messaggi di debug prodotti dal log di Spring sulla console.

Spring @PropertySource File Multipli – @PropertySources

C’è un altro modo per caricare file di proprietà multipli per una classe di configurazione.

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

Dal Java 8 in poi, l’annotazione PropertySource è diventata ripetibile. Per le versioni precedenti di Java, @PropertySources era il modo per fornire più file di proprietà alla classe di configurazione.

Spring Sovrascrive i Valori di PropertySource

Possiamo caricare più file di proprietà nell’ambiente Spring. Se ci sono chiavi uguali presenti in più file, allora l’ultimo file di proprietà caricato sovrascriverà i valori precedenti. Quindi, se stai ottenendo valori indesiderati per la tua proprietà, controlla se la stessa chiave è presente in un altro file di proprietà e qual è l’ordine di caricamento di questi file di proprietà.

File Esterno di PropertySource di Spring

A volte i nostri file di configurazione sono presenti in una posizione specifica e non fanno parte del classpath del progetto. Possiamo configurare PropertySource per caricare i file di proprietà anche dal sistema di file.

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

Variabile d’Ambiente di PropertySource di Spring

Si noti che la configurazione precedente per leggere il file di proprietà dalla posizione esterna funzionerà per il mio sistema locale, ma non per gli altri o sul server. Possiamo anche leggere le variabili di sistema in PropertySource, quindi la seguente configurazione funzionerà per tutti.

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

Spring PropertySource ignora FileNotFoundException

Se il file di proprietà non viene trovato, otterremo FileNotFoundException. A volte non vogliamo generare un’eccezione perché la nostra applicazione può funzionare anche con i valori predefiniti. Possiamo utilizzare PropertySource ignoreResourceNotFound impostato su true per indicare al framework Spring di non generare un’eccezione se il file non viene trovato.

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

Questo è tutto per l’esempio di Spring PropertySource. Puoi controllare il codice sorgente e il progetto Maven dal nostro repository GitHub.

Progetto Spring PropertySource