Cloud-Lösungen der Zukunft - Testen!
Revolutionäre Cloud-Technologie, ganz ohne versteckte Kosten. Profitieren Sie von unserer Testphase und entdecken Sie umfassende Funktionen. Der Anmeldeprozess ist transparent und unkompliziert. Starten Sie jetzt Ihre Reise in die Cloud - Kostenfrei!
Spring @Value Annotation
Die Spring @Value-Annotation wird verwendet, um Standardwerte für Variablen und Methodenargumente zuzuweisen. Wir können mit der @Value-Annotation sowohl Spring-Umgebungsvariablen als auch Systemvariablen lesen. Die Spring @Value-Annotation unterstützt auch SpEL (Spring Expression Language). Lassen Sie uns einige Beispiele für die Verwendung der @Value-Annotation betrachten.
Standardwert
Wir können einem Klassenattribut einen Standardwert zuweisen, indem wir die @Value-Annotation verwenden.
@Value("Standard-DB-Konfiguration")
private String defaultName;
Das Argument der @Value-Annotation kann nur ein String sein, aber Spring versucht, es in den angegebenen Typ zu konvertieren. Der folgende Code funktioniert einwandfrei und weist den Variablen die booleschen und ganzzahligen Werte zu.
@Value("true")
private boolean defaultBoolean;
@Value("10")
private int defaultInt;
Spring-Umgebungseigenschaft
@Value("${APP_NAME_NOT_FOUND}")
private String defaultAppName;
Wenn der Schlüssel in den Spring-Umgebungseigenschaften nicht gefunden wird, dann wird der Eigenschaftswert ${APP_NAME_NOT_FOUND} sein. Wir können einen Standardwert zuweisen, der vergeben wird, wenn der Schlüssel in den Spring-Umgebungseigenschaften fehlt.
@Value("${APP_NAME_NOT_FOUND:Standard}")
private String defaultAppName;
Spring @Value – Systemumgebung
Wenn die Spring-Umgebung aufgefüllt wird, liest sie alle Systemumgebungsvariablen und speichert sie als Eigenschaften. So können wir auch Systemvariablen mit der @Value-Annotation zuweisen.
@Value("${java.home}")
private String javaHome;
@Value("${HOME}")
private String homeDir;
Spring @Value – SpEL
Wir können auch die Spring Expression Language mit der @Value-Annotation verwenden. So können wir auch die Java-Home-Systemeigenschaft mit SpEL lesen.
@Value("#{systemProperties['java.home']}")
private String javaHome;
Spring @Value mit Methoden
Wenn die @Value-Annotation an einer Methode gefunden wird, wird Spring diese aufrufen, 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){} //beide 's' und 'v' Werte werden 'Test' sein
@Value("Test")
public void printValues(String s, @Value("Eine andere Variable") String v){}
// s=Test, v=Eine andere Variable
Beispiel
Lassen Sie uns eine einfache Spring-Anwendung erstellen, in der wir die @Value-Annotation verwenden, um Eigenschaften zu lesen und sie Klassenvariablen zuzuweisen. Erstellen Sie ein Maven-Projekt und fügen Sie 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 das untenstehende Bild aussehen, wir werden uns die einzelnen Komponenten nacheinander ansehen.
Erstellen Sie eine Komponentenklasse, in der wir Variablenwerte durch die @Value-Annotation injizieren.
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("Treiberklasse = " + driverClass);
System.out.println("DB-URL = " + dbURL);
System.out.println("Benutzername = " + userName);
// Machen Sie das niemals in einer Produktionsumgebung :D
System.out.println("Passwort = " + 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("Standard-DB-Konfiguration")
private String defaultName;
@Value("true")
private boolean defaultBoolean;
@Value("10")
private int defaultInt;
@Value("${APP_NAME_NOT_FOUND:Standard}")
private String defaultAppName;
@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("eine andere Variable") String v) {
System.out.println("Eingabeargument 1 = " + s);
System.out.println("Eingabeargument 2 = " + v);
System.out.println("Heimverzeichnis = " + homeDir);
System.out.println("Standardkonfigurationsname = " + defaultName);
System.out.println("Standard-App-Name = " + defaultAppName);
System.out.println("Java-Heimverzeichnis = " + javaHome);
System.out.println("Boolean = " + defaultBoolean);
System.out.println("Int = " + defaultInt);
}
Hier ist unsere Hauptklasse, in der wir einen auf Annotationen basierenden 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("Erfrischung des Spring-Kontexts");
DBConnection dbConnection = context.getBean(DBConnection.class);
dbConnection.printDBConfigs();
// Schließen des Spring-Kontexts
context.close();
}
}
Wenn Sie die Klasse ausführen, wird die folgende Ausgabe erzeugt.
Eingabeargument 1 = Test
Eingabeargument 2 = eine andere Variable
Heimverzeichnis = /Users/pankaj
Standardkonfigurationsname = Standard-DB-Konfiguration
Standard-App-Name = Standard
Java-Heimverzeichnis = /Library/Java/JavaVirtualMachines/jdk-10.0.1.jdk/Contents/Home
Boolean = wahr
Int = 10
Erfrischung des Spring-Kontexts
Treiberklasse = com.mysql.jdbc.Driver
DB-URL = jdbc:mysql://localhost:3306/Test
Benutzername = journaldev
Passwort = journaldev
Beachten Sie, dass die printValues()-Methode der Konfigurationsklasse aufgerufen wird, bevor unser Kontext bereit ist, Benutzeranfragen zu bedienen. Das ist alles für das Beispiel der Spring @Value-Annotation, Sie können den Beispielcode von unserem GitHub-Repository herunterladen.
Starten Sie Heute Ihre Kostenlose Cloud-Reise mit Unserer Cloud Testversion
Bereit, Ihre Java-Projekte auf das nächste Level zu heben? Als führender Cloud-Anbieter verstehen wir die Bedeutung einer effizienten und nahtlosen Entwicklung. Deshalb bieten wir Ihnen die exklusive Chance, unsere Cloud-Umgebung völlig kostenfrei zu testen. Tauchen Sie ein in eine Welt gesteigerter Kodierungseffizienz und entdecken Sie, wie unsere Cloud-Lösungen Ihren Entwicklungsprozess transformieren können. Melden Sie sich jetzt für Ihre kostenlose Testversion an und erleben Sie die Zukunft der Cloud-basierten Java-Entwicklung!