public void createOrder(String item) {
    long start = System.currentTimeMillis();                       // ← 公共功能：计时
    System.out.println("[日志] createOrder 开始");                  // ← 公共功能：日志
 
    System.out.println("创建订单：" + item);                        // 真正的业务逻辑，只有这一行
 
    System.out.println("[日志] createOrder 结束");                  // ← 公共功能：日志
    System.out.println("[耗时] " + (System.currentTimeMillis() - start) + "ms"); // ← 公共功能
}

<dependencies>
    <!-- Spring 核心容器（内含 spring-aop 模块） -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>6.2.2</version>
    </dependency>
 
    <!-- 切入点表达式的解析依赖 AspectJ -->
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.22</version>
    </dependency>
</dependencies>

package com.infinitescope.aop.service;
 
import org.springframework.stereotype.Component;
 
@Component
public class OrderService {
 
    public void createOrder(String item) {
        System.out.println("   >> 业务方法：创建订单 " + item);
    }
 
    public String getOrderStatus(int id) {
        System.out.println("   >> 业务方法：查询订单 " + id);
        return "订单" + id + "：已支付";
    }
 
    public void pay(int id) {
        System.out.println("   >> 业务方法：支付订单 " + id);
        if (id < 0) {
            throw new RuntimeException("订单号非法：" + id);
        }
    }
}

package com.infinitescope.aop.advice;
 
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
 
@Component      // 交给 Spring 管理
@Aspect         // 声明这是一个切面类
public class LogAdvice {
 
    @Pointcut("execution(* com.infinitescope.aop.service.*.*(..))")
    public void pt() {}     // 切入点：service 包下所有类的所有方法
 
    @Before("pt()")         // 通知：在目标方法执行前运行
    public void before() {
        System.out.println("【前置通知】方法即将执行");
    }
}

package com.infinitescope.aop.config;
 
import org.springframework.context.annotation.*;
 
@Configuration
@ComponentScan("com.infinitescope.aop")
@EnableAspectJAutoProxy     // 开启 Spring 对 AOP 注解的支持
public class SpringConfig {
}

public class Main {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        OrderService service = ctx.getBean(OrderService.class);
        service.createOrder("《Spring实战》");
    }
}

【前置通知】方法即将执行
   >> 业务方法：创建订单 《Spring实战》

execution(访问修饰符? 返回值类型 包名.类名.方法名(参数类型) 异常?)  // ?表示可无参数

// 1. 精确匹配：service 包下 OrderService 的 createOrder(String) 方法
execution(void com.infinitescope.aop.service.OrderService.createOrder(String))
 
// 2. 匹配 service 包（单层）下所有类的所有方法
execution(* com.infinitescope.aop.service.*.*(..))
 
// 3. 匹配 service 包及其所有子包（.. 表示多级）
execution(* com.infinitescope.aop.service..*.*(..))
 
// 4. 匹配任意包下的 OrderService
execution(* *..OrderService.*(..))
 
// 5. 匹配无参方法
execution(* com.infinitescope.aop.service.OrderService.getOrderStatus())

@Pointcut("@annotation(com.infinitescope.aop.anno.Log)")  // 匹配标注了 @Log 注解的方法
@Pointcut("within(com.infinitescope.aop.service.*)")     // 匹配指定类（范围更粗）

@Component
@Aspect
public class AllAdvice {
 
    @Pointcut("execution(* com.infinitescope.aop.service.OrderService.*(..))")
    public void pt() {}
 
    @Before("pt()")
    public void before() {
        System.out.println("   1. @Before 前置通知");
    }
 
    @AfterReturning(value = "pt()", returning = "result")
    public void afterReturning(Object result) {
        System.out.println("   2. @AfterReturning 返回后通知，返回值=" + result);
    }
 
    @AfterThrowing(value = "pt()", throwing = "e")
    public void afterThrowing(Throwable e) {
        System.out.println("   3. @AfterThrowing 异常后通知，异常=" + e.getMessage());
    }
 
    @After("pt()")
    public void after() {
        System.out.println("   4. @After 最终通知");
    }
 
    @Around("pt()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("   0-A. @Around 前半段");
        Object result = pjp.proceed();     // 调用原始方法（必须！）
        System.out.println("   0-B. @Around 后半段");
        return result;                     // 必须返回原方法的返回值
    }
}

0-A. @Around 前半段
1. @Before 前置通知
   >> 业务方法：创建订单 《Spring实战》
2. @AfterReturning 返回后通知，返回值=null
4. @After 最终通知
0-B. @Around 后半段

0-A. @Around 前半段
1. @Before 前置通知
   >> 业务方法：查询订单 1
2. @AfterReturning 返回后通知，返回值=订单1：已支付
4. @After 最终通知
0-B. @Around 后半段

0-A. @Around 前半段
1. @Before 前置通知
   >> 业务方法：支付订单 -1
3. @AfterThrowing 异常后通知，异常=订单号非法：-1
4. @After 最终通知
调用方捕获：订单号非法：-1

@Around 前半段 → @Before → 目标方法 → @AfterReturning / @AfterThrowing → @After → @Around 后半段

@Before("pt()")
public void before(JoinPoint jp) {
    Object[] args = jp.getArgs();                 // 目标方法的参数
    String methodName = jp.getSignature().getName(); // 方法名
    System.out.println("   准备执行：" + methodName + "，参数=" + Arrays.toString(args));
}
 
@AfterReturning(value = "pt()", returning = "result")
public void afterReturning(Object result) {
    // returning = "result" 把返回值绑定到方法参数上
    System.out.println("   返回值=" + result);
}
 
@AfterThrowing(value = "pt()", throwing = "e")
public void afterThrowing(Throwable e) {
    // throwing = "e" 把异常绑定到方法参数上
    System.out.println("   异常=" + e.getMessage());
}

ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
OrderService service = ctx.getBean(OrderService.class);   // 看看拿到手的对象是什么
System.out.println("代理对象类型：" + service.getClass().getName());

代理对象类型：com.infinitescope.aop.service.OrderService$$SpringCGLIB$$0

@Component
public class OrderService {
    public void createOrder(String item) {
        this.pay(1);          // 注意：this 是目标对象，不是代理对象！
    }
}