Lente @PropertySource

De annotatie @PropertySource wordt gebruikt om een properties-bestand te verstrekken aan de Spring Environment. Deze annotatie wordt gebruikt met @Configuration-klassen. De Spring PropertySource-annotatie is herhaalbaar, wat betekent dat je meerdere PropertySource-annotaties kunt hebben in een Configuration-klasse. Deze functie is beschikbaar als je Java 8 of een nieuwere versie gebruikt.

Voorbeeld van Spring PropertySource

Laten we snel een eenvoudige Spring-toepassing doornemen waarbij we de configuratiegegevens van de database uit het properties-bestand lezen en de databaseverbinding maken. We zullen enkele metagegevens van de database naar de console afdrukken. Maak een eenvoudig Maven-project en voeg Spring- en MySQL-afhankelijkheden toe. Je kunt ook een andere database gebruiken voor het voorbeeld, pas gewoon de configuraties dienovereenkomstig aan.

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

Hieronder zie je de uiteindelijke structuur van ons project. We zullen alle belangrijke componenten stap voor stap doornemen. Hier is onze klasse om de databaseverbinding te maken.

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

Let op: Als u een real-world applicatie aan het maken bent, kunt u Spring ORM gebruiken. Op deze manier zal Spring de databaseverbindingen beheren en kunt u zich richten op het schrijven van bedrijfslogica. Laten we nu de Spring Configuration-klasse maken waar we de PropertySource-annotatie zullen gebruiken.

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

Let op dat ik meerdere eigenschappenbestanden in de Spring-omgeving laad. Laten we eens kijken naar de inhoud van deze eigenschappenbestanden. db.properties

# MySQL Database Configuraties
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

Laten we de hoofdklasse maken en databasegegevens ophalen.

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

		// sluit de Spring-context
		context.close();
	}

}

Voer gewoon de bovenstaande klasse uit als een Java-toepassing, dan zal het het volgende uitvoer produceren.

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

Ter verbetering van de leesbaarheid heb ik de debugberichten verwijderd die door Spring naar de console worden gelogd.

Spring @PropertySource Meerdere bestanden – @PropertySources

Er is nog een andere manier om meerdere eigenschappenbestanden te laden voor een configuratieklasse.

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

Vanaf Java 8 is de PropertySource-annotatie herhaalbaar geworden. Voor eerdere Java-versies was @PropertySources de manier om meerdere eigenschapsbestanden aan de configuratieklasse te verstrekken.

Spring PropertySource Override-waarden

We kunnen meerdere eigenschapsbestanden laden in de Spring-omgeving. Als er dezelfde sleutels aanwezig zijn in meerdere bestanden, zal het laatst geladen eigenschapsbestand de eerdere waarden overschrijven. Dus als je ongewenste waarden krijgt voor je eigenschap, controleer dan of dezelfde sleutel aanwezig is in een ander eigenschapsbestand en wat de volgorde is van het laden van deze eigenschapsbestanden.

Spring PropertySource Externe Bestand

Soms bevinden onze configuratiebestanden zich op een specifieke locatie en maken ze geen deel uit van het project-classpath. We kunnen PropertySource configureren om eigenschapsbestanden ook vanuit het bestandssysteem te laden.

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

Spring PropertySource Omgevingsvariabele

Merk op dat de bovenstaande configuratie om het eigenschappenbestand van de externe locatie te lezen zal werken voor mijn lokale systeem maar niet voor iemand anders of op de server. We kunnen ook systeemvariabelen lezen in PropertySource, dus onderstaande configuratie zal voor iedereen werken.

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

Spring PropertySource negeer FileNotFoundException

Als het eigenschappenbestand niet wordt gevonden, zullen we een FileNotFoundException krijgen. Soms willen we geen uitzondering gooien omdat onze toepassing ook met standaardwaarden kan werken. We kunnen PropertySource ignoreResourceNotFound gebruiken om true te zetten om het Spring-framework te vertellen geen uitzondering te gooien als het bestand niet wordt gevonden.

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

Dat is alles voor het voorbeeld van Spring PropertySource. Je kunt de broncode en het Maven-project controleren in onze GitHub Repository.

Spring PropertySource Project