Introduction

L’AOP (programmation orientée aspect) ajoute des notions de transversalités qui ne sont pas disponibles dans la programmation orientée objet (POO). Cette transversalité est centrée sur les aspects permettant d’ajouter un traitement spécifique quand un type d’événement s’exécute sur un ensemble d’objets. Il est alors possible d’ajouter des préoccupations telles que la gestion des transactions qui est transverse à un ensemble d’objets. Spring utilise beaucoup l’AOP de façon transparente. Son utilisation dans nos projets est indépendante du noyau Spring. On n’ajoute la librairie Spring AOP que si elle est nécessaire.

Nous retrouvons souvent l’AOP dans les frameworks de nos clients. Elle est rarement utilisée pour le codage de règles métier car elle demande une conception particulière. Pour une fonctionnalité qui regroupe plusieurs entités on lui préfère généralement le copier/coller.

Plutôt que d’utiliser un design pattern proxy, nous utilisons, en général, le design pattern décorateur.

Décorateur :

Le design pattern décorateur est très bien en général car il permet de spécialiser des objets. Par contre, Java ne supporte pas l’héritage multiple et en diamant (sur les classes).

Il n’est pas possible d’hériter des variables de plusieurs classes. En revanche, l’héritage des méthodes de plusieurs interfaces est maintenant permis via les interfaces et les méthodes default.

Avant d’étudier l’AOP avec Spring, nous allons voir comment modifier des classes sans l’aide de Spring. Pour ce faire, nous pouvons utiliser les proxy.

