你觉得 Spring AOP 晦涩，其实不是你理解能力的问题，而是大多数资料从“名词”讲起，而不是从“现实问题”讲起。我们换一个工程师视角来讲。
一、先忘掉 AOP 名词，我们先看一个真实痛点
你现在是 Java 后端，在写业务代码：
public void pay(Long orderId) {
checkParam(orderId);
log("start pay");
try {
doPay(orderId);
log("pay success");
} catch (Exception e) {
log("pay fail");
throw e;
}
}然后你还有：
public void refund(Long orderId) { ... }
public void cancel(Long orderId) { ... }
public void ship(Long orderId) { ... }
你发现 4 类代码在疯狂重复：
• 打日志
• 权限校验
• 事务
• 耗时统计
• 异常处理
你要么：
• 到处 copy paste 把日志权限的代码写在这里
• 要么 写工具方法，但每个方法都得手动调用
这就是 AOP 要解决的问题：
把“横着切”在所有业务里的通用逻辑，抽出去
二、AOP 到底是什么？
AOP 的原意：
Aspect Oriented Programming
面向“切面”的编程
但你可以把它理解成：
“在你代码运行时，偷偷帮你插代码”
你写的是：
orderService.pay(1L);
你真正执行的是：
开启事务
↓
权限校验
↓
orderService.pay(1L)
↓
记录日志
↓
提交事务
你没有在 pay() 里写这些，是Spring 在外面“包了一层”
三、AOP 的本质：代理
Spring AOP 底层只有一个东西：
代理对象（Proxy）
你注入的：
@Autowired
OrderService orderService;
它不是 OrderService
而是：OrderServiceProxy
结构是：
Controller
↓
OrderServiceProxy
↓
OrderService
四、切面（Aspect）是什么？
切面就是：
一组“我要在某些方法前后插入的逻辑”
例如一个日志切面：
@Aspect
@Component
public class LogAspect {
@Around("execution(* com.xxx.service..*(..))")
public Object log(ProceedingJoinPoint pjp) throws Throwable {
logStart();
Object result = pjp.proceed();
logEnd();
return result;
}
}
它说的是：所有 service 包下的方法
执行前后，我要包一层
五、切点（Pointcut）是什么？
切点 = 你要拦哪些方法
execution(* com.xxx.service..*(..))
意思是：
com.xxx.service 包下
所有类
所有方法
它解决的是：
“这刀切到哪里？”
六、通知（Advice）是什么？
通知就是：
你在那个位置要干什么
类型 含义
@Before 方法前
@After 方法后
@AfterReturning 成功后
@AfterThrowing 异常后
@Around 包住整个方法
⸻
七、JoinPoint 是什么？
JoinPoint = 被拦截的那个方法
你可以从它拿到：
• 方法名
• 参数
• 返回值
• 异常
⸻
八、为什么 Spring 事务能这么“自动”？
因为事务本身就是一个 AOP 切面
你写：
@Transactional
public void pay() {}
Spring 实际做的是：
给这个方法加了一个“事务切面”
在你方法外包了一层：
开启事务
→ 执行方法
→ 提交 / 回滚
⸻
九、为什么 AOP 常被误用？
因为它不是真正的“拦截一切”
它只拦：
通过 Spring 容器调用的方法
所以：
this.pay()
不会被 AOP 拦
⸻
十、用一句工程师能懂的话总结 AOP
AOP = 用代理对象，把你不想写在业务里的“脏活累活”，统一包在方法外面
你只写：
我想做什么
Spring 帮你包上：
怎么安全地做
⸻
如果你愿意，我可以下一步给你画一张：
“Spring Bean → 代理 → 切面 → 真实对象”的调用链图
你会瞬间理解 AOP 为什么既强大又容易踩坑。