Spring-Annotationen
Spring-Annotationen ermöglichen es uns, Abhängigkeiten zu konfigurieren und Abhängigkeitsinjektion durch Java-Programme zu implementieren.
Überblick über Spring-Annotationen
Das Spring-Framework implementiert und fördert das Prinzip der Inversionssteuerung (IOC) oder Abhängigkeitsinjektion (DI) und ist tatsächlich ein IOC-Container. Traditionell erlaubt Spring einem Entwickler, Abhängigkeiten von Beans mit einer XML-basierten Konfiguration zu verwalten. Es gibt eine alternative Methode, um Beans und ihre Abhängigkeiten zu definieren. Diese Methode ist eine Java-basierte Konfiguration. Im Gegensatz zum XML-Ansatz ermöglicht die Java-basierte Konfiguration es Ihnen, Bean-Komponenten programmatisch zu verwalten. Deshalb wurden Spring-Annotationen eingeführt. In diesem Artikel werden wir die am häufigsten verwendeten Spring-Annotationen erkunden und uns einige Beispielprogramme ansehen.
Liste der Spring-Annotationen
Einige der Kernframework-Annotationen von Spring sind:
@Configuration
Wird verwendet, um anzugeben, dass eine Klasse eine oder mehrere @Bean-Methoden deklariert. Diese Klassen werden vom Spring-Container verarbeitet, um Bean-Definitionen zu generieren und Dienstanfragen für diese Beans zur Laufzeit zu bedienen.
@Bean
Gibt an, dass eine Methode einen von Spring verwalteten Bean erzeugt. Dies ist eine der am häufigsten verwendeten und wichtigen Spring-Annotationen. Die @Bean-Annotation kann auch mit Parametern wie name, initMethod und destroyMethod verwendet werden.
- name – erlaubt Ihnen, dem Bean einen Namen zu geben
- initMethod – ermöglicht Ihnen, die Methode zu wählen, die beim Registrieren des Kontexts aufgerufen wird
- destroyMethod – ermöglicht Ihnen, die Methode zu wählen, die beim Herunterfahren des Kontexts aufgerufen wird
Zum Beispiel:
@Configuration
public class AppConfig {
@Bean(name = "comp", initMethod = "turnOn", destroyMethod = "turnOff")
Computer computer(){
return new Computer();
}
}
public class Computer {
public void turnOn(){
System.out.println("Betriebssystem laden");
}
public void turnOff(){
System.out.println("Alle Programme schließen");
}
}
@PreDestroy und @PostConstruct sind alternative Wege für die Bean-initMethod und destroyMethod. Sie können verwendet werden, wenn die Bean-Klasse von uns definiert ist. Zum Beispiel;
public class Computer {
@PostConstruct
public void turnOn(){
System.out.println("Betriebssystem laden");
}
@PreDestroy
public void turnOff(){
System.out.println("Alle Programme schließen");
}
}
@ComponentScan
Konfiguriert Anweisungen zum Scannen von Komponenten für die Verwendung mit @Configuration-Klassen. Hier können wir die Basispakete angeben, die nach Spring-Komponenten gescannt werden sollen.
@Component
Gibt an, dass eine annotierte Klasse eine „Komponente“ ist. Solche Klassen werden als Kandidaten für die automatische Erkennung bei der Verwendung von annotationsbasierter Konfiguration und Klassenpfad-Scanning betrachtet.
@PropertySource
Bietet einen einfachen deklarativen Mechanismus, um eine Eigenschaftsquelle zur Umgebung von Spring hinzuzufügen. Es gibt eine ähnliche Annotation für das Hinzufügen eines Arrays von Eigenschaftsquellendateien, z. B. @PropertySources.
@Service
Gibt an, dass eine annotierte Klasse ein „Service“ ist. Diese Annotation dient als Spezialisierung von @Component und ermöglicht es Implementierungsklassen, durch Klassenpfad-Scanning automatisch erkannt zu werden.
@Repository
Gibt an, dass eine annotierte Klasse ein „Repository“ ist. Diese Annotation dient als Spezialisierung von @Component und wird für die Verwendung mit DAO-Klassen empfohlen.
@Autowired
Die Spring-Annotation @Autowired wird für die automatische Injektion von Beans verwendet. Die Spring-Annotation @Qualifier wird in Verbindung mit Autowired verwendet, um Verwirrung zu vermeiden, wenn wir zwei oder mehr Beans für denselben Typ konfiguriert haben.
Spring MVC-Annotationen
Einige der wichtigen Spring-MVC-Annotationen sind:
- @Controller
- @RequestMapping
- @PathVariable
- @RequestParam
- @ModelAttribute
- @RequestBody und @ResponseBody
- @RequestHeader und @ResponseHeader
Sie können mehr darüber im Spring-MVC-Tutorial erfahren.
Spring-Annotationen für das Transaktionsmanagement
@Transactional ist die Spring-deklarative Transaktionsmanagement-Annotation, mehr dazu unter Spring MVC Hibernate.
Spring-Sicherheitsannotationen
@EnableWebSecurity wird zusammen mit der @Configuration-Klasse verwendet, um die Spring-Sicherheitskonfiguration zu definieren, mehr dazu unter Spring Security Beispiel.
Spring Boot-Annotationen
@SpringBootApplication
@EnableAutoConfiguration
Mehr dazu unter Spring Boot Beispiel.
Spring-Annotationsbeispiel
Lassen Sie uns ein einfaches Beispiel ansehen, in dem wir Spring-Annotationen in unserer Anwendung verwenden. Das untenstehende Bild veranschaulicht mein Spring-Annotations-Beispielprojekt.
Spring Framework-Abhängigkeiten
Spring Framework-AbhängigkeitenIch habe das Maven-Projekt erstellt und Spring Core Framework-Abhängigkeiten hinzugefügt.
<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.journaldev.spring</groupId>
<artifactId>spring-annotations</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>Spring-Annotationen</name>
<properties>
<spring.framework>4.3.0.RELEASE</spring.framework>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.framework}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.framework}</version>
</dependency>
</dependencies>
</project>
Damit werden alle Spring Core JARs für unser Projekt eingebunden.
Komponentenklassen
Der nächste Schritt besteht darin, Komponentenklassen zu erstellen. Hier imitiere ich mehrere Datenbankkomponenten, eine für MySQL und eine weitere für Oracle.
DataBaseDriver ist die Basisschnittstelle, die wir implementieren werden.
package com.journaldev.drivers;
public interface DataBaseDriver {
public String getInfo();
}
DataBaseDriver ist die Basisschnittstelle, die wir implementieren werden.
package com.journaldev.drivers;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;
@Component
@PropertySource("classpath:mysqldatabase.properties")
public class MySqlDriver implements DataBaseDriver {
@Value("${databaseName}")
private String databaseName;
@Value("${disableStatementPooling}")
private String disableStatementPooling;
public String getInfo() {
return "[ Treiber: mySql" +
", Datenbankname: " + databaseName +
", disableStatementPooling: " + disableStatementPooling +
" ]";
}
}
Beachten Sie die Verwendung der @Component-Annotation, um dem Spring-Framework anzuzeigen, diese Klasse als Komponente zu behandeln. Wir verwenden auch @PropertySource- und @Value-Annotationen, Spring wird diese zur Laufzeit verwenden, um diese Variablenwerte aus der angegebenen Eigenschaftsdatei zu injizieren und festzulegen. Unten sind die Eigenschaften in der mysqldatabase.properties-Datei deklariert.
databaseName=schule
disableStatementPooling=true
package com.journaldev.drivers;
public class OracleDriver implements DataBaseDriver {
protected String url;
protected String user;
protected String password;
protected String driver;
protected Integer port;
public String getUrl() {
return url;
}
public String getUser() {
return user;
}
public void setUser(String user) {
this.user = user;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getDriver() {
return driver;
}
public void setDriver(String driver) {
this.driver = driver;
}
public Integer getPort() {
return port;
}
public void setPort(Integer port) {
this.port = port;
}
public void setUrl(String url) {
this.url = url;
}
public String getInfo() {
return "[ Treiber: Oracle" +
", url: " + url +
", port; " + port +
", Benutzer: " + user +
", Passwort: " + password +
", Treiber: " + driver +
" ] ";
}
}
package com.journaldev.drivers;
public class OracleDriver implements DataBaseDriver {
protected String url;
protected String user;
protected String password;
protected String driver;
protected Integer port;
public String getUrl() {
return url;
}
public String getUser() {
return user;
}
public void setUser(String user) {
this.user = user;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getDriver() {
return driver;
}
public void setDriver(String driver) {
this.driver = driver;
}
public Integer getPort() {
return port;
}
public void setPort(Integer port) {
this.port = port;
}
public void setUrl(String url) {
this.url = url;
}
public String getInfo() {
return "[ Treiber: Oracle" +
", url: " + url +
", port; " + port +
", Benutzer: " + user +
", Passwort: " + password +
", Treiber: " + driver +
" ] ";
}
}
OracleDriver ist ein einfacher Bean, wir verwenden eine Serviceklasse, um Eigenschaften in diesen Bean zu injizieren.
Spring Serviceklasse
package com.journaldev.service;
import com.journaldev.drivers.DataBaseDriver;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
@Service
public class UserService {
@Autowired
@Qualifier("oracleDriver")
private DataBaseDriver dataBaseDriver;
public String getDriverInfo(){
return dataBaseDriver.getInfo();
}
}
Hier verwenden wir die @Service-Annotation, um dem Spring-Framework anzuzeigen, diese als Serviceklasse zu behandeln. Dann verwenden wir die @Autowired- und @Qualifier(„oracleDriver“)-Annotationen, um dem Spring-Framework mitzuteilen, dass es den Bean mit dem Namen oracleDriver in die Klassenvariable dataBaseDriver injizieren soll. Beachten Sie, dass wir diesen Spring-Bean noch nicht erstellt haben.
Spring Beans
Der letzte Schritt besteht darin, unsere Spring-Beans und Konfigurationsklassen zu erstellen, um alles zusammenzufügen.
package com.journaldev.config;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
import com.journaldev.drivers.DataBaseDriver;
import com.journaldev.drivers.MySqlDriver;
import com.journaldev.drivers.OracleDriver;
@Configuration
@ComponentScan("com.journaldev")
@PropertySource("classpath:oracledatabase.properties")
public class AppConfig {
@Autowired
Environment environment;
@Bean
DataBaseDriver oracleDriver() {
OracleDriver oracleDriver = new OracleDriver();
oracleDriver.setDriver(environment.getProperty("db.driver"));
oracleDriver.setUrl(environment.getProperty("db.url"));
oracleDriver.setPort(Integer.parseInt(environment.getProperty("db.port")));
oracleDriver.setUser(environment.getProperty("db.user"));
oracleDriver.setPassword(environment.getProperty("db.password"));
return oracleDriver;
}
@Bean
DataBaseDriver mysqlDriver() {
return new MySqlDriver();
}
}
Beachten Sie die Bean-Definition für oracleDriver. In dieser Methode lesen wir Eigenschaften aus der oracledatabase.properties-Datei, die durch das Spring-Framework der Umgebungsvariable zugewiesen wird. Hier sind die Eigenschaften definiert in der oracledatabase.properties-Datei.
db.url=localhost
db.port=4444
db.user=vasiliy
db.password=yilisav
db.driver=driver_name
Unser Spring-Annotations-Beispielprojekt ist nun bereit zum Testen. Zusammenfassend haben wir folgende Schritte durchgeführt:
- Maven-Projekt erstellt und benötigte Spring-Abhängigkeiten hinzugefügt.
- Komponentenklassen erstellt und Eigenschaften aus einer Ressourcendatei in deren Variablen injiziert.
- Wenn wir eine Drittanbieterkomponente haben, können wir eine Serviceklasse verwenden, um Abhängigkeiten in sie zu injizieren. Genau wie wir es für OracleDriver durch die UserService-Klasse gemacht haben.
- Schließlich haben wir die Konfigurationsklasse erstellt, um Spring-Beans zu definieren und das Basispaket für das Scannen von Spring-Komponentenklassen festzulegen und sie zu konfigurieren.
Testen des Spring-Annotations-Beispiels
Hier ist unsere Hauptklasse, um unser Spring-Annotations-Beispielprojekt zu testen.
package com.journaldev;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;
import com.journaldev.config.AppConfig;
import com.journaldev.drivers.DataBaseDriver;
import com.journaldev.service.UserService;
public class Main {
public static void main(String[] args) {
AbstractApplicationContext appContext = new AnnotationConfigApplicationContext(AppConfig.class);
DataBaseDriver oracle = appContext.getBean("oracleDriver", DataBaseDriver.class);
DataBaseDriver mysql = appContext.getBean("mysqlDriver", DataBaseDriver.class);
System.out.println("Oracle Treiberinfo:");
System.out.println(oracle.getInfo());
System.out.println("MySQL Treiberinfo:");
System.out.println(mysql.getInfo());
System.out.println("UserService Informationen");
UserService userService = appContext.getBean(UserService.class);
System.out.println(userService.getDriverInfo());
appContext.close();
}
}
Das untenstehende Bild zeigt die erzeugte Ausgabe. Beachten Sie, dass wir kein Logging-Framework konfiguriert haben, daher wird das gesamte Logging des Spring-Frameworks in roter Farbe in der Konsole gedruckt.
Das war eine kurze Einführung in Spring-Annotationen. Ich habe hier die meisten der wichtigen Annotationen aufgelistet, aber es gibt noch viele weitere für spezifische Aufgaben zu meistern.
