Aspect-Oriented Programming trong Spring

01-aop-proxy/
  pom.xml                       parent Boot 4.1.1, starter aspectj, test
  src/main/java/dev/canhdominich/boot/aop/
    AopApplication.java         @SpringBootApplication
    Events.java                 ghi lại các sự kiện theo thứ tự
    Audited.java                annotation đánh dấu phương thức cần ghi kiểm toán
    OrderService.java           lớp có phương thức public, @Audited, gọi nội bộ, final và private
    PriceCalculator.java, PricingService.java   interface và cài đặt để so proxy JDK với CGLIB
    LoggingAspect.java          @Around, @Before, @AfterReturning, @After (thứ tự 2)
    OuterAspect.java            aspect bên ngoài (thứ tự 1)
    AopDemo.java                chạy mọi thí nghiệm

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>4.1.1</version>
        <relativePath/>
    </parent>

    <groupId>dev.canhdominich.javabackend</groupId>
    <artifactId>aop-proxy</artifactId>
    <version>1.0.0</version>
    <name>AOP - Aspect va proxy</name>

    <properties>
        <java.version>17</java.version>
        <main.class>dev.canhdominich.boot.aop.AopDemo</main.class>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aspectj</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <configuration>
                    <executable>java</executable>
                    <arguments>
                        <argument>-classpath</argument>
                        <classpath/>
                        <argument>${main.class}</argument>
                    </arguments>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

package dev.canhdominich.boot.aop;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public final class Events {

    private static final List<String> LOG = Collections.synchronizedList(new ArrayList<>());

    private Events() {
    }

    public static void record(String event) {
        LOG.add(event);
    }

    public static void clear() {
        LOG.clear();
    }

    public static List<String> all() {
        synchronized (LOG) {
            return new ArrayList<>(LOG);
        }
    }
}

package dev.canhdominich.boot.aop;

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 Audited {
}

package dev.canhdominich.boot.aop;

import org.springframework.stereotype.Service;

@Service
public class OrderService {

    private final String prefix;

    public OrderService() {
        this.prefix = String.valueOf("order-");
    }

    @Audited
    public String place(String item) {
        Events.record("body: place " + item);
        return secret(item);
    }

    public String cancel(String item) {
        Events.record("body: cancel " + item);
        return "cancelled " + item;
    }

    public String outer(String item) {
        Events.record("body: outer " + item);
        return this.place(item);
    }

    public final String receipt(String item) {
        Events.record("body: receipt " + item);
        return prefix + item;
    }

    private String secret(String item) {
        Events.record("body: private secret " + item);
        return prefix + item;
    }
}

package dev.canhdominich.boot.aop;

public interface PriceCalculator {

    int priceOf(String item);
}

package dev.canhdominich.boot.aop;

import org.springframework.stereotype.Service;

@Service
public class PricingService implements PriceCalculator {

    @Override
    public int priceOf(String item) {
        return item.length() * 1000;
    }
}

package dev.canhdominich.boot.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Aspect
@Component
@Order(2)
public class LoggingAspect {

    @Around("execution(public * dev.canhdominich.boot.aop.OrderService.*(..))")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        Events.record("around: before " + point.getSignature().getName());
        try {
            return point.proceed();
        } finally {
            Events.record("around: after " + point.getSignature().getName());
        }
    }

    @Before("@annotation(audited)")
    public void audit(JoinPoint point, Audited audited) {
        Events.record("before (audited): " + point.getSignature().getName());
    }

    @AfterReturning(pointcut = "@annotation(Audited)", returning = "result")
    public void returned(JoinPoint point, Object result) {
        Events.record("after returning: " + point.getSignature().getName() + " -> " + result);
    }

    @After("@annotation(Audited)")
    public void finished(JoinPoint point) {
        Events.record("after (finally): " + point.getSignature().getName());
    }

    @Before("execution(* dev.canhdominich.boot.aop.PricingService.priceOf(..))")
    public void priced(JoinPoint point) {
        Events.record("before: priceOf");
    }
}

package dev.canhdominich.boot.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Aspect
@Component
@Order(1)
public class OuterAspect {

    @Around("execution(* dev.canhdominich.boot.aop.OrderService.cancel(..))")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        Events.record("outer aspect: before " + point.getSignature().getName());
        try {
            return point.proceed();
        } finally {
            Events.record("outer aspect: after " + point.getSignature().getName());
        }
    }
}

package dev.canhdominich.boot.aop;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class AopApplication {

    public static void main(String[] args) {
        SpringApplication.run(AopApplication.class, args);
    }
}

