Spring @PropertySource

La anotación @PropertySource de Spring se utiliza para proporcionar un archivo de propiedades al Entorno de Spring. Esta anotación se utiliza con clases @Configuration. La anotación Spring PropertySource es repetible, lo que significa que puedes tener múltiples PropertySource en una clase de configuración. Esta característica está disponible si estás utilizando Java 8 o una versión superior.

Ejemplo de Spring PropertySource

Vamos a revisar rápidamente una aplicación de Spring simple donde leeremos detalles de configuración de la base de datos desde el archivo de propiedades y crearemos la conexión a la base de datos. Imprimiremos información de metadatos de la base de datos en la consola. Crea un proyecto Maven simple y agrega dependencias de Spring y MySQL. También puedes usar cualquier otra base de datos para el ejemplo, solo cambia las configuraciones en consecuencia.

<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>

A continuación, se muestra la estructura final de nuestro proyecto en la imagen. Revisaremos todos los componentes importantes uno por uno. Aquí está nuestra clase para crear la Conexión a la Base de Datos.

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: Si estás creando una aplicación del mundo real, puedes usar Spring ORM. De esta manera, Spring se encargará de la gestión de la conexión a la base de datos y tú podrás concentrarte en escribir la lógica del negocio. Ahora creemos la clase de configuración de Spring donde utilizaremos la anotación 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;
    }
	
}

Observa que estoy cargando múltiples archivos de propiedades en el entorno de Spring. Veamos el contenido de estos archivos de propiedades. db.properties

# Configuraciones de la Base de Datos 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

Creemos la clase principal y obtengamos los detalles de la base de datos.

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

		// cierra el contexto de Spring
		context.close();
	}

}

Solo ejecuta la clase anterior como una aplicación Java, producirá la siguiente salida.

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

Para una mejor legibilidad, he eliminado los mensajes de depuración producidos por el registro de Spring en la consola.

Spring @PropertySource Múltiples Archivos – @PropertySources

Hay otra manera de cargar múltiples archivos de propiedades para una clase de configuración.

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

Desde Java 8 en adelante, la anotación PropertySource se volvió repetible. Para versiones anteriores de Java, @PropertySources era la forma de proporcionar múltiples archivos de propiedades a la clase de configuración.

Spring PropertySource Override Values

Podemos cargar varios archivos de propiedades al entorno de Spring. Si hay claves iguales presentes en varios archivos, entonces el último archivo de propiedades cargado sobrescribirá los valores anteriores. Por lo tanto, si está obteniendo valores no deseados para su propiedad, verifique si la misma clave está presente en algún otro archivo de propiedades y cuál es el orden de carga de estos archivos de propiedades.

Spring PropertySource External File

A veces nuestros archivos de configuración están ubicados en una ubicación específica y no forman parte de la ruta de clases del proyecto. Podemos configurar PropertySource para cargar archivos de propiedades desde el sistema de archivos también.

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

Spring PropertySource Environment Variable

Nota que la configuración anterior para leer el archivo de propiedades desde una ubicación externa funcionará en mi sistema local, pero no para otra persona o en el servidor. También podemos leer variables del sistema en PropertySource, por lo que la siguiente configuración funcionará para todos.

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

Spring PropertySource ignora FileNotFoundException

Si el archivo de propiedades no se encuentra, obtendremos FileNotFoundException. A veces no queremos lanzar una excepción porque nuestra aplicación puede funcionar con valores predeterminados. Podemos usar PropertySource ignoreResourceNotFound a true para indicar al framework de Spring que no lance una excepción si no se encuentra el archivo.

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

Eso es todo para el ejemplo de Spring PropertySource. Puedes revisar el código fuente y el proyecto Maven en nuestro Repositorio de GitHub.

Proyecto Spring PropertySource