Spring @PropertySource

Primavera A anotação @PropertySource é utilizada para fornecer um arquivo de propriedades ao Ambiente Spring. Essa 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. Esse recurso está disponível se você estiver usando o Java 8 ou uma versão superior.

Exemplo de Spring PropertySource

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. Iremos 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ê pode usar qualquer outro banco de dados também 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, iremos 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 criando um aplicativo do mundo real, você pode usar o Spring ORM. Desta forma, o Spring cuidará da gestão da conexão com o banco de dados e você poderá focar na escrita da lógica de negócios. Agora vamos criar a classe de Configuração do Spring onde usaremos 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;
    }
	
}

Observe que estou carregando vários arquivos de propriedades para o ambiente do Spring. Vamos dar uma olhada no conteúdo desses arquivos de propriedades. db.properties

#Configurações do Banco 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 detalhes do banco 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 do Spring
		context.close();
	}

}

Apenas execute a classe acima como aplicativo Java, ela 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 registro do Spring no console.

Spring @PropertySource Múltiplos Arquivos – @PropertySources

Há outra maneira de carregar múltiplos arquivos 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 se tornou 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 PropertySource do Spring

Podemos carregar vários arquivos de propriedades para o ambiente Spring. Se houver chaves iguais presentes em vários arquivos, então o último arquivo de propriedades carregado substituirá os valores anteriores. Portanto, se você estiver recebendo 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 de PropertySource do Spring

Às vezes, nossos arquivos de configuração estão presentes 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 do PropertySource do Spring

Observe que a configuração acima para ler o arquivo de propriedades do local externo funcionará para 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 receberemos 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 PropertySource ignoreResourceNotFound para true para informar ao framework Spring para não lançar exceção se o arquivo não for encontrado.

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

Isso é tudo para o Exemplo de PropertySource do Spring. Você pode verificar o código-fonte e o projeto Maven em nosso Repositório do GitHub.

Projeto PropertySource do Spring