TOC

Spring Bean-Anmerkungen

Spring Bean-Anmerkungen

1. Überblick

In diesem Artikel werden die meistencommon Spring bean annotationserläutert, die zum Definieren verschiedener Bohnensorten verwendet werden.

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

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

2. Komponenten-Scannen

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

@ComponentScan konfiguriert, welchepackages to scan for classes with annotation configuration. Wir können die Namen der Basispakete direkt mit einem der ArgumentebasePackages odervalueangeben (value ist ein Alias ​​fürbasePackages): 

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

Außerdem können wir mit dem ArgumentbasePackageClassesauf 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 Anmerkungen versehene Klasse@ComponentScanvorhanden ist.

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

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

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

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

Beiusing XML configuration ist das Konfigurieren des Komponenten-Scannens genauso einfach:

3. @Component

@Component ist eine Annotation auf Klassenebene. Während des Komponentenscans werdenSpring Framework automatically detects classes annotated with @Component.

Zum Beispiel: 

@Component
class CarUtility {
    // ...
}

Standardmäßig haben die Bean-Instanzen dieser Klasse denselben Namen wie der Klassenname mit einer Initiale in Kleinbuchstaben. Darüber hinaus können wir mit dem optionalen Argumentvaluedieser Annotation einen anderen Namen angeben.

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

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 ist, dassit has automatic persistence exception translation enabled. Bei Verwendung eines Persistenz-Frameworks wie Hibernate werden native Ausnahmen, die in mit@Repository versehenen Klassen ausgelöst werden, automatisch in Unterklassen vonDataAccessExeption von Spring übersetzt.

To enable exception translation, wir müssen unsere eigenePersistenceExceptionTranslationPostProcessor 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

Diebusiness logic einer Anwendung befinden 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 alscontroller in Spring MVC dient: 

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

7. @Configuration

Configuration Klassen könnencontain bean definition methods mit@Bean kommentiert werden: 

@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 mit einem bestimmten Stereotyp abzielt.

Angenommen, wir möchten die Ausführungszeit von Methoden aus der DAO-Schicht messen. Wir erstellen den folgenden Aspekt (unter Verwendung von AspectJ-Annotationen) unter Ausnutzung des Stereotyps von@Repository: 

@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 diesem Beispiel haben wir einen Pointcut erstellt, der allen Methoden in Klassen entspricht, die mit@Repository versehen sind. Wir haben den Rat von@Aroundverwendet, um dann auf diesen Pointcut abzuzielen und die Ausführungszeit der abgefangenen Methodenaufrufe zu bestimmen.

Mit diesem Ansatz können wir jeder Anwendungsebene Protokollierungs-, Leistungsmanagement-, Audit- oder andere Verhaltensweisen hinzufügen.

9. Fazit

In diesem Artikel haben wir die Spring-Stereotypanmerkungen untersucht und erfahren, welche Art von Semantik diese jeweils darstellen.

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

Schließlich - wir haben gesehen, wie diese Anmerkungenlead to a clean, layered design und Trennung zwischen den Anliegen einer Anwendung. Sie verkleinern auch die Konfiguration, da wir Beans nicht mehr explizit manuell definieren müssen.

Wie üblich sind die Beispiele inover on GitHub verfügbar.

Related