Spring @PropertySource Annotation

Die Spring @PropertySource Annotation wird verwendet, um eine Eigenschaftendatei für die Spring-Umgebung bereitzustellen. Diese Annotation wird bei @Configuration-Klassen verwendet. Die Spring PropertySource Annotation ist wiederholbar, was bedeutet, dass Sie mehrere PropertySource in einer Configuration-Klasse haben können. Diese Funktion ist verfügbar, wenn Sie Java 8 oder eine höhere Version verwenden.

Spring PropertySource Beispiel

Lassen Sie uns schnell eine einfache Spring-Anwendung durchgehen, in der wir Datenbankkonfigurationsdetails aus der Eigenschaftendatei lesen und die Datenbankverbindung herstellen werden. Wir werden einige Metadateninformationen der Datenbank in der Konsole ausdrucken. Erstellen Sie ein einfaches Maven-Projekt und fügen Sie Spring- und MySQL-Abhängigkeiten hinzu. Sie können für das Beispiel auch jede 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 unsere endgültige Projektstruktur, wir werden alle wichtigen Komponenten einzeln 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 Anwendung für die reale Welt 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 der Geschäftslogik konzentrieren. Lassen Sie uns jetzt die Spring Configuration-Klasse erstellen, in der wir die PropertySource Annotation verwenden werden.

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 Eigenschaftendateien in die Spring-Umgebung lade. Lassen Sie uns einen Blick auf den Inhalt dieser Eigenschaftendateien werfen. db.properties

#MYSQL Database Configurations
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

Let’s create the main class and get database details.

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

		// close the spring context
		context.close();
	}

}

Führen Sie einfach die obige Klasse als Java-Anwendung aus, und es wird folgende Ausgabe erzeugt.

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 von Spring Logging in der Konsole erzeugten Debug-Nachrichten entfernt.

Spring @PropertySource Mehrere Dateien – @PropertySources

Es gibt eine weitere Möglichkeit, mehrere Eigenschaftendateien 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 Eigenschaftendateien der Konfigurationsklasse zur Verfügung zu stellen.

Spring PropertySource Überschreiben von Werten

Wir können mehrere Eigenschaftendateien in die Spring-Umgebung laden. Wenn dieselben Schlüssel in mehreren Dateien vorhanden sind, überschreibt die zuletzt geladene Eigenschaftendatei die früheren Werte. Überprüfen Sie also, ob derselbe Schlüssel in einer anderen Eigenschaftendatei vorhanden ist und in welcher Reihenfolge diese Eigenschaftendateien geladen werden, falls Sie unerwünschte Werte für Ihre Eigenschaft erhalten.

Spring PropertySource Externe Datei

Manchmal befinden sich unsere Konfigurationsdateien an einem bestimmten Ort und sind nicht Teil des Projektklassenpfads. Wir können PropertySource auch so konfigurieren, dass Eigenschaftendateien aus dem Dateisystem geladen werden.

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

Spring PropertySource Umgebungsvariable

Beachten Sie, dass die obige Konfiguration zum Lesen der Eigenschaftendatei von einem externen Standort für mein lokales System funktioniert, aber nicht für jemand anderen oder auf dem Server. Wir können auch Systemvariablen in PropertySource lesen, daher wird die untenstehende Konfiguration für jeden funktionieren.

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

Spring PropertySource Ignoriere FileNotFoundException

Wenn die Eigenschaftendatei nicht gefunden wird, erhalten wir eine 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 zu sagen, dass es keine Ausnahme werfen soll, wenn die Datei nicht gefunden wird.

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

Das ist alles für das Spring PropertySource Beispiel.