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

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.

L'AOP (« Aspect Oriented Programming » ou « Programmation Orientée 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.

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és transversales » 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
}

• 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.

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▲

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

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

}

V-B. Les annotations AspectJ▲

V-C. Syntaxe AspectJ▲

V-D. Exemple avec les loggers▲

[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>

@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);
    }
}

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

/**
 * An aspect class for logging all routes
 *
 * @author Gokan EKINCI
 */
@Component
@Aspect
@Log
public class RestLogAspect {

    @Pointcut("@annotation(org.springframework.web.bind.annotation.RequestMapping)")
    public void restAnnotation() {}

    @Around("restAnnotation() && execution(* *(..))")
    public Object restLog(ProceedingJoinPoint joinPoint) throws Throwable {
        final MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        final Method method = signature.getMethod();

        final Class<?> controllerClass = joinPoint.getTarget().getClass();
        final RequestMapping controllerAnnotation = controllerClass.getAnnotation(RequestMapping.class);
        final String controllerRestPath = (controllerAnnotation.path().length == 0) ? "" : controllerAnnotation.path()[0];

        final RequestMapping controllerMethodAnnotation = method.getAnnotation(RequestMapping.class);
        final String methodRestPath = (controllerMethodAnnotation.path().length == 0) ? "" : controllerMethodAnnotation.path()[0];
        final RequestMethod requestMethod = (controllerMethodAnnotation.method().length == 0) ? RequestMethod.GET : controllerMethodAnnotation.method()[0];

        final Instant start = Instant.now();

        // @Before code
        Object returnValue = null;
        Throwable throwable = null;
        try {
            returnValue = joinPoint.proceed();
        } catch (Throwable throwable1) {
            throwable = throwable1;
            log.warning(String.format("[RestLogAspect] : %s", throwable1.getMessage()));
        }
        // @After code

        final String logMessage = String.format("[REST][%sms][%s][%s][%s][%s()] %s",
            Duration.between(start, Instant.now()).toMillis(),
            controllerClass.getSimpleName(),
            requestMethod,
            controllerRestPath + methodRestPath,
            method.getName(),
            Arrays.stream(joinPoint.getArgs())
                    .map(argument -> (argument != null) ? argument.toString() : "null")
                    .collect(Collectors.joining(", "))
        );

        log.info(logMessage);

        if (throwable != null) {
            throw throwable;
        }

        return returnValue;
    }}

Je tiens à remercier ClaudeLeloup et -FloT- pour la relecture orthographique.