先说结论

Spring AOP 的本质是动态代理:容器里注入的其实是代理对象,代理在目标方法前后织入切面逻辑。由此推出一条铁律——所有 AOP/事务失效问题,十有八九是"调用没有经过代理对象"。掌握这条主线后,自调用失效、final 方法失效、private 方法失效这些"玄学"都能一秒定位。判断某段代码"注解为什么不生效",本质只问一个问题:这次调用从入口到目标方法的完整链路上,有没有一跳发生在代理对象身上? 只要有一跳绕开了代理,切面就在那一跳丢失。

两种代理的实现与选择

Spring AOP 有两套代理实现,由 DefaultAopProxyFactory 自动选择:

维度JDK 动态代理CGLIB
前提条件目标类实现了接口无接口要求
代理形态与目标实现同一接口的"兄弟类"目标类的子类
增强手段InvocationHandler 反射转发继承 + 方法重写
天然限制接口之外的方法不在代理范围final / private / static 方法不可重写
instanceof 表现instanceof 接口成立,instanceof 实现类不成立instanceof 目标类成立

proxyTargetClass = true 时强制走 CGLIB。注意 Spring Boot 2.0 起 spring.aop.proxy-target-class 默认为 true,所以 Spring Boot 项目里容器返回的通常是"目标类的子类",instanceof 目标类依然成立,但直接 new 出来的对象没有切面能力。两套代理在"方法可见性"上的限制是同构的:凡是不能被"转发"或"重写"的方法,都绕过了拦截,这与选择哪套代理无关。

再划清一个容易混淆的边界:Spring AOP 与 AspectJ 不是一回事。Spring AOP 是运行期动态代理,拦截粒度是方法;AspectJ 是编译期/类加载期织入,可以拦截字段访问与构造器调用,final 方法也不在话下。绝大多数业务项目用不到 AspectJ——真遇到"必须拦截第三方库的 final 方法"这类场景时,先考虑改设计(包一层适配类)而不是引入织入器这种重型方案。

一个能直接验证的例子:

@Service
public class OrderService {
    public void create() {
        // Spring 注入环境里,this 实际是代理对象,打印结果类似:
        // class OrderService$$EnhancerBySpringCGLIB$$8a2f1c
        // 若打印出纯 OrderService,说明拿到的不是容器代理,切面必然失效
        System.out.println(this.getClass());
    }
}

三个最常见的代理陷阱

陷阱一:自调用失效

同类中方法互调,走的是 this(原始对象),不经过代理,切面全部失效。先看错误写法:

// 错误写法:this.create() 绕过代理,@Transactional 完全不生效
@Service
public class OrderService {

    @Transactional
    public void create(Order order) {
        orderMapper.insert(order);
        stockMapper.deduct(order.getSkuId()); // 这一步抛异常也不会触发回滚
    }

    public void batchCreate(List<Order> orders) {
        for (Order o : orders) {
            this.create(o); // 灾难:this 是原始对象,事务注解形同虚设
        }
    }
}

正确写法按推荐程度排序,首选是把被调方法拆到另一个 Bean:

// 正确写法一(首选):拆 Bean,调用必然经过代理,同时也是职责优化
@Service
public class OrderBatchService {
    @Autowired
    private OrderService orderService; // 独立 Bean,注入的就是代理

    public void batchCreate(List<Order> orders) {
        for (Order o : orders) {
            orderService.create(o); // 每次调用都走事务代理
        }
    }
}
// 正确写法二:注入自身代理(@Lazy 打破构造期依赖环)
@Service
public class OrderService {
    @Autowired
    @Lazy
    private OrderService self; // Spring 注入的是代理对象,不是 this

    public void batchCreate(List<Order> orders) {
        orders.forEach(o -> self.create(o)); // 经由 self(代理)调用,切面生效
    }
}

第三种解法是开启 @EnableAspectJAutoProxy(exposeProxy = true) 后用 (OrderService) AopContext.currentProxy() 强转调用——侵入性最强,只作为改不动结构时的兜底,且要在代码里注明待重构。三种解法共同点只有一个:让调用重新回到代理对象上。

选解法时还有一个隐性维度要核对:事务语义。拆 Bean 后每个 Bean 的事务边界互相独立,batchCreate 与 create 是否要同生共死,决定了拆分怎么组合——业务要求批量操作整体一个事务时,应该拆成"批量事务壳 + 无事务单条逻辑",让壳方法持有事务,而不是把注解原样抄到拆出的方法上,那样事务边界就变了。

