Spring @PropertySource

A anotação @PropertySource do Spring é usada para fornecer arquivos de propriedades ao Ambiente Spring. Esta anotação é usada com classes @Configuration. A anotação Spring PropertySource é repetível, o que significa que você pode ter várias PropertySource em uma classe de configuração. Este recurso está disponível se estiver utilizando Java 8 ou uma versão superior.

Exemplo de PropertySource do Spring

Vamos rapidamente passar por uma aplicação spring simples onde iremos ler detalhes de configuração do banco de dados a partir do arquivo de propriedades e criar a conexão com o banco de dados. Vamos imprimir algumas informações de metadados do banco de dados no console. Crie um projeto maven simples e adicione as dependências do Spring e MySQL. Você também pode usar qualquer outro banco de dados para o exemplo, basta alterar as configurações conforme necessário.

<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 imagem abaixo mostra a estrutura final do nosso projeto, vamos passar por todos os componentes importantes um por um. Aqui está nossa classe para criar a Conexão com o Banco de Dados.

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 estiver a criar uma aplicação do mundo real, pode utilizar o Spring ORM. Desta forma, o Spring irá cuidar da gestão da ligação à base de dados e você pode concentrar-se em escrever a lógica de negócio. Agora vamos criar a classe de Configuração do Spring onde iremos utilizar a anotação 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;
    }
	
}

Note que estou a carregar vários ficheiros de propriedades para o ambiente Spring. Vamos olhar para o conteúdo destes ficheiros de propriedades. db.properties

#Configurações de Base de Dados 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

Vamos criar a classe principal e obter os detalhes da base de dados.

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

		// fechar o contexto Spring
		context.close();
	}

}

Basta executar a classe acima como aplicação Java, irá produzir a seguinte saída.

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

Para melhor legibilidade, removi as mensagens de depuração produzidas pelo registo de primavera na consola.

Primavera @PropertySource Múltiplos Ficheiros – @PropertySources

Existe outra forma de carregar múltiplos ficheiros de propriedades para uma classe de configuração.

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

A partir do Java 8 em diante, a anotação PropertySource tornou-se repetível. Para versões anteriores do Java, @PropertySources era a maneira de fornecer vários arquivos de propriedades para a classe de configuração.

Substituição de Valores de Propriedades da Spring PropertySource

Podemos carregar vários arquivos de propriedades para o ambiente do Spring. Se existirem chaves iguais em vários arquivos, então o último arquivo de propriedades carregado irá substituir os valores anteriores. Portanto, se estiver obtendo valores indesejados para sua propriedade, verifique se a mesma chave está presente em qualquer outro arquivo de propriedades e qual é a ordem de carregamento desses arquivos de propriedades.

Arquivo Externo da Spring PropertySource

Às vezes, nossos arquivos de configuração estão localizados em um local específico e não fazem parte do classpath do projeto. Podemos configurar o PropertySource para carregar arquivos de propriedades do sistema de arquivos também.

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

Variável de Ambiente da Spring PropertySource

Observe que a configuração acima para ler o arquivo de propriedades de uma localização externa funcionará para o meu sistema local, mas não para outra pessoa ou no servidor. Também podemos ler variáveis do sistema em PropertySource, então a configuração abaixo funcionará para todos.

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

Spring PropertySource ignora FileNotFoundException

Se o arquivo de propriedades não for encontrado, então teremos uma FileNotFoundException. Às vezes, não queremos lançar uma exceção porque nossa aplicação pode funcionar com valores padrão também. Podemos usar ignoreResourceNotFound em PropertySource, definindo true, para informar ao framework Spring que não deve lançar exceção se o arquivo não for encontrado.

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

Isso conclui o exemplo de Spring PropertySource. Você pode conferir o código-fonte e o projeto Maven em nosso Repositório GitHub.

Projeto Spring PropertySource