Spring-Annotationen

Tutorials
Spring

Spring-Annotationen ermöglichen es uns, Abhängigkeiten zu konfigurieren und die Abhängigkeitsinjektion durch Java-Programme zu implementieren.

Spring-Annotationen

  • Das Spring-Framework implementiert und fördert das Prinzip der Kontrollumkehr (IOC) oder der Abhängigkeitsinjektion (DI) und ist tatsächlich ein IOC-Container.
  • Traditionell ermöglicht Spring einem Entwickler, Bean-Abhängigkeiten mithilfe einer XML-basierten Konfiguration zu verwalten.
  • Es gibt eine alternative Möglichkeit, 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 die programmatische Verwaltung von Bean-Komponenten. Aus diesem Grund wurden Spring-Annotationen eingeführt.

In diesem Artikel werden wir die am häufigsten verwendeten Spring-Annotationen untersuchen und uns auch einige Beispielprogramme ansehen.

Liste der Spring-Annotationen

Einige der Kern-Annotationen des Spring-Frameworks sind:

  1. @Configuration: Wird verwendet, um anzuzeigen, dass eine Klasse eine oder mehrere @Bean-Methoden deklariert. Diese Klassen werden vom Spring-Container verarbeitet, um Bean-Definitionen und Serviceanfragen für diese Beans zur Laufzeit zu generieren.

  2. @Bean: Gibt an, dass eine Methode eine Bean produziert, die vom Spring-Container verwaltet werden soll. Dies ist eine der meistverwendeten und wichtigsten Spring-Annotationen. @Bean kann auch mit Parametern wie Name, initMethod und destroyMethod verwendet werden.

    • Name – ermöglicht es Ihnen, einen Namen für die Bean anzugeben
    • initMethod – ermöglicht es Ihnen, die Methode auszuwählen, die bei der Registrierung des Kontextes aufgerufen wird
    • destroyMethod – ermöglicht es Ihnen, die Methode auszuwählen, die beim Herunterfahren des Kontextes 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");
    }
}

  3. @PreDestroy und @PostConstruct sind eine alternative Möglichkeit für die Bean initMethod und destroyMethod. Sie können verwendet werden, wenn die Bean-Klasse von uns definiert wird. Zum Beispiel;

     public class Computer {

    @PostConstruct
    public void einschalten(){
        System.out.println("Betriebssystem laden");
    }

    @PreDestroy
    public void ausschalten(){
        System.out.println("Alle Programme schließen");
    }
}

  4. @ComponentScan: Konfiguriert Komponenten-Scanning-Direktiven für die Verwendung mit @Configuration-Klassen. Hier können wir die Basispakete angeben, die nach Spring-Komponenten durchsucht werden sollen.

  5. @Component: Gibt an, dass eine annotierte Klasse eine „Komponente“ ist. Solche Klassen gelten als Kandidaten für die automatische Erkennung bei der Verwendung von annotationsbasierten Konfigurationen und Classpath-Scans.

  6. @PropertySource: Bietet einen einfachen deklarativen Mechanismus zum Hinzufügen einer Property-Quelle zur Spring-Umgebung. Es gibt eine ähnliche Annotation zum Hinzufügen eines Arrays von Property-Quelldateien, nämlich @PropertySources.

  7. @Service: Gibt an, dass eine annotierte Klasse ein „Service“ ist. Diese Annotation dient als Spezialisierung von @Component und ermöglicht die automatische Erkennung von Implementierungsklassen durch Klassenpfadscans.

  8. @Repository: Gibt an, dass eine annotierte Klasse ein „Repository“ ist. Diese Annotation dient als Spezialisierung von @Component und ist ratsam für die Verwendung mit DAO-Klassen.

  9. @Autowired: Die Spring @Autowired-Annotation wird für die automatische Injektion von Beans verwendet. Die Spring-@Qualifier-Annotation wird in Verbindung mit Autowired verwendet, um Verwirrung zu vermeiden, wenn zwei oder mehr Beans für denselben Typ konfiguriert sind.

Spring MVC-Annotationen

Einige der wichtigen Spring MVC-Annotationen sind:

  1. @Controller
  2. @RequestMapping
  3. @PathVariable
  4. @RequestParam
  5. @ModelAttribute
  6. @RequestBody und @ResponseBody
  7. @RequestHeader und @ResponseHeader

Weitere Informationen dazu finden Sie unter Spring MVC Tutorial.

Spring Transaction Management Annotations

@Transactional ist die spring deklarative Transaktionsmanagement-Annotation, lesen Sie mehr unter Spring MVC Hibernate.

Spring Security Annotations

@EnableWebSecurity wird mit der @Configuration-Klasse verwendet, um die Spring Security-Konfiguration zu definieren. Weitere Informationen finden Sie unter Spring Security Beispiel.

Spring Boot Annotationen

  1. @SpringBootApplication
  2. @EnableAutoConfiguration

