Technologies et Applications d'entreprise

Java/Jee XML Webservices SOA

Posted on by Rabii


On peut trouver beaucoup de tutoriaux de spring AOP avec l’exemple de logger.
Mais, quelque part,cette  exemple était peu déroutant pour les nouveaux arrivants. Alors, je vais vous présenter ici un exemple qui explique comment utiliser Spring AOP pour le profilage de temps d'exécution d’une fonction. L’exemple servira aussi pour  connaitre simplement le temps d’exécution de certains de vos fonctions si vous avez pas accées à JProfiler ou autres outils de profilage. Si vous voulez connaitre les principes fondamentaux de l’aop je vous invite à lire l’article : “AOP Concepts et implémentations

Utilisation de spring AOP pour profiler le temps d’exécution d’une fonction

L'exemple  est très simple - notre application a une classe métier avec une fonction implémentant le métier. Nous allons profiler le temps d’exécution de la fonction .
Le profilage (profiling) est un bon exemple pour les  préoccupation transversales de l’application.
L'utilisation de spring AOP est un bon choix pour l’implémenter. On verra par la suite étape par étape l’implémentation de notre exemple.

Environnement et structure de projet

Lancez votre IDE  préféré IDE (j'utilise Eclipse Helios) et Créer un nouveau projet Java. Et puis créer la structure comme indiqué ci-dessous.

Vous aurez besoin de télécharger tous les jar qui sont dans Referenced Libraries et les ajouter au classpath. Vous pouvez trouver ces jar ici: Spring, Commons-logging, aspectjrt, aspectjweaver. Aussi, noter que le fichier Metier.java est une interface.

Vous pouvez télécharger les sources de projet ici.

La Logique métier

Nous allons commencer par écrire notre logique métier et ensuite nous allons ajouter Spring AOP pour profiler notre fonction métier. Ouvrez l’interface Metier.java et copier le code ci-dessous :


package com.soat.spring.aop.demo;

public interface Metier {

void jeTravaille();

}

Maintenant, ouvrez le MetierImpl.java et copiez-y le code ci-dessous :

package com.soat.spring.aop.demo;

public class MetierImpl implements Metier {

public void jeTravaille() {

System.out.println("== Je commence le travaille ..");
try {
// traitements métiers
System.out.println(" .... traitements metiers .... ");
Thread.sleep(3500);
} catch (InterruptedException e) {
System.out.println("Erreur");
}
System.out.println("== Travaille finie");

}

}

Ce code est assez explicite. Notre méthode dort juste pour quelques  secondes et  affiche un texte sur la console.

Un aspect spring pour profiler notre fonction

Écrivons maintenant un aspect qui va profiler notre fonction “jeTravaille ()”. On va utiliser le greffon @ Autour ( advice en anaglais) (Perdu dans le jargon ? Spring AOP basics ). Ouvrez le fichier MetierProfiler .java et copiez y le code ci-dessous :


package com.soat.spring.aop.demo;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;

@Aspect
public class MetierProfiler {

        @Pointcut("execution(* com.soat.spring.aop.demo.*.*(..))")
        public void fonctionMetier() { }

        @Around("fonctionMetier()")
        public Object profile(ProceedingJoinPoint joinPoint) throws Throwable {
                long debut = System.currentTimeMillis();
                System.out.println("//Apelle de la fonction ...");
                Object sortie = joinPoint.proceed();
                System.out.println("//Fonction executee avec succees");
                long tempsPasse = System.currentTimeMillis() - debut;
                System.out.println("Temps d'exécution de la fonction: " + tempsPasse + " milliseconds.");
                return sortie;
        }

}

Voici ce que ce code fait :

  1. Utilisation de l’annotation @AspectJ pour  déclaré que cette classe est un aspect.
  2. En utilisant l'annotation @Pointcut, nous avons défini une “pointcut” qui correspondent à l'exécution de toutes les méthodes publiques appartenant au package com.soat.spring.aop.demo [ point de coupure]
  3. Utilisation de l’annotation  @Around pour définir un greffon qui sera appelée avant et après notre fonction métier. Le greffon @Around va envelopper notre fonction.

Configuration de Spring AOP et @AspectJ

Ouvrez le fichier applicationContext.xml et copiez le code ci-dessous :


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

        <!-- @AspectJ support -->
        <aop:aspectj-autoproxy />

        <bean id="MetierProfiler" />
        <bean id="classMetier" />
</beans>

&nbsp;

Voici ce que nous faisons dans le fichier XML ci-dessus:

  1. Nous avons ajouté les schémas AOP nécessaires  sur le haut du fichier XML.
  2. Utiliser <aop:aspectj-autoproxy />, nous avons activé le support @ AspectJ pour notre application.
  3. Et puis nous avons défini deux beans Spring normeaux - une pour notre classe métier et l'autre pour notre métier Profiler (c'est à dire notre aspect).

Félicitations nous avons finis ! A ce stade, nous avons ajouté avec succès Spring AOP à notre projet et nous l’avons configuré. Dans l'étape suivante, nous allons pouvoir tester notre code !

Testons notre Spring AOP profiler

Ouvrez le fichier et Test.java  et copiez y les lignes ci-dessous :


package com.soat.spring.aop.demo;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

        public static void main(String[] args) {
                ApplicationContext context = new ClassPathXmlApplicationContext(
                                "applicationContext.xml");
                Metier t1 = (Metier) context.getBean("classMetier");
                t1.jeTravaille();
        }

}

Dans le code ci-dessus nous chargeons notre bean Métier à partir du context spring, puis on apelle notre fonction. Si vous exécutez cette classe (Test.java) , on voit produire sur la console :


//Apelle de la fonction ...
==> Je commence le travaille ..
 .... traitements metiers ....
==> Travaille finie
//Fonction executee avec succees
Temps d'exécution de la fonction: 3502 milliseconds.

Spring AOP Flow - expliqué dans un diagramme de séquence

Conclusion

Spring Aop offre bien plus de fonctionnalités qui vous permettent de séparer tout les préoccupations transverses. On peut se préoccuper que de l'aspect  de l'application qui nous concerne, ce qui simplifie le travail, et permet d'augmenter la parallélisation du développement.

L’apprentissage de Spring Aop demande un certain temps mais le ROTI (Return Of Time Invested ) est considérable.
J'espère que ce tutoriel vous aide à comprendre les bases de la programmation Orientée Aspect Spring. Si vous avez des questions concernant n'hésitez pas à laisser un commentaire.

Posted on by Rabii | Posted in JEE | Tagged , ,


About Rabii

Ingénieur d'études et de développement chez "SOAT

2 Responses to Faites du profilage avec Spring AOP

  1. Stéphane says:


    on peut adapter ton exemple pour faire un framework maison de profilage !


  2. Jim says:


    Je te propose maven pour la gestion de dép


Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *