Dévoilement du fonctionnement interne de Spring AOP

Dans cet article, nous démystifierons les mécanismes internes de la programmation orientée aspect (AOP) au printemps. L'accent sera mis sur la compréhension de la manière dont AOP réalise des fonctionnalités telles que la journalisation, souvent considérée comme une forme de « magie ». En parcourant une implémentation de base de Java, nous verrons en quoi tout dépend de la réflexion, des modèles de proxy et des annotations de Java plutôt que de quelque chose de vraiment magique.

Conditions préalables

• API Java Core Proxy
• API de réflexion
• API d'annotations

Ceux-ci font tous partie des packages java.lang.reflect,java.lang.annotation et javassist.util.proxy.

Le mécanisme de base

Au cœur de Spring AOP se trouve le concept d'objets proxy, d'intercepteurs de méthodes et de réflexion. L'acteur clé de ce modèle est le MethodHandler (ou gestionnaire d'invocation). Ce gestionnaire contrôle le comportement de l'objet proxy en interceptant les appels de méthode. Lorsqu'une méthode est invoquée sur le proxy, elle est transmise via le gestionnaire, où les annotations peuvent être introspectées via la réflexion. Sur la base des annotations appliquées, la logique nécessaire (par exemple, la journalisation) peut être exécutée avant, après ou en cas d'exception.

Le décomposer

1. Objets proxy : Ce sont des objets créés dynamiquement qui remplacent vos objets métier réels, acheminant les appels de méthode via le gestionnaire de méthode.
2. Gestionnaires d'invocation : C'est là que la magie de l'interception opère. Grâce à la réflexion, le gestionnaire peut examiner les annotations présentes sur la méthode cible et modifier le comportement en conséquence.
3. Annotations personnalisées : Vous pouvez définir des annotations personnalisées, qui servent de marqueurs pour déclencher des fonctionnalités supplémentaires telles que la journalisation, les contrôles de sécurité ou la gestion des transactions.

Exemple : Supposons que nous souhaitions ajouter une journalisation avant et après certaines exécutions de méthodes. Au lieu de coder en dur la journalisation partout, nous pouvons annoter les méthodes avec @BeforeMethod et @AfterMethod. Notre gestionnaire inspecte la méthode de cette annotation et ajoute dynamiquement la logique de journalisation appropriée.

Vous trouverez ci-dessous les classes à quoi ressemblent le contrôleur et le service pour notre exemple.

WorkerController.java

package edu.pk.poc.aop.controller;

import edu.pk.poc.aop.annotation.AfterMethod;
import edu.pk.poc.aop.annotation.All;
import edu.pk.poc.aop.annotation.BeforeMethod;
import edu.pk.poc.aop.helper.ProxyFactory;
import edu.pk.poc.aop.service.Worker;
import edu.pk.poc.aop.service.WorkerService;
import edu.pk.poc.aop.service.WorkerServiceImpl;

public class WorkerController {
    WorkerService workerService = ProxyFactory.createProxy(WorkerServiceImpl.class);
    /**
     * This Method 1s annotated with @BeforeMethod and @AfterMethod, So the log statements
     * will be generated before and after method call.
     */
    @BeforeMethod
    @AfterMethod
    public void engageFullTimeWorker() throws Exception {
        Worker fullTimeWorker = new Worker();
        fullTimeWorker.setName("FullTime-Worker");
        fullTimeWorker.setPartTime(false);
        fullTimeWorker.setDuration(9);
        workerService.doWork(fullTimeWorker);
    }
    /**
     * This Method is annotated with @All, So the log statements will be generated before and after method call
     * along with exception if raised.
     */
    @All
    public void engagePartTimeWorker() throws Exception {
        Worker partTimeWorker = new Worker();
        partTimeWorker.setName("PartTime-Worker");
        partTimeWorker.setPartTime(true);
        partTimeWorker.setDuration(4);
        workerService.doWork(partTimeWorker);
    }
}

WorkerServiceImpl.java

package edu.pk.poc.aop.service;

import edu.pk.poc.aop.annotation.AfterMethod;

public class WorkerServiceImpl implements WorkerService {
    /**
     * Here this method is annotated with only @AfterMethod, So only log statement
     * will be generated after method call
     */
    @AfterMethod
    @Override
    public void doWork(Worker worker) throws Exception {
        if (worker.isPartTime()) {
            throw new Exception("Part time workers are not permitted to work.");
        }
        System.out.print("A full time worker is working for " + worker.getDuration() + " hours :: ");
        for (int i = 1; i < worker.getDuration(); i++) {
            System.out.print("* ");
        }
        System.out.println();
    }
}

Classe de test Main.java

package edu.pk.poc.aop.test;

import edu.pk.poc.aop.controller.WorkerController;
import edu.pk.poc.aop.helper.ProxyFactory;
import edu.pk.util.Logger;

public class Main {
    public static void main(String[] args) {
        WorkerController controller = ProxyFactory.createProxy(WorkerController.class);
        Logger logger = new Logger();
        try {
            System.out.println("Testing @BeforeMethod and @AfterMethod");
            System.out.println("-----------------------------------------");
            controller.engageFullTimeWorker();
            System.out.println("Testing @All");
            System.out.println("-----------------------------------------");
            controller.engagePartTimeWorker();
        } catch (Exception e) {
            logger.error("Exception caught in Main class");
        }
    }
}