Lesen Sie mehr unter Spring Boot Beispiel.

Spring Annotationen Beispiel

Lassen Sie uns ein einfaches Beispiel betrachten, in dem wir Spring-Annotationen in unserer Anwendung verwenden. Das folgende Bild veranschaulicht mein Spring-Annotationen Beispielprojekt.

Spring Framework-Abhängigkeiten

I have created the maven project and added Spring Core Framework dependencies.

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

Dies zieht alle Spring-Core-JARs für unser Projekt herunter.

Komponentenklassen

Der nächste Schritt besteht darin, Komponentenklassen zu erstellen. Hier ahme ich mehrere Datenbankkomponenten nach, eine für MySQL und eine für Oracle. 

package com.journaldev.drivers;

public interface DataBaseDriver {
    public String getInfo();
}

DataBaseDriver ist das Basisschnittstellen, 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 "[ Driver: mySql" +
                ", databaseName: " + databaseName +
                ", disableStatementPooling: " + disableStatementPooling +
                " ]";
    }
}

Beachten Sie die Verwendung der Annotation @Component, um dem Spring-Framework anzuzeigen, dass diese Klasse als Komponente behandelt werden soll. Wir verwenden auch die Annotationen @PropertySource und @Value. Das Spring-Framework verwendet diese zur Laufzeit, um diese Variablenwerte aus der angegebenen Eigenschaftsdatei zu injizieren und festzulegen. Im Folgenden sind die in der Datei mysqldatabase.properties deklarierten Eigenschaften aufgeführt. 

databaseName=school
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 "[ Driver: Oracle" +
                ", url: " + url +
                ", port; " + port +
                ", user: " + user +
                ", password: " + password  +
                ", driver: " + driver +
                " ] ";
    }
}

OracleDriver ist eine einfache Bean. Wir werden eine Serviceklasse verwenden, um Eigenschaften in diese Bean einzufügen.

Spring Service Klasse

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 Annotation @Service, um dem Spring-Framework anzuzeigen, dass es sich um eine Serviceklasse handelt. Dann verwenden wir die Annotationen @Autowired und @Qualifier("oracleDriver"), um dem Spring-Framework mitzuteilen, dass die Bean mit dem Namen oracleDriver an das Klassenattribut dataBaseDriver injiziert werden soll. Beachten Sie, dass wir diese Spring-Bean noch nicht erstellt haben.

Spring Beans

Der letzte Schritt besteht darin, unsere Spring-Beans und Konfigurationsklassen zu erstellen, um alles zu verbinden. 

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 Datei oracledatabase.properties, die von Spring-Framework der Variablen environment zugewiesen werden. Hier sind die in der Datei oracledatabase.properties definierten Eigenschaften.

db.url=localhost
db.port=4444
db.user=vasiliy
db.password=yilisav
db.driver=driver_name

Unser Beispielprojekt für Frühlingsannotationen ist bereit zum Testen. Zusammenfassend haben wir folgende Schritte ausgeführt:

  1. Ein Maven-Projekt erstellt und erforderliche Frühlingsabhängigkeiten hinzugefügt.
  2. Komponentenklassen erstellt und Eigenschaften aus einer Ressourcendatei in ihre Variable eingefügt.
  3. Wenn wir eine Komponente von Drittanbietern haben, können wir die Serviceklasse verwenden, um Abhängigkeiten in sie einzufügen. Genau wie wir es für OracleDriver über die UserService-Klasse getan haben.
  4. Zuletzt haben wir eine Konfigurationsklasse erstellt, um Frühlingsbohnen zu definieren und das Basispaket festzulegen, das für die Suche nach Frühlingskomponentenklassen und deren Konfiguration gescannt werden soll.

Frühlingsannotationsbeispieltest

Hier ist unsere Hauptklasse, um unser Frühlingsannotationsbeispielprojekt 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 driver info:");
        System.out.println(oracle.getInfo());
        
        System.out.println("MySQL driver info:");
        System.out.println(mysql.getInfo());

        System.out.println("UserService Information");
	UserService userService = appContext.getBean(UserService.class);
	System.out.println(userService.getDriverInfo());

	appContext.close();
	}
}

Das folgende Bild zeigt die erzeugte Ausgabe. Beachten Sie, dass wir kein Protokollierungsframework konfiguriert haben, sodass alle Protokollierungen des Frühlingsframeworks in roter Farbe in die Konsole gedruckt werden. Das ist alles für eine kurze Einführung in Frühlingsannotationen. Ich habe hier die meisten wichtigen Annotationen aufgelistet, aber es gibt noch viele weitere für spezifische Aufgaben. Sie können mein Frühlingsannotationsbeispielprojekt über den untenstehenden Link herunterladen.

Herunterladen Sie das Beispielprojekt für Frühjahrsannotationen

Referenz: API-Dokumentation

Source:
https://www.digitalocean.com/community/tutorials/spring-annotations