В этом посте мы раскроем тайну внутренней механики аспектно-ориентированного программирования (АОП) в Spring. Основное внимание будет уделено пониманию того, как АОП реализует такие функции, как ведение журнала, которое часто считается формой «магии». Изучив базовую реализацию Java, мы увидим, что речь идет об отражениях Java, шаблонах прокси и аннотациях, а не о чем-то действительно волшебном.

Предварительные условия

• API прокси-сервера Java
• API отражения
• API аннотаций

Все это часть пакетов java.lang.reflect,java.lang.annotation и javassist.util.proxy.

Основной механизм

В основе Spring AOP лежит концепция прокси-объектов, перехватчиков методов и отражения. Ключевым игроком в этом шаблоне является MethodHandler (или обработчик вызова). Этот обработчик управляет поведением прокси-объекта, перехватывая вызовы методов. Когда метод вызывается на прокси-сервере, он передается через обработчик, где аннотации можно анализировать посредством отражения. На основе примененных аннотаций необходимая логика (например, ведение журнала) может выполняться до, после или в случае исключения.

Разрушение этого

1. Прокси-объекты: Это динамически создаваемые объекты, которые заменяют ваши реальные бизнес-объекты, маршрутизируя вызовы методов через обработчик метода.
2. Обработчики вызовов: Здесь происходит волшебство перехвата. Используя отражение, обработчик может проверять аннотации, присутствующие в целевом методе, и соответствующим образом изменять поведение.
3. Пользовательские аннотации: Вы можете определить собственные аннотации, которые будут служить маркерами для запуска дополнительных функций, таких как ведение журнала, проверки безопасности или управление транзакциями.

Пример: Предположим, мы хотим добавить ведение журнала до и после выполнения определенных методов. Вместо жесткого ведения журналов повсюду мы можем аннотировать методы с помощью @BeforeMethod и @AfterMethod. Наш обработчик проверяет метод для этой аннотации и динамически добавляет соответствующую логику журналирования.

Ниже приведены классы, как выглядят контроллер и служба для нашего примера.

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


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




Выход


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





  
  
  Как это работает


Когда метод вызывается для прокси-объекта, вызов перехватывается обработчиком, который использует отражение для проверки всех аннотаций в целевом методе. На основе этих аннотаций обработчик решает, следует ли регистрировать вход/выход метода, регистрировать исключения или вообще пропускать регистрацию.

Вот как это можно визуализировать:

• Перед выполнением: запись метода в журнал.
• После выполнения: Зарегистрируйте выход или успех метода.
• Все: запись метода в журнал, запись метода и исключение, если оно возникло. Такое динамическое поведение показывает, что Spring AOP использует основные API Java, а не применяет какой-то магический трюк.

Определить аннотации

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 {

}

Определить фабрику прокси

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

Определить обработчик метода

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

Заключение

Spring AOP — мощный инструмент для решения комплексных задач, но он не делает ничего революционного. Он построен на основных концепциях Java, таких как отражение и прокси, которые доступны в самом языке. Поняв это, вы сможете лучше понять, как Spring упрощает эти низкоуровневые механики для удобства разработчиков.