package dev.canhdominich.boot.aop;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.springframework.aop.support.AopUtils;
import org.springframework.boot.SpringApplication;
import org.springframework.context.ConfigurableApplicationContext;

public class AopDemo {

    public static void main(String[] args) {
        run();
    }

    public static List<String> run() {
        List<String> lines = new ArrayList<>();
        SpringApplication application = new SpringApplication(AopApplication.class);
        application.setDefaultProperties(Map.of("spring.main.web-application-type", "none", "spring.main.banner-mode", "off", "logging.level.root", "OFF"));
        try (ConfigurableApplicationContext context = application.run()) {
            OrderService orders = context.getBean(OrderService.class);
            PriceCalculator prices = context.getBean(PriceCalculator.class);
            lines.add("-- what the beans really are");
            lines.add("OrderService class: " + describe(orders));
            lines.add("PriceCalculator class: " + describe(prices));
            lines.add("-- advice around a public method with @Audited");
            lines.addAll(trace("place", () -> orders.place("book")));
            lines.add("-- a public method without @Audited");
            lines.addAll(trace("cancel", () -> orders.cancel("book")));
            lines.add("-- a method that calls another through this");
            lines.addAll(trace("outer", () -> orders.outer("book")));
            lines.add("-- a final method");
            lines.addAll(trace("receipt", () -> orders.receipt("book")));
            lines.add("-- an interface-based bean that an aspect advises");
            lines.addAll(trace("priceOf", () -> String.valueOf(prices.priceOf("book"))));
        }
        lines.add("-- the same beans with spring.aop.proxy-target-class=false");
        SpringApplication jdk = new SpringApplication(AopApplication.class);
        jdk.setDefaultProperties(Map.of("spring.main.web-application-type", "none", "spring.main.banner-mode", "off", "logging.level.root", "OFF", "spring.aop.proxy-target-class", "false"));
        try (ConfigurableApplicationContext context = jdk.run()) {
            lines.add("PriceCalculator class: " + describe(context.getBean(PriceCalculator.class)));
            lines.add("OrderService class (no interface): " + describe(context.getBean(OrderService.class)));
            lines.addAll(trace("priceOf", () -> String.valueOf(context.getBean(PriceCalculator.class).priceOf("book"))));
            try {
                context.getBean(PricingService.class);
                lines.add("getBean(PricingService.class): found");
            } catch (RuntimeException e) {
                lines.add("getBean(PricingService.class): " + e.getClass().getSimpleName());
            }
        }
        lines.forEach(System.out::println);
        return lines;
    }

    private static String describe(Object bean) {
        String name = bean.getClass().getSimpleName();
        String kind = AopUtils.isCglibProxy(bean) ? "CGLIB proxy" : AopUtils.isJdkDynamicProxy(bean) ? "JDK dynamic proxy" : "not a proxy";
        return name.replaceAll("\\$Proxy\\d+", "\\$Proxy<n>") + " (" + kind + ", target " + AopUtils.getTargetClass(bean).getSimpleName() + ")";
    }

    private static List<String> trace(String label, java.util.function.Supplier<String> call) {
        Events.clear();
        String result = call.get();
        List<String> lines = new ArrayList<>();
        lines.add(label + " returned " + result);
        Events.all().forEach(event -> lines.add("    " + event));
        return lines;
    }
}

-- what the beans really are
OrderService class: OrderService$$SpringCGLIB$$0 (CGLIB proxy, target OrderService)
PriceCalculator class: PricingService$$SpringCGLIB$$0 (CGLIB proxy, target PricingService)
-- advice around a public method with @Audited
place returned order-book
    around: before place
    before (audited): place
    body: place book
    body: private secret book
    after returning: place -> order-book
    after (finally): place
    around: after place
-- a public method without @Audited
cancel returned cancelled book
    outer aspect: before cancel
    around: before cancel
    body: cancel book
    around: after cancel
    outer aspect: after cancel
-- a method that calls another through this
outer returned order-book
    around: before outer
    body: outer book
    body: place book
    body: private secret book
    around: after outer
-- a final method
receipt returned nullbook
    body: receipt book
-- an interface-based bean that an aspect advises
priceOf returned 4000
    before: priceOf
-- the same beans with spring.aop.proxy-target-class=false
PriceCalculator class: $Proxy<n> (JDK dynamic proxy, target PricingService)
OrderService class (no interface): OrderService$$SpringCGLIB$$0 (CGLIB proxy, target OrderService)
priceOf returned 4000
    before: priceOf
getBean(PricingService.class): NoSuchBeanDefinitionException