Tutoriel pour découvrir la Programmation Orientée Aspect avec Spring AOP

Gokan EKINCI

Ce tutoriel s'adresse aux développeurs qui souhaitent découvrir la Programmation Orientée Aspect grâce au framework Spring

Commentez

- Titre : Tutoriel pour découvrir la Programmation Orientée Aspect avec Spring AOP

- Auteur : Gokan EKINCI

- Parution : 21 janvier 2018

- Mise à jour : 18 novembre 2018

- Public visé :

- Licence : Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright ® 2017 Gokan EKINCI. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. Prérequis

- II. Qu'est-ce que l'AOP ?

- III. Dans quel contexte utilise-t-on l'AOP ?

- IV. Quelques dates sur l'AOP

- V. AspectJ avec Spring

- V-A. Dépendances Maven

- V-B. Les annotations AspectJ

- V-C. Syntaxe AspectJ

- V-D. Exemple avec les loggers

- VI. Remerciements

I - Prérequis

Vous pouvez utiliser l'IDE que vous souhaitez pour suivre ce tutoriel. Le code source des exemples présentés dans ce tutoriel est disponible dans ce repository Git, et plus particulièrement dans cette classe.

Les outils dont vous aurez besoin pour suivre ce tutoriel sont : JDK 8 d'Oracle, Maven 3.

N'hésitez pas à lire le tutoriel Maven 3 si vous souhaitez en apprendre plus sur ce dernier.

II - Qu'est-ce que l'AOP ?

L'AOP (Aspect Oriented Programming ou « Programmation Orienté Aspect » en français) n'est pas à proprement parler un langage de programmation pour créer des programmes, c'est un concept qui permet d'exécuter une action lorsqu'un événement est déclenché (ex: une méthode qui est exécutée). On peut donc voir l'AOP comme une extension au langage de programmation utilisé dans le projet.

III - Dans quel contexte utilise-t-on l'AOP ?

Lorsque l'on programme par aspect, on distingue le code métier du code technique. L'AOP permet de factoriser le code technique du projet. Le terme crosscutting concerns (ou fonctionnalité transversale en français) est utilisé pour désigner cette partie technique.

Pour citer quelques exemples de crosscutting concerns, l'AOP peut être utilisé pour :

- Ouvrir/fermer des ressources (ex: Démarrer et commiter/rollbacker une transaction)

- Vérifier les permissions de l'utilisateur (sécurité)

- Du cache

- Des loggers

- Du monitoring

- Des benchmarks

- Interrompre une méthode qui prend beaucoup de temps pour s'exécuter.

- Dans une moindre mesure : Changer le comportement d'une méthode pour retourner un nouveau résultat.

Voici un exemple de code sans l'AOP :

public void addPermissionsToUser(Permission[] permissions, User user)
throws SQLException {

try {
// Code technique : SI aucune transaction n'est en cours ALORS
// Code technique :     créer la transaction (cf: START TRANSACTION en SQL)
// Code technique : FIN SI
// Code métier    : Ajouter des droits à l'utilisateur
} catch (SQLException e) {
// Code technique : SI une exception est lancée ALORS
// Code technique :     rollbacker
// Code technique :     propager l'exception
// Code technique : FIN SI
} finally {
// Code technique : SI une exception n'est pas lancée ET la méthode courante est la dernière méthode transactionnelle exécutée ALORS
// Code technique :     commiter
// Code technique : FIN SI
}
}

Voici un exemple de code avec l'AOP :

@Transactional
public void addPermissionsToUser(Permission[] permissions, User user) {
// Code métier : Ajouter des droits à l'utilisateur
}

IV - Quelques dates sur l'AOP

- Juillet 1996 : La première apparition de l'AOP est attribuée à MTS (Microsoft Transaction Service) avec Windows NT 4.0, pour avoir mis en place un système d'interception pour les transactions et la sécurité.

- L'AOP en Java avec AspectJ :

- 1997 : Le projet AspectJ est créé par Gregor Kiczales et ses collègues, alors employés de la société Xerox PARC.

- 2001 : Une première version publique est publiée.

- Décembre 2002 : Le projet est confié à la fondation Eclipse.

- 20 décembre 2005 : L'introduction des annotations dans Java 5 (4 octobre 2004) permet au projet AspectJ 5 d'avoir une nouvelle syntaxe à base d'annotations. Il est alors possible d'inclure du code AspectJ directement dans du code Java.

- Le framework Spring intègre le concept d'AOP avec AspectJ, mais ce dernier limite les possibilités d'AspectJ à l'exécution des méthodes publiques.

V - AspectJ avec Spring

Il existe deux moyens pour mettre en place l'AOP avec AspectJ :

- En incluant directement les concepts AspectJ dans du code Java, votre code Java sera alors présent dans un fichier d'extension « .aj » et vous aurez besoin d'un plugin qui permettra à votre IDE de comprendre la syntaxe.

- En utilisant des annotations Java.

Dans ce tutoriel nous verrons la deuxième solution.

V-A - Dépendances Maven

Ajoutez la dépendance ci-dessous dans votre pom.xml :

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

Utilisez l'annotation @EnableAspectJAutoProxy pour activer l'AOP. Vous pouvez placer cette annotation sur votre classe main, ou bien créer une classe de configuration comme ci-dessous :

// Cette classe de configuration permet d'activer les aspects
// Vous pouvez la laisser vide
@Configuration
@EnableAspectJAutoProxy
public class AspectConfig {

}

