In diesem Beitrag werden wir die internen Mechanismen der aspektorientierten Programmierung (AOP) im Frühjahr entmystifizieren. Der Schwerpunkt liegt auf dem Verständnis, wie AOP Funktionen wie die Protokollierung erreicht, die oft als eine Form von „Magie“ angesehen werden. Beim Durchgehen einer Kern-Java-Implementierung werden wir sehen, dass es eher um die Reflektion, Proxy-Muster und Annotationen von Java geht als um irgendetwas wirklich Magisches.

Voraussetzungen

• Java Core Proxy API
• Reflection-API
• Annotation API

Diese sind alle Teil der Pakete java.lang.reflect, java.lang.annotation und javassist.util.proxy.

Der Kernmechanismus

Das Herzstück von Spring AOP ist das Konzept von Proxy-Objekten, Methoden-Interceptoren und Reflexion. Der Schlüsselspieler in diesem Muster ist der MethodHandler (oder Aufrufhandler). Dieser Handler steuert das Verhalten des Proxy-Objekts, indem er Methodenaufrufe abfängt. Wenn eine Methode auf dem Proxy aufgerufen wird, wird sie durch den Handler geleitet, wo Anmerkungen per Reflektion überprüft werden können. Basierend auf den angewendeten Annotationen kann die erforderliche Logik (z. B. Protokollierung) vor, nach oder bei einer Ausnahme ausgeführt werden.

Aufschlüsseln

1. Proxy-Objekte: Dabei handelt es sich um dynamisch erstellte Objekte, die Ihre tatsächlichen Geschäftsobjekte ersetzen und Methodenaufrufe über den Methodenhandler weiterleiten.
2. Aufruf-Handler: Hier geschieht die Magie des Abfangens. Mithilfe von Reflektion kann der Handler die in der Zielmethode vorhandenen Anmerkungen untersuchen und das Verhalten entsprechend ändern.
3. Benutzerdefinierte Anmerkungen: Sie können benutzerdefinierte Anmerkungen definieren, die als Markierungen dienen, um zusätzliche Funktionen wie Protokollierung, Sicherheitsprüfungen oder Transaktionsverwaltung auszulösen.

Beispiel: Angenommen, wir möchten die Protokollierung vor und nach bestimmten Methodenausführungen hinzufügen. Anstatt die Protokollierung überall fest zu codieren, können wir Methoden mit @BeforeMethod und @AfterMethod mit Anmerkungen versehen. Unser Handler überprüft die Methode für diese Annotation und fügt dynamisch die entsprechende Protokollierungslogik hinzu.

Unten sind die Klassen aufgeführt, wie der Controller und der Dienst für unser Beispiel aussehen.

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 



Main.java-Testklasse


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




Ausgabe


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





  
  
  Wie es funktioniert


Wenn eine Methode für ein Proxy-Objekt aufgerufen wird, wird der Aufruf vom Handler abgefangen, der mithilfe von Reflektion alle Anmerkungen zur Zielmethode überprüft. Basierend auf diesen Anmerkungen entscheidet der Handler, ob er den Ein-/Ausstieg der Methode protokolliert, Ausnahmen protokolliert oder die Protokollierung ganz überspringt.

So können Sie es visualisieren:

• Vor der Ausführung: Methodeneintrag protokollieren.
• Nach der Ausführung: Beenden oder Erfolg der Methode protokollieren.
• Alle: Methodeneintrag protokollieren, Methodeneintrag und bei Ausnahme, falls ausgelöst. Dieses dynamische Verhalten zeigt, dass Spring AOP die Kern-Java-APIs nutzt, anstatt einen magischen Trick anzuwenden.

Anmerkungen definieren

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 {

}

Proxy-Factory definieren

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    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 createProxy(Class 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;
    }
}

MethodHandler definieren

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

Abschluss

Spring AOP ist ein leistungsstarkes Tool für übergreifende Anliegen, aber es bewirkt nichts Revolutionäres. Es basiert auf zentralen Java-Konzepten wie Reflektion und Proxys, die in der Sprache selbst verfügbar sind. Wenn Sie dies verstehen, können Sie besser verstehen, wie Spring diese Mechaniken auf niedrigerer Ebene zur Vereinfachung für Entwickler vereinfacht.