Introduction à Spring AOP

1. Introduction

Dans ce didacticiel, nous présenterons AOP (Aspect Oriented Programming) avec Spring et commencerons à comprendre comment nous pouvons commencer à utiliser cet outil puissant dans des scénarios pratiques.

Il est également possible de tirer parti des annotations d'AspectJ lors du développement à l'aide de Spring AOP, mais dans cet article, nous nous concentrons sur la configuration de base basée sur XML Spring AOP.

2. Aperçu

AOP est un paradigme de programmation qui vise à accroître la modularité en permettant la séparation des préoccupations transversales. Il le fait en ajoutant un comportement supplémentaire au code existant sans modification du code lui-même.

Au lieu de cela, nous pouvons déclarer ce nouveau code et ces nouveaux comportements séparément.

Le cadre AOP de Spring nous aide à mettre en œuvre ces préoccupations transversales.

3. Dépendances de Maven

Commençons par ajouter la dépendance de la bibliothèque AOP de Spring dans le pom.xml :

 org.springframework.boot spring-boot-starter-parent 2.2.2.RELEASE    org.springframework.boot spring-boot-starter-aop  

La dernière version de la dépendance peut être vérifiée ici.

4. Concepts et terminologie de l'AOP

Passons brièvement en revue les concepts et la terminologie spécifiques à AOP:

4.1. Objet métier

Un objet métier est une classe normale qui a une logique métier normale. Regardons un exemple simple d'objet métier où nous ajoutons simplement deux nombres:

public class SampleAdder { public int add(int a, int b) { return a + b; } } 

Notez que cette classe est une classe normale avec une logique métier et sans annotations liées à Spring.

4.2. Aspect

Un aspect est une modularisation d'une préoccupation qui traverse plusieurs classes. L’exploitation unifiée peut être un exemple d’une telle préoccupation intersectorielle.

Voyons comment nous définissons un aspect simple:

public class AdderAfterReturnAspect { private Logger logger = LoggerFactory.getLogger(this.getClass()); public void afterReturn(Object returnValue) throws Throwable { logger.info("value return was {}", returnValue); } } 

Dans l'exemple ci-dessus, nous venons de définir une classe Java simple qui a une méthode appelée afterReturn qui prend un argument de type Object et qui se connecte simplement à cette valeur. Notez que même notre AdderAfterReturnAspect est une classe standard, sans annotations Spring.

Dans les sections suivantes, nous verrons comment nous pouvons câbler cet aspect à notre objet métier.

4.3. Joinpoint

Un Joinpoint est un point lors de l'exécution d'un programme, tel que l'exécution d'une méthode ou la gestion d'une exception.

Dans Spring AOP, un JoinPoint représente toujours une exécution de méthode.

4.4. Pointcut

Un Pointcut est un prédicat qui permet de faire correspondre un Conseil à appliquer par un Aspect à un JoinPoint particulier .

Le Conseil est souvent associé à une expression Pointcut et s'exécute à n'importe quel Joinpoint correspondant au Pointcut.

4.5. Conseil

Un conseil est une action entreprise par un aspect à un point de jonction particulier . Différents types de conseils comprennent les conseils «autour», «avant» et «après» .

Au printemps, un conseil est modélisé comme un intercepteur, maintenant une chaîne d'intercepteurs autour du point de jonction .

4.6. Câblage d'objet métier et d'aspect

Voyons comment nous pouvons câbler un objet Business à un aspect avec un conseil après retour.

Vous trouverez ci-dessous l'extrait de configuration que nous placerions dans une configuration Spring standard dans la balise «» :

Comme on peut le voir, nous avons défini un bean simple appelé simpleAdder qui représente une instance d'un objet métier. De plus, nous créons une instance d'un Aspect appelée AdderAfterReturnAspect .

XML n'est bien entendu pas notre seule option ici; comme mentionné précédemment, les annotations AspectJ sont également entièrement prises en charge.

4.7. Configuration en un coup d'œil

La balise aop: config est utilisée pour définir la configuration liée à AOP. Dans la balise config , nous définissons la classe qui représente un aspect. Nous lui avons donné une référence au bean aspect «doAfterReturningAspect» que nous avons créé.

Ensuite, nous définissons un Pointcut en utilisant la pointcut balise. Le raccourci utilisé dans l'exemple ci-dessus est l' exécution (* org.baeldung.logger.SampleAdder +. * (..)) ce qui signifie appliquer un conseil sur n'importe quelle méthode de la classe SampleAdder qui accepte n'importe quel nombre d'arguments et renvoie n'importe quel type de valeur.

Ensuite, nous définissons les conseils que nous voulons appliquer. Dans l'exemple ci-dessus, nous allons appliquer les conseils après-retour qui sont définis dans notre Aspect AdderAfterReturnAspect en exécutant la méthode nommée afterReturn définie à l'aide de la méthode d'attribut.

Ce conseil dans Aspect prend un paramètre de type Object. Le paramètre nous donne la possibilité d'effectuer une action avant et / ou après l'appel de la méthode cible. Dans ce cas, nous enregistrons simplement la valeur de retour de la méthode.

Spring AOP prend en charge plusieurs conseils en utilisant une configuration basée sur les annotations - cet exemple et d'autres peuvent être trouvés ici et ici.

5. Conclusion

Dans ce tutoriel, nous avons illustré les concepts utilisés dans AOP et un exemple d'utilisation du module AOP de Spring. Si vous souhaitez en savoir plus sur AOP, voici quelques ressources:

  • Une introduction à AspectJ
  • Implémentation d'une annotation Spring AOP personnalisée
  • Une introduction aux expressions ponctuelles au printemps
  • Comparaison de Spring AOP et AspectJ
  • Une introduction aux types de conseils au printemps

La mise en œuvre de ces exemples se trouve dans le projet GitHub - il s'agit d'un projet basé sur Maven, il devrait donc être facile à importer et à exécuter tel quel.