Sortie

Testing @BeforeMethod and @AfterMethod
-----------------------------------------
>>> Entering into edu.pk.poc.aop.controller.WorkerController.engageFullTimeWorker()
A full time worker is working for 9 hours :: * * * * * * * * 
>>> Exiting from edu.pk.poc.aop.service.WorkerServiceImpl.doWork()
>>> Exiting from edu.pk.poc.aop.controller.WorkerController.engageFullTimeWorker()
Testing @All
-----------------------------------------
>>> Entering into edu.pk.poc.aop.controller.WorkerController.engagePartTimeWorker()
>>> Exception in edu.pk.poc.aop.controller.WorkerController.engagePartTimeWorker()
Exception caught in Main class

Comment ça marche

Lorsqu'une méthode est invoquée sur un objet proxy, l'appel est intercepté par le gestionnaire, qui utilise la réflexion pour inspecter toutes les annotations sur la méthode cible. Sur la base de ces annotations, le gestionnaire décide s'il doit enregistrer l'entrée/sortie de la méthode, enregistrer les exceptions ou ignorer complètement la journalisation.

Voici comment vous pouvez le visualiser :

• Avant l'exécution : entrée de la méthode de journalisation.
• Après l'exécution : journaliser la sortie ou le succès de la méthode.
• Tous : enregistre l'entrée de la méthode, l'entrée de la méthode et l'exception si elle est déclenchée. Ce comportement dynamique montre que Spring AOP exploite les API Java de base plutôt que d'utiliser une astuce magique.

Définir les annotations

package edu.pk.poc.aop.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface AfterMethod {

}

package edu.pk.poc.aop.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface BeforeMethod {

}

package edu.pk.poc.aop.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface All {

}

Définir Proxy Factory

package edu.pk.poc.aop.helper;

/**
 * The {@code ProxyFactory} class is responsible for creating proxy objects using the Javassist library.
 * It allows for dynamic generation of proxies for classes or interfaces, with support for method interception.
 */
public class ProxyFactory {

    /**
     * A Javassist ProxyFactory instance used to generate proxy classes.
     */
    private static final javassist.util.proxy.ProxyFactory factory = new javassist.util.proxy.ProxyFactory();

    /**
     * Creates a proxy object for the given class or interface.
     * If the class is an interface, the proxy implements the interface.
     * If it's a concrete class, the proxy extends the class.
     *
     * @param <T>   the type of the class or interface for which the proxy is to be created
     * @param klass the {@code Class} object representing the class or interface to proxy
     * @return a proxy instance of the specified class or interface, or {@code null} if proxy creation fails
     */
    public static <T> T createProxy(Class<T> klass) {
        if (klass.isInterface())
            factory.setInterfaces(new Class[]{klass});
        else
            factory.setSuperclass(klass);
        try {
            return (T) factory.create(new Class<?>[0], new Object[0], new AOPLoggingMethodHandler());
        } catch (Exception e) {
            System.err.println(e.getMessage());
        }
        return null;
    }
}

Définir MethodHandler

package edu.pk.poc.aop.helper;

import edu.pk.poc.aop.annotation.AfterMethod;
import edu.pk.poc.aop.annotation.All;
import edu.pk.poc.aop.annotation.BeforeMethod;
import edu.pk.poc.aop.annotation.OnException;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;

import edu.pk.util.Logger;
import javassist.util.proxy.MethodHandler;

public class AOPLoggingMethodHandler implements MethodHandler {

    private static final Logger logger = new Logger();

    public Object invoke(Object self, Method thisMethod, Method proceed, Object[] args) throws Throwable {
        if (proceed != null) { // Concrete Method
            Object result = null;
            String className = resolveClassName(self);
            try {
                if (isAnnotationPresent(thisMethod, BeforeMethod.class) || isAnnotationPresent(thisMethod, All.class)) {
                    logger.info(">>> Entering into " + className + "." + thisMethod.getName() + "()");
                }
                result = proceed.invoke(self, args);
                if (isAnnotationPresent(thisMethod, AfterMethod.class) || isAnnotationPresent(thisMethod, All.class)) {
                    logger.info(">>> Exiting from " + className + "." + thisMethod.getName() + "()");
                }
            } catch (Throwable t) {
                if (isAnnotationPresent(thisMethod, OnException.class) || isAnnotationPresent(thisMethod, All.class)) {
                    logger.error(">>> Exception in " + className + "." + thisMethod.getName() + "()");
                }
                throw t;
            }
            return result;
        }
        throw new RuntimeException("Method is Abstract");
    }

    private boolean isAnnotationPresent(Method method, Class klass) {
        Annotation[] declaredAnnotationsByType = method.getAnnotationsByType(klass);
        return declaredAnnotationsByType != null && declaredAnnotationsByType.length > 0;
    }

    private String resolveClassName(Object self) {
        String className = self.getClass().getName();
        if (className.contains("_$$")) {
            className = className.substring(0, className.indexOf("_$$"));
        }
        return className;
    }
}

Conclusion

Spring AOP est un outil puissant pour des problématiques transversales, mais il n’apporte rien de révolutionnaire. Il repose sur des concepts Java fondamentaux tels que la réflexion et les proxys, qui sont disponibles dans le langage lui-même. En comprenant cela, vous pourrez mieux comprendre comment Spring simplifie ces mécanismes de niveau inférieur pour le confort des développeurs.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!