Annotations de Spring Bean

Cet article fait partie d'une série: • Annotations Spring Core

• Annotations Web de printemps

• Annotations Spring Boot

• Annotations de planification du printemps

• Annotations de données Spring

• Annotations Spring Bean (article actuel)

1. Vue d'ensemble

Dans cet article, nous discuterons des annotations de bean Spring les plus courantes utilisées pour définir différents types de beans.

Il existe plusieurs façons de configurer des beans dans un conteneur Spring. Nous pouvons les déclarer en utilisant la configuration XML. Nous pouvons déclarer des beans en utilisant l' annotation @Bean dans une classe de configuration.

Ou nous pouvons marquer la classe avec l'une des annotations du package org.springframework.stereotype et laisser le reste à l'analyse des composants.

2. Analyse des composants

Spring peut analyser automatiquement un package pour les beans si l'analyse des composants est activée.

@ComponentScan configure les packages à rechercher pour les classes avec la configuration d'annotations . Nous pouvons spécifier les noms de paquets de base directement avec l' un des basePackages ou la valeur des arguments ( valeur est un alias pour basePackages ):

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

De plus, nous pouvons pointer vers des classes dans les packages de base avec l' argument basePackageClasses :

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

Les deux arguments sont des tableaux afin que nous puissions fournir plusieurs packages pour chacun.

Si aucun argument n'est spécifié, l'analyse s'effectue à partir du même package où la classe annotée @ComponentScan est présente.

@ComponentScan exploite la fonction d'annotations répétitives de Java 8, ce qui signifie que nous pouvons marquer une classe avec elle plusieurs fois:

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

Alternativement, nous pouvons utiliser @ComponentScans pour spécifier plusieurs configurations @ComponentScan :

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

Lors de l' utilisation de la configuration XML , la configuration de l'analyse des composants est tout aussi simple:

3. @Composant

@Component est une annotation de niveau classe. Lors de l'analyse des composants, Spring Framework détecte automatiquement les classes annotées avec @Component .

Par exemple:

@Component class CarUtility { // ... }

Par défaut, les instances de bean de cette classe ont le même nom que le nom de classe avec une initiale minuscule. En plus de cela, nous pouvons spécifier un nom différent en utilisant l' argument valeur facultative de cette annotation.

Puisque @Repository , @Service , @Configuration et @Controller sont tous des méta-annotations de @Component , ils partagent le même comportement de dénomination de bean. De plus, Spring les récupère automatiquement pendant le processus de numérisation des composants.

4. @Repository

Les classes DAO ou Repository représentent généralement la couche d'accès à la base de données dans une application et doivent être annotées avec @Repository:

@Repository class VehicleRepository { // ... }

L'un des avantages de l'utilisation de cette annotation est qu'elle a activé la traduction automatique des exceptions de persistance . Lors de l'utilisation d'un framework de persistance tel que Hibernate, les exceptions natives lancées dans les classes annotées avec @Repository seront automatiquement traduites en sous-classes de DataAccessExeption de Spring .

Pour activer la traduction d'exceptions , nous devons déclarer notre propre bean PersistenceExceptionTranslationPostProcessor :

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

Notez que dans la plupart des cas, Spring effectue automatiquement l'étape ci-dessus.

Ou, via la configuration XML:

5. @Service

La logique métier d'une application réside généralement dans la couche de service - nous allons donc utiliser l' annotation @Service pour indiquer qu'une classe appartient à cette couche:

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

6. @Controller

@Controller est une annotation au niveau de la classe qui indique au Spring Framework que cette classe sert de contrôleur dans Spring MVC :

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

7. @Configuration

Les classes de configuration peuvent contenir des méthodes de définition de bean annotées avec @Bean :

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

8. Annotations stéréotypées et AOP

Lorsque nous utilisons des annotations de stéréotype Spring, il est facile de créer un pointcut qui cible toutes les classes ayant un stéréotype particulier.

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.

Nous avons également appris à utiliser l'analyse des composants pour indiquer au conteneur où trouver les classes annotées.

Enfin - nous avons vu comment ces annotations conduisent à une conception propre et en couches et à une séparation entre les préoccupations d'une application. Ils réduisent également la configuration, car nous n'avons plus besoin de définir explicitement les beans manuellement.

Comme d'habitude, les exemples sont disponibles à l'adresse over sur GitHub.

« Annotations de données de printemps précédentes