Frühling @Value Annotation

Frühling @Value-Annotation wird verwendet, um Standardwerte für Variablen und Methodenargumente zuzuweisen. Wir können sowohl Spring-Umgebungsvariablen als auch Systemvariablen mit der @Value-Annotation lesen. Die Spring-@Value-Annotation unterstützt auch SpEL. Schauen wir uns einige Beispiele für die Verwendung der @Value-Annotation an.

Frühling @Value – Standardwert

Wir können einem Klassenattribut einen Standardwert mit der @Value-Annotation zuweisen.

@Value("Default DBConfiguration")
private String defaultName;

@Value-Annotation-Argument kann nur ein String sein, aber Spring versucht, ihn in den angegebenen Typ umzuwandeln. Der folgende Code wird einwandfrei funktionieren und die Boolean- und Integer-Werte der Variable zuweisen.

@Value("true")
private boolean defaultBoolean;

@Value("10")
private int defaultInt;

Frühling @Value – Spring Umgebungsvariable

@Value("${APP_NAME_NOT_FOUND}")
private String defaultAppName;

Wenn der Schlüssel nicht in den Umgebungsvariablen der Spring-Umgebung gefunden wird, wird der Eigenschaftswert ${APP_NAME_NOT_FOUND} sein. Wir können einen Standardwert zuweisen, der zugewiesen wird, wenn der Schlüssel in den Umgebungsvariablen der Spring-Umgebung fehlt.

@Value("${APP_NAME_NOT_FOUND:Default}")
private String defaultAppName;

Frühling @Wert – Systemumgebung

Wenn die Spring-Umgebung bevölkert ist, liest sie alle Systemumgebungsvariablen und speichert sie als Eigenschaften. Daher können wir auch Systemvariablen mit der @Wert-Annotation zuweisen.

@Value("${java.home}")
private String javaHome;
	
@Value("${HOME}")
private String homeDir;

Frühling @Wert – SpEL

Wir können auch die Spring Expression Language mit der @Wert-Annotation verwenden. So können wir auch die Java-Heimsystemeigenschaft mit SpEL lesen.

@Value("#{systemProperties['java.home']}")
private String javaHome;

Frühling @Wert mit Methoden

Wenn die @Value-Annotation in einer Methode gefunden wird, ruft der Spring-Kontext sie auf, wenn alle Spring-Konfigurationen und Beans geladen werden. Wenn die Methode mehrere Argumente hat, wird jeder Argumentwert aus der Methodenannotation abgebildet. Wenn wir verschiedene Werte für verschiedene Argumente möchten, können wir die @Value-Annotation direkt mit dem Argument verwenden.

@Value("Test")
public void printValues(String s, String v){} //both 's' and 'v' values will be 'Test' 

@Value("Test")
public void printValues(String s, @Value("Data") String v){}
// s=Test, v=Data

Frühling @Value Beispiel

Erstellen wir eine einfache Frühlingsanwendung, in der wir die @Value-Annotation verwenden, um Eigenschaften zu lesen und ihnen Klassenvariablen zuzuweisen. Erstellen Sie ein Maven-Projekt und fügen Sie die Spring-Core-Abhängigkeiten hinzu.

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-context</artifactId>
	<version>5.0.6.RELEASE</version>
</dependency>

Unsere endgültige Projektstruktur wird wie auf dem untenstehenden Bild aussehen. Wir werden uns jeden der Komponenten einzeln ansehen. Erstellen Sie eine Komponentenklasse, in der wir Variablenwerte durch die @Value-Annotation injizieren werden.

package com.journaldev.spring;

import org.springframework.beans.factory.annotation.Value;

public class DBConnection {

	@Value("${DB_DRIVER_CLASS}")
	private String driverClass;
	@Value("${DB_URL}")
	private String dbURL;
	@Value("${DB_USERNAME}")
	private String userName;
	@Value("${DB_PASSWORD}")
	private char[] password;

	public DBConnection() {
	}

	public void printDBConfigs() {
		System.out.println("Driver Class = " + driverClass);
		System.out.println("DB URL = " + dbURL);
		System.out.println("User Name = " + userName);

		// Machen Sie niemals Folgendes in einer Produktionsumgebung :D
		System.out.println("Password = " + String.valueOf(password));
	}
}

Jetzt müssen wir eine Konfigurationsklasse erstellen und eine @Bean-Methode für die DBConnection-Klasse bereitstellen.

package com.journaldev.spring;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

@Configuration
@PropertySource("classpath:db.properties")
@PropertySource(value = "classpath:root.properties", ignoreResourceNotFound = true)
public class DBConfiguration {

	@Value("Default DBConfiguration")
	private String defaultName;

	@Value("true")
	private boolean defaultBoolean;

	@Value("10")
	private int defaultInt;

	@Value("${APP_NAME_NOT_FOUND:Default}")
	private String defaultAppName;

	// @Value("#{systemProperties['java.home']}")
	@Value("${java.home}")
	private String javaHome;

	@Value("${HOME}")
	private String homeDir;

	@Bean
	public DBConnection getDBConnection() {
		DBConnection dbConnection = new DBConnection();
		return dbConnection;
	}

	@Value("Test")
	public void printValues(String s, @Value("another variable") String v) {
		System.out.println("Input Argument 1 =" + s);
		System.out.println("Input Argument 2 =" + v);

		System.out.println("Home Directory = " + homeDir);
		System.out.println("Default Configuration Name = " + defaultName);
		System.out.println("Default App Name = " + defaultAppName);
		System.out.println("Java Home = " + javaHome);
		System.out.println("Boolean = " + defaultBoolean);
		System.out.println("Int = " + defaultInt);

	}

}

Hier ist unsere Hauptklasse, in der wir einen annotationsbasierten Spring-Kontext erstellen.

package com.journaldev.spring;

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();
		System.out.println("Refreshing the spring context");
		DBConnection dbConnection = context.getBean(DBConnection.class);

		dbConnection.printDBConfigs();
		
		// Schließe den Spring-Kontext
		context.close();
	}

}

Wenn Sie die Klasse ausführen, wird sie folgende Ausgabe erzeugen.

Input Argument 1 =Test
Input Argument 2 =another variable
Home Directory = /Users/pankaj
Default Configuration Name = Default DBConfiguration
Default App Name = Default
Java Home = /Library/Java/JavaVirtualMachines/jdk-10.0.1.jdk/Contents/Home
Boolean = true
Int = 10
Refreshing the spring context
Driver Class = com.mysql.jdbc.Driver
DB URL = jdbc:mysql://localhost:3306/Test
User Name = journaldev
Password = journaldev

Beachten Sie, dass die Konfigurationsklasse printValues() aufgerufen wird, bevor unser Kontext bereit ist, Benutzeranfragen zu bearbeiten. Das ist alles für das Beispiel zur Spring-@Value-Annotation. Sie können den Beispielcode von unserem GitHub-Repository herunterladen.

Spring @Value Annotation Projekt