Si vous souhaitez voir ce qui se passe derrière la scène, vous pouvez regarder les sources des JDK (https://github.com/openjdk/jdk).

Proxy :

Le design pattern proxy permet d’augmenter une ou plusieurs classes avec des méthodes et des attributs. Écrire un proxy à la main n’est pas facile mais cela reste possible pour une classe, grâce aux API d’introspection du package java.lang.reflect du JDK :

Méthode	Utilité
Proxy	Permet de créer des classes...

Pourquoi l’AOP

Nous verrons qu’il existe une librairie pour les utilisations simples et standards, et une librairie spécifique pour les utilisations avancées qui se base sur les annotations AspectJ.

Comme pour la configuration classique du contexte Spring, il est possible de définir des aspects sous la forme de fichiers XML ou d’annotations ou d’une composition des deux. Par exemple : la gestion des transactions est conduite par Spring via l’annotation @Transactional. Cette annotation est un aspect particulier géré directement par Spring.

Les aspects sont généralement mis dans le socle technique et répondent à des préoccupations comme par exemple l’instrumentation du code. Ils ne sont que très rarement exploités pour des préoccupations métier car ce type de programmation est complexe au niveau de la maintenance. Le code des traitements AOP doit donc être soigné et très bien commenté.

Les méthodes appelées via l’AOP sont généralement débrayables via la configuration avec des annotations @Conditional.

Les concepts d’AOP

Spring utilise la terminologie standard pour nommer ses éléments relatifs à l’AOP même si elle n’est pas très intuitive.

Définitions

Aspect : modularisation d’une préoccupation qui concerne un ensemble de classes de façon transverse.
Point de jonction (Joinpoint) : une étape au cours de l’exécution d’un programme, comme l’exécution d’une méthode ou le traitement d’une exception. Dans Spring AOP, un point de jonction représente toujours une exécution de méthode.
Greffon (Advice) : les actions d’interception prises par un aspect particulier à un point de jonction. Les différents types d’actions sont « autour », « avant » et « après ». Il est possible de chaîner ces intercepteurs.
Coupe (Pointcut) : un prédicat qui permet de sélectionner des points de jonction à travers une expression qui indique par exemple le nom d’une méthode. Spring utilise le langage de AspectJ par défaut.
Introduction (ou injection) : permet d’injecter dynamiquement des champs et des méthodes supplémentaires dans un objet. Spring AOP vous permet aussi d’introduire dynamiquement de nouvelles interfaces avec leurs implémentations. Une injection...

Limites de Spring AOP et utilisation d’AspectJ

Spring AOP se limite à l’exécution de méthodes sur des points de jonction, ce qui suffit dans une grande majorité des cas d’utilisation. L’interception sur le changement d’état des champs des objets n’est, par exemple, pas prise en compte. On utilisera plutôt directement AspectJ pour une utilisation avancée.

Le support @AspectJ dans Spring

Nous utilisons ce support pour réutiliser l’interprétation des annotations de AspectJ pour la recherche et la détection des méthodes candidates pour un aspect. Seul le support des annotations est utilisé. Spring n’utilise pas le tisseur d’aspect d’AspectJ.

Il est tout à fait possible d’utiliser AspectJ en conjonction avec Spring pour des cas complexes pour lesquels Spring ne suffirait pas.

1. Activation du support

La librairie AspectJ aspectjweaver.jar doit être dans le classpath.

<dependency> 
   <groupId>aopalliance</groupId> 
   <artifactId>aopalliance</artifactId> 
   <version>1.0</version> 
</dependency> 
<dependency> 
   <groupId>org.aspectj</groupId> 
   <artifactId>aspectjweaver</artifactId> 
   <version>1.9.9.1</version> 
</dependency>

2. Activation de @AspectJ avec configuration XML

Pour activer AspectJ support avec une configuration basée sur XML, il faut utiliser l’élément AOP aspectj-autoproxy.

Ajoutez cet élément dans la configuration et vérifiez qu’il y a bien la définition de l’AOP :

<beans default-lazy-init="true"  
xmlns="http://www.springframework.org/schema/beans"  
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
xmlns:context="http://www.springframework.org/schema/context"  
xmlns:jdbc="http://www.springframework.org/schema/jdbc" 
   xmlns:aop="http://www.springframework.org/schema/aop" 
   xsi:schemaLocation=" 
         http://www.springframework.org/schema/beans  
http://www.springframework.org/schema/beans/spring-beans-4.1.xsd 
         http://www.springframework.org/schema/jdbc  
http://www.springframework.org/schema/jdbc/spring-jdbc-4.1.xsd 
         http://www.springframework.org/schema/context  
http://www.springframework.org/schema/context/spring-context-4.1.xsd 
         http://www.springframework.org/schema/aop...

Les API bas niveau pour Spring AOP

Voici un exemple d’utilisation des API de bas niveau. Nous ne les montrerons pas toutes car elles sont très bien présentées dans la documentation Spring et nous ne nous en servirons que très rarement. Nous les mentionnons car elles permettent d’expérimenter les aspects très simplement.

1. L’interface PointCut

L’interface PointCut correspond à un point de coupe, qui permet grâce à une expression régulière d’identifier les méthodes qui seront interceptées.

class MonPointcut implements PointCut { 
   public ClassFilter getClassFilter() { 
      return null; 
   } 
   public MethodMatcher getMethodMatcher() { 
      return null; 
   }

Il y a deux méthodes dans l’interface :

Classe	Méthode	Utilité
ClassFilter	getClassFilter();	Filtre sur la classe.
MethodMatcher	getMethodMatcher();	Matcher sur la classe.

2. L’interface ClassFilter

L’interface ClassFilter ne contient qu’une méthode qui correspond à celle qui sera appelée lors de l’interception.

class MonClassFilter implements ClassFilter { 
   public boolean matches(Class<?> clazz) { 
      return...

Points clés

La programmation orientée aspect est souvent présente dans les socles logiciels.
Il est possible de coder simplement des aspects.
Si on retrouve une action sur un groupe de classes, il faut voir si on peut utiliser un aspect.
Les aspects sont déroutants, il faut bien les comprendre pour pouvoir corriger le code qui les utilise.

Programmation orientée aspect avec Spring