Spring @PropertySource

Frühling @PropertySource-Annotation wird verwendet, um der Spring-Umgebung eine Eigenschaftsdatei bereitzustellen. Diese Annotation wird mit @Configuration-Klassen verwendet. Die Spring PropertySource-Annotation ist wiederholbar, das bedeutet, Sie können mehrere PropertySource in einer Konfigurationsklasse haben. Diese Funktion ist verfügbar, wenn Sie Java 8 oder eine höhere Version verwenden.

Beispiel für Spring PropertySource

Lassen Sie uns schnell eine einfache Frühlingsanwendung durchgehen, bei der wir Konfigurationsdetails für die Datenbank aus der Eigenschaftsdatei lesen und die Datenbankverbindung erstellen werden. Wir werden einige Metadateninformationen der Datenbank auf der Konsole ausgeben. Erstellen Sie ein einfaches Maven-Projekt und fügen Sie Frühlings- und MySQL-Abhängigkeiten hinzu. Sie können für das Beispiel auch eine andere Datenbank verwenden, ändern Sie einfach die Konfigurationen entsprechend.

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

Das folgende Bild zeigt die endgültige Struktur unseres Projekts, wir werden alle wichtigen Komponenten nacheinander durchgehen. Hier ist unsere Klasse zur Erstellung der Datenbankverbindung.

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

HINWEIS: Wenn Sie eine real-world Anwendung erstellen, können Sie Spring ORM verwenden. Auf diese Weise kümmert sich Spring um das Datenbankverbindungsmanagement, und Sie können sich auf das Schreiben von Geschäftslogik konzentrieren. Erstellen wir nun die Spring-Konfigurationsklasse, in der wir die PropertySource-Annotation verwenden.

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

Beachten Sie, dass ich mehrere Eigenschaftsdateien in die Spring-Umgebung lade. Schauen wir uns den Inhalt dieser Eigenschaftsdateien an. db.properties

# MYSQL-Datenbankkonfigurationen
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

Erstellen wir die Hauptklasse und holen wir uns die Datenbankdetails.

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

		// Schließen des Spring-Kontexts
		context.close();
	}

}

Führen Sie einfach die obige Klasse als Java-Anwendung aus, sie wird folgende Ausgabe erzeugen.

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

Zur besseren Lesbarkeit habe ich die Debug-Nachrichten entfernt, die von Spring zum Konsolenprotokoll ausgegeben werden.

Spring @PropertySource Mehrere Dateien – @PropertySources

Es gibt eine weitere Möglichkeit, mehrere Eigenschaftsdateien für eine Konfigurationsklasse zu laden.

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

Ab Java 8 wurde die PropertySource-Annotation wiederholbar. Für frühere Java-Versionen war @PropertySources der Weg, um mehrere Property-Dateien an die Konfigurationsklasse anzugeben.

Spring PropertySource Override Werte

Wir können mehrere Property-Dateien in die Spring-Umgebung laden. Wenn in mehreren Dateien dieselben Schlüssel vorhanden sind, wird die zuletzt geladene Property-Datei die früheren Werte überschreiben. Wenn Sie also unerwünschte Werte für Ihre Eigenschaft erhalten, überprüfen Sie, ob derselbe Schlüssel in einer anderen Eigenschaftsdatei vorhanden ist, und welche Reihenfolge beim Laden dieser Eigenschaftsdateien verwendet wird.

Spring PropertySource Externe Datei

Manchmal befinden sich unsere Konfigurationsdateien an einem bestimmten Ort und sind nicht Teil des Projekt-Classepfads. Wir können PropertySource konfigurieren, um Eigenschaftsdateien auch vom Dateisystem zu laden.

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

Spring PropertySource Umgebungsvariable

Beachten Sie, dass die obige Konfiguration zum Lesen von Eigenschaftsdateien vom externen Speicherort für mein lokales System funktioniert, aber nicht für andere Personen oder auf dem Server. Wir können auch Systemvariablen in PropertySource lesen, daher funktioniert die folgende Konfiguration für jeden.

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

Spring PropertySource ignoriert FileNotFoundException

Wenn die Eigenschaftsdatei nicht gefunden wird, erhalten wir FileNotFoundException. Manchmal möchten wir keine Ausnahme werfen, weil unsere Anwendung auch mit Standardwerten funktionieren kann. Wir können PropertySource ignoreResourceNotFound auf true setzen, um dem Spring-Framework mitzuteilen, dass keine Ausnahme geworfen werden soll, wenn die Datei nicht gefunden wird.

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

Das war es für das Beispiel Spring PropertySource. Sie können den Quellcode und das Maven-Projekt aus unserem GitHub-Repository überprüfen.

Spring PropertySource-Projekt