陷阱二:final / private / static 方法无法增强

CGLIB 靠继承 + 方法重写实现代理:final 方法不能被重写,private 方法对子类不可见,static 方法不参与继承,三者都绕过了拦截。JDK 代理模式下问题同样存在——代理只转发接口方法,实现类自己新增的方法不在代理范围内。这类失效是静默的:不报错、不打日志,注解只是"看起来存在",只有数据不一致的后果会暴露它。团队规约里直接禁止对带事务/缓存/异步注解的方法使用 final 与 private 修饰,比事后排查便宜得多。

陷阱三:new 出来的对象没有代理

AOP 能力是容器在创建 Bean 时织入的。工具类里手动 new OrderService(),拿到的是裸对象,切面、事务、缓存一概没有。同理,在构造器和 @PostConstruct 里调用本类带切面的方法也会失效——构造阶段代理还没组装,@PostConstruct 阶段方法调用仍走 this 原始引用。需要"容器就绪后立刻触发一次切面方法"时,监听 ContextRefreshedEvent 或用 ApplicationRunner,那时容器里所有代理都已就绪。

绕不开结构时还有一条编程式的路:事务场景用 TransactionTemplate 手动包住需要保护的代码块,不依赖代理拦截,自调用、工具类调用天然生效。代价是事务边界侵入代码,适合局部小段逻辑,不适合作为全局默认——两条路线的选择标准依然是"声明式优先、编程式局部兜底"。

实战排查思路

这套顺序的前提是"先穷尽代理链路,再怀疑切面本身"——绝大多数案例在前三步就结束,跳步直接去调切点表达式反而绕远。动手时把调用链画出来(入口 → 调用方 → 被调方),每一跳标注"这个引用是注入的还是自己构造的",代理在哪一跳断掉就一目了然。

遇到"注解加了没效果",按顺序检查:

  1. 调用方拿到的是不是 Spring 注入的 Bean(排除 new);
  2. 调用链上有没有 this.xxx() 自调用——尤其注意隔着两层方法的自调用,比直接自调用更隐蔽;
  3. 被调方法是不是 public、有没有被 final 修饰;
  4. 打印 bean.getClass() 确认它确实是代理类;
  5. 类路径上有没有重复声明的 @EnableAspectJAutoProxy 导致代理配置互相覆盖(少见但存在);
  6. 切点表达式是否真的命中目标方法——写一个临时 @AfterReturning 打一行日志验证命中情况,别靠肉眼读表达式。

列表之外还有一个兜底验证手段:Arthas。stack 命令打印方法的完整调用栈,能直接看到链路上是否经过 CGLIB$$ 或 Proxy 类;jad 确认线上类的增强情况。比肉眼审代码可靠,特别适合排查"隔着好几层"的隐蔽自调用。

一句话收尾:AOP 的一切魔法都发生在"代理对象"身上,绕过代理 = 绕过魔法。

生产案例

一次对账系统上线补偿任务后,财务侧发现部分扣款流水既没有成功记录也没有回滚痕迹,成了"悬空账"。排查用 Arthas watch 打出方法入参和 this 的类名,发现批量补偿入口内部用 this.retryCharge() 触发扣款——this 打印出来是裸的 ChargeService,事务代理被完全绕过:扣款本地落库成功后远程调用失败,异常又被上层 catch,本地数据既没走提交口径校验也没回滚。修复没有引入任何新框架能力,就是把扣款逻辑拆到独立的 ChargeService,由批量任务注入代理调用。这个案例的后续动作,是把"同类自调用 + 事务注解"写进了代码评审的固定检查项,类似的静默失效再没出现过。

检查清单

  • 项目内所有 @Transactional / @Async / @Cacheable 方法都是 public 且非 final
  • 代码评审专门检查同类内 this.xxx() 调用是否指向带增强注解的方法
  • 没有任何业务对象通过 new 创建后调用了带切面的方法
  • 构造器与 @PostConstruct 里没有对自身切面方法的调用
  • 关键 Bean 上线前验证过 getClass() 输出包含代理类名
  • AopContext.currentProxy 方案只作为临时兜底,且登记了待重构清单
  • 团队规约明确优先级:拆 Bean 解自调用优先,注入自身代理次之