V-B - Les annotations AspectJ

@Pointcut

Crée un alias pour une portion de condition(s)

@Before

S'exécute AVANT la méthode appelée. La méthode peut prendre en paramètre un JoinPoint.

@After

Similaire à @Before mais s'exécute APRÈS la méthode appelée. Peut prendre en paramètre un JoinPoint.

@Around

S'exécute lorsqu'une méthode est appelée, permet d'exécuter du code avant et après l'exécution de la méthode appelée (comme les filtres web). La méthode peut prendre en paramètre un ProceedingJoinPoint.

V-C - Syntaxe AspectJ

Il faut placer les exemples ci-dessous dans les annotations (au choix) : @Pointcut, @Before, @Around, ou @After.

Template

expression(<method scope> <return type> <fully qualified class name>.*(parameters))

Syntaxe représentant toutes les méthodes

execution(* *(..))

Syntaxe représentant toutes les méthodes ayant une annotation

@annotation(mypackage.MyAnnotation) && execution(* *(..))

V-D - Exemple avec les loggers

Créons une classe aspect « RestLogAspect » qui va afficher une ligne de log à chaque fois qu'une route, soit une méthode annotée avec @RequestMapping, de notre @RestController sera appelée.

Notre ligne de log aura le format suivant :

[REST][<durée-méthode-exécutée>ms][<nom-rest-contrôleur>][<nom-méthode-http>][<chemin-http>][<nom-méthode-contrôleur>()] <valeurs-des-paramètres>

Ainsi, l'exécution de la méthode sayHello() du contrôleur ci-dessous :

@RestController
public class HelloWorldController {

@RequestMapping(path = "/hello/{name}", method = RequestMethod.GET)
public ResponseEntity<String> sayHello(@PathVariable("name") String name) {
return new ResponseEntity<>("hello " + name, HttpStatus.OK);
}
}

… affichera ceci :

[REST][31ms][HelloWorldController][GET][/hello/{name}][sayHello()] world

Implémentation de notre classe (source) :

1. /**

2. * An aspect class for logging all routes

3. *

4. * @author Gokan EKINCI

5. */

6. @Component

7. @Aspect

8. @Log

9. public class RestLogAspect {

11. @Pointcut("@annotation(org.springframework.web.bind.annotation.RequestMapping)")

12. public void restAnnotation() {}

14. @Around("restAnnotation() && execution(* *(..))")

15. public Object restLog(ProceedingJoinPoint joinPoint) throws Throwable {

16. final MethodSignature signature = (MethodSignature) joinPoint.getSignature();

17. final Method method = signature.getMethod();

19. final Class<?> controllerClass = joinPoint.getTarget().getClass();

20. final RequestMapping controllerAnnotation = controllerClass.getAnnotation(RequestMapping.class);

21. final String controllerRestPath = (controllerAnnotation.path().length == 0) ? "" : controllerAnnotation.path()[0];

23. final RequestMapping controllerMethodAnnotation = method.getAnnotation(RequestMapping.class);

24. final String methodRestPath = (controllerMethodAnnotation.path().length == 0) ? "" : controllerMethodAnnotation.path()[0];

25. final RequestMethod requestMethod = (controllerMethodAnnotation.method().length == 0) ? RequestMethod.GET : controllerMethodAnnotation.method()[0];

27. final Instant start = Instant.now();

29. // @Before code

30. Object returnValue = null;

31. Throwable throwable = null;

32. try {

33. returnValue = joinPoint.proceed();

34. } catch (Throwable throwable1) {

35. throwable = throwable1;

36. log.warning(String.format("[RestLogAspect] : %s", throwable1.getMessage()));

37. }

38. // @After code

40. final String logMessage = String.format("[REST][%sms][%s][%s][%s][%s()] %s",

41. Duration.between(start, Instant.now()).toMillis(),

42. controllerClass.getSimpleName(),

43. requestMethod,

44. controllerRestPath + methodRestPath,

45. method.getName(),

46. Arrays.stream(joinPoint.getArgs())

47. .map(argument -> (argument != null) ? argument.toString() : "null")

48. .collect(Collectors.joining(", "))

49. );

51. log.info(logMessage);

53. if (throwable != null) {

54. throw throwable;

55. }

57. return returnValue;

58. }}

Ce qu'il faut retenir de cette implémentation :

1. Nous avons une classe annotée avec @Component et @Aspect pour indiquer à Spring que nous avons un bean de type aspect. L'annotation @Log est un simple utilitaire de librairie Lombok pour éviter de créer explicitement un attribut log de type Logger, n'en prenez pas compte.

2. Nous avons créé une méthode annotée avec @PointCut pour créer un alias « restAnnotation() », que nous utiliserons dans l'annotation @Around de la méthode aspect « restLog() ». Cette étape est facultative mais augmente la lisibilité de l'expression AspectJ utilisée dans l'annotation @Around.

3. Nous avons créé une méthode aspect restLog() annotée avec @Around, celle-ci va se déclencher lorsque l'expression indiquée dans l'annotation va matcher avec la méthode exécutée. Dans notre cas, lorsqu'une méthode annotée avec @RequestMapping va s'exécuter, notre méthode aspectrestLog()va s'exécuter aussi.

4. La méthode restLog() possède en paramètre le type ProceedingJoinPoint pour récupérer toutes les informations nécessaires par rapport à la méthode exécutée.

VI - Remerciements

Je tiens à remercier XXX pour la relecture technique et XXX pour la relecture orthographique.