Introduction au printemps AOP

1. Introduction

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

Il est également possible d’utiliser le lien:/aspectj[annotations AspectJ]lors du développement à l’aide de Spring AOP, mais dans cet article, nous nous concentrons sur la configuration de base de Spring AOP XML.

2. Vue d’ensemble

AOP est un paradigme de programmation qui vise à augmenter la modularité en permettant la séparation des problèmes transversaux. ** 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 Maven

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

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.7.RELEASE<version>
</parent>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>
</dependencies>

La dernière version de la dépendance peut être vérifiée: https://search.maven.org/classic/#search%7Cga%7C1%7C%20(g%3A%22org.springframework.boot%22%20AND%20a%3A% 22spring-boot-starter-parent% 22)% 20OR% 20% 20 (g% 3A% 22org.springframework.boot% 22% 20and% 20a% 3a% 22% de démarrage-démarrage-démarreur% 22)% 20OR% 20% 20 ( g% 3A% 22org.springframework.boot% 22% 20and% 20a% 3A% 22spring-boot-starter-aop% 22)[ici].

4. Concepts et terminologie AOP

Passons brièvement en revue les concepts et la terminologie propres à l’AOP:

lien:/uploads/Program__Execution.jpg%201000w[]

4.1. Objet métier

Un objet métier est une classe normale ayant une logique métier normale.

Voyons un exemple simple d’objet métier dans lequel nous ajoutons simplement deux chiffres:

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 la modularisation d’une préoccupation qui concerne plusieurs classes. La journalisation unifiée peut être un exemple d’une telle préoccupation transversale.

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 comportant une méthode appelée afterReturn qui prend un argument de type Object et qui enregistre simplement cette valeur. Notez que même notre AdderAfterReturnAspect est une classe standard, exempte d’annotations Spring.

Dans les sections suivantes, nous verrons comment relier 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 le traitement 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 aide à faire correspondre un Conseil à appliquer par un Aspect à un JoinPoint particulier.

Advice 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 prise par un aspect à un Joinpoint particulier.

Les différents types de conseils incluent 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 joinpoint .

4.6. Objet métier et aspect de câblage

Voyons comment connecter un objet métier à un aspect avec un avis de retour.

Voici l’extrait de configuration que nous aurions placé dans une configuration standard de Spring dans la balise “<beans>” :

<bean id="sampleAdder" class="org.baeldung.logger.SampleAdder"/>
<bean id="doAfterReturningAspect"
  class="org.baeldung.logger.AdderAfterReturnAspect"/>
<aop:config>
    <aop:aspect id="aspects" ref="doAfterReturningAspect">
       <aop:pointcut id="pointCutAfterReturning" expression=
         "execution(**  org.baeldung.logger.SampleAdder+.** (..))"/>
       <aop:after-returning method="afterReturn"
         returning="returnValue" pointcut-ref="pointCutAfterReturning"/>
    </aop:aspect>
</aop:config>

Comme on peut le constater, nous avons défini un simple bean 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 sûr pas notre seule option ici; Comme mentionné précédemment, les annotations AspectJ sont également entièrement prises en charge.

4.7. Configuration en bref

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é la référence du bean aspect «doAfterReturningAspect» que nous avons créé.

Ensuite, nous définissons un pointcut en utilisant la balise pointcut . Le pointcut utilisé dans l’exemple ci-dessus est execution ( org.baeldung.logger.SampleAdder. (..)) , ce qui signifie appliquer un conseil sur toute méthode de la classe SampleAdder qui accepte un nombre quelconque d’arguments et renvoie tout type de valeur.

Ensuite, nous définissons quel conseil nous voulons appliquer. Dans l’exemple ci-dessus, nous allons appliquer le conseil après retour qui est défini dans notre Aspect AdderAfterReturnAspect en exécutant la méthode nommée afterReturn définie à l’aide de la méthode attribut

Cet avis dans Aspect prend un paramètre de type Object. Ce paramètre nous permet 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 des annotations - vous pouvez trouver cet exemple et plus encore. Link:/spring-aop-advice-tutorial[ici]et ici .

5. Conclusion

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

lien:/aspectj[Une introduction à AspectJ]
link:/spring-aop-annotation[Implémentation d’un AOP de ressort personnalisé

Annotation]** link:/spring-aop-pointcut-tutorial[Une introduction à Pointcut

Expressions au printemps]** lien:/spring-aop-vs-aspectj[Comparaison de Spring AOP et AspectJ]

link:/spring-aop-advice-adviceial[Introduction aux types de conseils dans

Printemps]

La mise en oeuvre de ces exemples est disponible à l’adresse the GitHub - il s’agit d’un projet basé sur Maven, il devrait donc être facile à importer et à courir comme est.

TOC