Anmerkungen zu Spring Bean

Dieser Artikel ist Teil einer Reihe: • Spring Core Annotations

• Spring Web Annotations

• Spring Boot-Anmerkungen

• Anmerkungen zur Frühlingsplanung

• Frühlingsdatenanmerkungen

• Spring Bean Annotations (aktueller Artikel)

1. Übersicht

In diesem Artikel werden die häufigsten Anmerkungen zu Spring Bean erläutert , mit denen verschiedene Arten von Beans definiert werden.

Es gibt verschiedene Möglichkeiten, Beans in einem Spring-Container zu konfigurieren. Wir können sie mithilfe der XML-Konfiguration deklarieren. Wir können Beans mithilfe der Annotation @Bean in einer Konfigurationsklasse deklarieren .

Oder wir können die Klasse mit einer der Anmerkungen aus dem Paket org.springframework.stereotype markieren und den Rest dem Scannen von Komponenten überlassen.

2. Scannen von Komponenten

Spring kann ein Paket automatisch nach Beans durchsuchen, wenn das Scannen von Komponenten aktiviert ist.

@ComponentScan konfiguriert, welche Pakete mit Annotationskonfiguration nach Klassen durchsucht werden sollen . Wir können die Namen der Basispakete direkt mit einem der basePackages- oder value- Argumente angeben ( value ist ein Alias ​​für basePackages ):

@Configuration @ComponentScan(basePackages = "com.baeldung.annotations") class VehicleFactoryConfig {}

Außerdem können wir mit dem Argument basePackageClasses auf Klassen in den Basispaketen verweisen :

@Configuration @ComponentScan(basePackageClasses = VehicleFactoryConfig.class) class VehicleFactoryConfig {}

Beide Argumente sind Arrays, sodass wir für jedes mehrere Pakete bereitstellen können.

Wenn kein Argument angegeben wird, erfolgt das Scannen aus demselben Paket, in dem die mit Annotationen versehene Klasse @ComponentScan vorhanden ist.

@ComponentScan nutzt die Funktion zum Wiederholen von Anmerkungen in Java 8, sodass wir eine Klasse mehrmals damit markieren können:

@Configuration @ComponentScan(basePackages = "com.baeldung.annotations") @ComponentScan(basePackageClasses = VehicleFactoryConfig.class) class VehicleFactoryConfig {}

Alternativ können wir @ComponentScans verwenden , um mehrere @ ComponentScan- Konfigurationen anzugeben :

@Configuration @ComponentScans({ @ComponentScan(basePackages = "com.baeldung.annotations"), @ComponentScan(basePackageClasses = VehicleFactoryConfig.class) }) class VehicleFactoryConfig {}

Bei Verwendung der XML-Konfiguration ist das Konfigurieren des Komponenten-Scannens genauso einfach:

3. @Component

@Component ist eine Annotation auf Klassenebene. Während des Komponentenscans erkennt Spring Framework automatisch mit @Component kommentierte Klassen .

Zum Beispiel:

@Component class CarUtility { // ... }

Standardmäßig haben die Bean-Instanzen dieser Klasse denselben Namen wie der Klassenname mit einer Initiale in Kleinbuchstaben. Hinzu kommt, dass, können wir einen anderen Namen mit dem optionalen angeben Wert Argumente dieser Anmerkung.

Da @Repository , @Service , @Configuration und @Controller alle Meta-Annotationen von @Component sind , haben sie dasselbe Bean-Namensverhalten. Außerdem nimmt Spring sie während des Scannens der Komponenten automatisch auf.

4. @Repository

DAO- oder Repository-Klassen stellen normalerweise die Datenbankzugriffsschicht in einer Anwendung dar und sollten mit @Repository versehen werden:

@Repository class VehicleRepository { // ... }

Ein Vorteil der Verwendung dieser Anmerkung besteht darin, dass die automatische Übersetzung von Persistenzausnahmen aktiviert ist . Bei Verwendung eines Persistenzframeworks wie Hibernate werden native Ausnahmen, die in mit @Repository kommentierten Klassen ausgelöst werden, automatisch in Unterklassen von Spring's DataAccessExeption übersetzt .

Um die Ausnahmeübersetzung zu aktivieren , müssen wir unsere eigene PersistenceExceptionTranslationPostProcessor- Bean deklarieren :

@Bean public PersistenceExceptionTranslationPostProcessor exceptionTranslation() { return new PersistenceExceptionTranslationPostProcessor(); }

Beachten Sie, dass Spring in den meisten Fällen den obigen Schritt automatisch ausführt.

Oder über die XML-Konfiguration:

5. @Service

Die Geschäftslogik einer Anwendung befindet sich normalerweise in der Service-Schicht. Daher verwenden wir die Annotation @Service, um anzugeben, dass eine Klasse zu dieser Schicht gehört:

@Service public class VehicleService { // ... }

6. @Controller

@Controller ist eine Annotation auf Klassenebene, die dem Spring Framework mitteilt, dass diese Klasse in Spring MVC als Controller dient :

@Controller public class VehicleController { // ... }

7. @Konfiguration

Konfigurationsklassen können Bean-Definitionsmethoden enthalten, die mit @Bean kommentiert sind :

@Configuration class VehicleFactoryConfig { @Bean Engine engine() { return new Engine(); } }

8. Stereotype Annotations und AOP

Wenn wir Spring-Stereotyp-Annotationen verwenden, ist es einfach, einen Pointcut zu erstellen, der auf alle Klassen abzielt, die ein bestimmtes Stereotyp haben.

For example, suppose we want to measure the execution time of methods from the DAO layer. We'll create the following aspect (using AspectJ annotations) taking advantage of @Repository stereotype:

@Aspect @Component public class PerformanceAspect { @Pointcut("within(@org.springframework.stereotype.Repository *)") public void repositoryClassMethods() {}; @Around("repositoryClassMethods()") public Object measureMethodExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable { long start = System.nanoTime(); Object returnValue = joinPoint.proceed(); long end = System.nanoTime(); String methodName = joinPoint.getSignature().getName(); System.out.println( "Execution of " + methodName + " took " + TimeUnit.NANOSECONDS.toMillis(end - start) + " ms"); return returnValue; } }

In this example, we created a pointcut that matches all methods in classes annotated with @Repository. We used the @Around advice to then target that pointcut and determine the execution time of the intercepted methods calls.

Using this approach, we may add logging, performance management, audit, or other behaviors to each application layer.

9. Conclusion

In this article, we have examined the Spring stereotype annotations and learned what type of semantics these each represent.

Wir haben auch gelernt, wie Sie mithilfe des Komponentenscans dem Container mitteilen, wo sich mit Anmerkungen versehene Klassen befinden.

Schließlich haben wir gesehen, wie diese Anmerkungen zu einem sauberen, geschichteten Design und einer Trennung zwischen den Anliegen einer Anwendung führen. Sie verkleinern auch die Konfiguration, da Beans nicht mehr explizit manuell definiert werden müssen.

Wie üblich sind die Beispiele auf GitHub verfügbar.

« Vorherige Frühlingsdatenanmerkungen