Annotations de haricots printaniers

Annotations de haricots de printemps

1. Vue d'ensemble

Dans cet article, nous discuterons descommon Spring bean annotationsles plus utilisés 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 packageorg.springframework.stereotype et laisser le reste à l'analyse des composants.

2. Analyse des composants

Spring peut automatiquement rechercher des beans dans un paquet si l'analyse de composant est activée.

@ComponentScan configure quelspackages to scan for classes with annotation configuration. Nous pouvons spécifier les noms des packages de base directement avec l'un des argumentsbasePackages ouvalue (value est un alias pourbasePackages):

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

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

@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étées de Java 8, ce qui signifie que nous pouvons marquer une classe avec elle plusieurs fois:

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

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

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

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

3. @Component

@Component est une annotation de niveau classe. Pendant le balayage des composants,Spring Framework automatically detects classes annotated with @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 la classe avec une initiale minuscule. En plus de cela, nous pouvons spécifier un nom différent en utilisant l'argument optionnelvalue 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 prend 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 queit has automatic persistence exception translation enabled. Lorsque vous utilisez 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 desDataAccessExeption de Spring.

To enable exception translation, nous devons déclarer notre propre beanPersistenceExceptionTranslationPostProcessor:

@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

Lebusiness logic 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 decontroller in Spring MVC:

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

7. @Configuration

Les classesConfiguration peuventcontain bean definition methods 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 une coupe de point qui cible toutes les classes ayant un stéréotype particulier.

Par exemple, supposons que nous voulions mesurer le temps d'exécution des méthodes de la couche DAO. Nous allons créer l'aspect suivant (en utilisant les annotations AspectJ) en tirant parti du stéréotype@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;
    }
}

Dans cet exemple, nous avons créé un pointcut qui correspond à toutes les méthodes des classes annotées avec@Repository. Nous avons utilisé les conseils de@Aroundpour ensuite cibler ce point de coupe et déterminer le temps d'exécution des appels de méthodes interceptés.

En utilisant cette approche, nous pouvons ajouter des comportements de journalisation, de gestion des performances, d'audit ou autres à chaque couche d'application.

9. Conclusion

Dans cet article, nous avons examiné les annotations de stéréotypes de Spring et appris quel type de sémantique chacune représente.

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

Enfin - nous avons vu comment ces annotationslead to a clean, layered design et la séparation entre les préoccupations d'une application. Ils rendent également la configuration plus petite, car nous n'avons plus besoin de définir explicitement les beans manuellement.

Comme d'habitude, les exemples sont disponiblesover on GitHub.

TOC