Archives pour la catégorie AOP

Introduction à l’Aspect

Spring AOP et l’interception d’exceptions

Pour des besoins d’interception d’exceptions globales sur un package d’une application, Spring AOP (Aspect Oriented Programming) permet de mettre en place des tissages non pas dans le code écrit mais directement autour du byte code.

L’intérêt d’une telle solution est de ne pas toucher au code existant mais d' »envelopper » l’application avec du code additionnel qui sera déclenché sur certaines conditions.

Pour mettre en place une telle solution il est nécessaire :

  • de rajouter des dépendances dans le fichier pom.xml
  • de compléter le fichier de configuration Spring
  • de créer une classe qui sera responsable des traitements voulus

1. Ajout des dépendances pour Spring AOP

Ajouter les dependances suivantes dans le fichier pom.xml

<dependency>
<groupId>org.apache.tomcat</groupId>
<artifactId>catalina</artifactId>
</dependency>
<dependency>
<groupId>net.sf.ehcache</groupId>
<artifactId>ehcache-core</artifactId>
<scope>provided</scope>
 </dependency>
 <dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
<scope>provided</scope>
 </dependency>

2. Modifier la configuration Spring

Ajouter la configuration AOP dans le fichier de configuration Spring Xml

<!--************* Gestionnaire des aspects (AOP) *********************** -->
<aop:config>
    <aop:aspect id="loggingAspect" ref="rootErrorInterceptor">
        <aop:after-throwing method="afterThrowing" throwing="ex" pointcut="execution(* fr.appli.web.front.*.*(..))"/>
    </aop:aspect>
</aop:config>

<bean id="rootErrorInterceptor" class="fr.appli.web.front.it.intercepteurs.RootErrorInterceptor"/>
<!-- Fin de la configuration AOP -->

Dans cette configuration on stipule que :

  • L’identifiant de notre aspect est « loggingAspect »
  • Qu’il fait référence à un bean qui est nommé « rootErrorInterceptor »
  • Nous utilisons un déclencheur de type « aop:after-throwing ». On trouve d’autres types d’advice comme : Before, After, Throws et Around). Pour notre cas nous utilisons « Throws »
  • La méthode a invoquer est « afterThrowing » de notre bean « rootErrorInterceptor »
  • Il traite l’exception « ex » dans les paramètres de notre méthode
  • Le le champ d’application de notre tissage est l’espace de nommage « fr.appli.web.front.*.*(..) », ce qui veut dire que toute méthode et classe qui se trouve dans ce package sera concerné
  • La déclaration de notre bean « rootErrorInterceptor » qui va intercepter notre exception et la traiter
  • La classe qui est décrite par notre bean : « fr.appli.web.front.it.intercepteurs.RootErrorInterceptor »

3. Créer notre classe de traitement des exceptions

Créer une classe qui va effectuer certains traitement lorsque une exception du type défini dans les paramètres est interceptée. Ici nous traitons toutes les exceptions de type « Exception » mais on pourrait être plus précis et traiter que certaines exceptions précises. Toute fois, le fait de catcher les exceptions par l’AOP n’empêche pas la propagation des exceptions mais permet de faire un traitement particulier lors de la levée de ceux-ci.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.aop.ThrowsAdvice;
public class RootErrorInterceptor implements ThrowsAdvice {
 /** Le logger pour la classe RootErrorInterceptor */
 private static final Logger LOGGER = LoggerFactory.getLogger(RootErrorInterceptor.class);

/** La methode declenchee a la levee d une exception du type RuntimeException */
 public void afterThrowing(RuntimeException ex) {
 // Do something with remote exception
 LOGGER.error("Declenche sur la levée d'une exception de type Exception !");
 }
}
Publicités