罗罗编程学习记录
本页内容 展开查看

06.2.1.3 AOP 与代理机制

所属:全栈开发面试题库 / 06 后端框架与工程实践 / 06.2 Java Spring 生态 / 06.2.1 Spring Framework

本节要解决的问题

  • 日志、事务、权限这些“每个方法都要做一点”的逻辑,怎么不侵入业务代码?
  • Spring 的 AOP 到底用的是 JDK 代理还是 CGLIB?
  • 为什么加了 @Transactional 却不生效?

06.2.1.3-001 AOP 是什么?有哪些核心术语?

一句话结论

AOP(面向切面编程)把横切逻辑(日志、事务、权限、缓存)从业务代码中抽出来,在方法执行前后“织入”;核心术语是切面、连接点、切点、通知、目标对象、代理。

概念解释

  • 切面(Aspect):横切逻辑的模块,如“事务切面”。
  • 连接点(Join Point):程序执行中可插入切面的点,Spring 中就是方法调用。
  • 切点(Pointcut):匹配哪些连接点的表达式。
  • 通知(Advice):在连接点做什么(前置/后置/环绕/异常/返回)。
  • 目标对象(Target):被增强的原始对象。
  • 代理(Proxy):容器生成的包装对象,调用先经过通知链。

示例

@Aspect
@Component
public class LogAspect {
    @Around("execution(* com.example.service.*.*(..))")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        long t = System.currentTimeMillis();
        try { return pjp.proceed(); }
        finally { System.out.println(pjp.getSignature() + " cost=" + (System.currentTimeMillis()-t)); }
    }
}

常见误区

  • AOP 不等于“动态代理”,动态代理只是 Spring AOP 的实现手段。
  • 切面逻辑最终仍要在方法调用链上执行,不是编译期真的改写字节码(Spring AOP 如此;AspectJ 编译期织入是另一回事)。

追问

  • Spring AOP 和 AspectJ 的区别?Spring AOP 基于代理、只支持方法级;AspectJ 编译期/加载期织入,支持字段、构造器。
  • 为什么叫“织入”?把通知逻辑编织到目标方法的调用前后。

06.2.1.3-002 JDK 动态代理和 CGLIB 有什么区别?

一句话结论

JDK 动态代理只能代理实现了接口的类,基于 InvocationHandler;CGLIB 通过继承生成子类,可代理没有接口的类,但不能代理 final 类和 final 方法。

对比

维度 JDK 动态代理 CGLIB
前提 目标类实现接口 目标类可被继承
实现 Proxy + InvocationHandler ASM 生成子类,方法拦截
final 不受影响 不能代理 final 类/方法
性能 JDK 8+ 较快 生成类较慢,调用较快
典型 UserService 接口代理 无接口的 @Service 类

示例

public interface UserService { void save(); }

UserService proxy = (UserService) Proxy.newProxyInstance(
    classLoader, new Class[]{UserService.class},
    (p, m, args) -> { System.out.println("before"); return m.invoke(target, args); });

常见误区

  • “CGLIB 一定比 JDK 快”是过时结论,JDK 8 之后已大幅优化。
  • CGLIB 代理对象不是原类型实例的简单替换,getClass() 会看到生成的子类。

追问

  • 为什么 Spring Boot 2.x 默认 spring.aop.proxy-target-class=true?因为很多 Bean 没有接口,CGLIB 更通用。
  • final 方法加了 @Transactional 为什么无效?CGLIB 无法重写 final 方法。

06.2.1.3-003 Spring 如何决定用哪种代理?

一句话结论

AbstractAutoProxyCreator 判断目标类是否实现接口:有接口默认 JDK 代理,无接口用 CGLIB;可通过 proxyTargetClass=true 强制 CGLIB。

展开原理

  • 配置项:@EnableAspectJAutoProxy(proxyTargetClass = true) 或 Boot 的 spring.aop.proxy-target-class。
  • 有接口但强制 CGLIB 时,注入按接口类型仍可,但实际对象是子类。
  • 代理创建发生在 BeanPostProcessor.postProcessAfterInitialization。

示例

@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class AopConfig {}

常见误区

  • 按具体类注入一个 JDK 代理对象会失败(代理类只实现接口,不是目标类)。
  • 强制 CGLIB 后,final 类/方法仍无法增强。

追问

  • 如何判断某个 Bean 是否被代理?打印 bean.getClass(),或看是否含 $$EnhancerBySpringCGLIB/$Proxy。
  • 代理对象和原对象的依赖注入关系?容器注入的是代理,目标对象内部自调用不会经过代理。

06.2.1.3-004 Spring AOP 有哪几种通知类型?

一句话结论

五种:@Before(前置)、@After(后置/最终)、@AfterReturning(正常返回)、@AfterThrowing(异常)、@Around(环绕,最强但需手动 proceed())。

对比

通知 执行时机 能否改变返回值 能否阻止异常
@Before 方法前 否 否
@After 方法后(finally 语义) 否 否
@AfterReturning 正常返回后 可修改(需绑定 returning) 否
@AfterThrowing 抛异常后 否 否
@Around 包裹整个调用 是 是

示例

@Around("execution(* com.example.service.*.*(..))")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
    // 前置
    Object result = pjp.proceed();
    // 后置
    return result;
}

常见误区

  • @After 不等于“正常返回”,异常也会执行;要正常返回用 @AfterReturning。
  • @Around 不调用 proceed(),目标方法就不会执行。

追问

  • 多个通知的执行顺序?同一切面内按声明顺序,环绕通知包裹其他通知。
  • @Around 里能修改参数吗?可以,proceed(Object[] args) 传入新参数。

06.2.1.3-005 切点表达式怎么写?

一句话结论

常用 execution 匹配方法签名,within 匹配类型,@annotation 匹配注解;组合用 &&、||、!。

示例

@Pointcut("execution(public * com.example.service..*.*(..))")
public void serviceMethods() {}

@Pointcut("@annotation(com.example.Log)")
public void logAnnotated() {}

@Around("serviceMethods() && logAnnotated()")
public Object around(ProceedingJoinPoint pjp) throws Throwable { ... }

常见误区

  • .. 表示任意层包,. 表示一层;写错会导致匹配不到。
  • 切点只匹配 Spring 容器管理的 Bean 方法调用,内部自调用不经过代理。

追问

  • 如何匹配带特定参数的方法?execution(* *(String, ..))。
  • 切点能匹配 private 方法吗?Spring AOP 基于代理,private 方法不可见,匹配也无效。

06.2.1.3-006 为什么 AOP 会失效?常见场景有哪些?

一句话结论

本质是“调用没有经过代理对象”。常见于自调用、private/final/static 方法、同类内部调用、对象不是 Spring Bean、切点不匹配。

场景清单

  1. 自调用:this.save() 不经过代理,事务/日志不生效。
  2. private/final/static 方法:代理无法重写或不可见。
  3. new 出来的对象:不在容器中,没有代理。
  4. 切点表达式错误:包名、返回值、参数不匹配。
  5. JDK 代理按类注入:注入失败或拿到代理但类型不符。
  6. 异步线程:跨线程调用丢失代理上下文(如事务)。

修复示例

@Service
public class OrderService {
    @Autowired private OrderService self;   // 注入代理自身

    public void outer() { self.inner(); }  // 经过代理
    @Transactional public void inner() { ... }
}

常见误区

  • 把 @Transactional 标在 private 方法上,以为会生效。
  • 在同类中注入自己造成循环依赖,可用 @Lazy 或 AopContext.currentProxy()。

追问

  • 为什么自调用不经过代理?因为 JVM 的 invokevirtual 直接调用本对象方法,不经过包装对象。
  • AopContext.currentProxy() 怎么用?开启 exposeProxy=true,再强转为代理调用。

06.2.1.3-007 AOP 和声明式事务是什么关系?

一句话结论

@Transactional 是 AOP 的一个典型应用:事务切面在方法调用前开启事务、正常返回后提交、异常时回滚。

展开原理

  • @EnableTransactionManagement 注册 InfrastructureAdvisorAutoProxyCreator。
  • BeanFactoryTransactionAttributeSourceAdvisor 匹配 @Transactional 方法。
  • TransactionInterceptor 环绕执行:获取事务管理器 → 开启 → 调用目标 → 提交/回滚。

图示

调用方 → 代理 → TransactionInterceptor
                    → PlatformTransactionManager.getTransaction
                    → 目标方法
                    → commit / rollback

常见误区

  • 事务切面只对经过代理的调用生效;自调用失效。
  • 事务开启后,异常被内部 catch 吞掉,切面看不到异常就不会回滚。

追问

  • 为什么 @Transactional 默认只回滚 RuntimeException?Spring 约定受检异常不触发回滚,可用 rollbackFor 修改。
  • 事务和 AOP 的优先级?事务通知通常是环绕通知,多个切面按 @Order 排序。

06.2.1.3-008 多个切面如何控制执行顺序?

一句话结论

用 @Order(数值越小优先级越高)或实现 Ordered;环绕通知的执行顺序是“外层先进入、内层先退出”,即栈式嵌套。

示例

@Aspect @Order(1)   // 外层
@Component
public class LogAspect { ... }

@Aspect @Order(2)   // 内层
@Component
public class TxAspect { ... }

图示

Log.before → Tx.before → 目标方法 → Tx.after → Log.after

常见误区

  • 顺序只对同一类通知有意义;不同通知类型混用时按切面整体顺序包裹。
  • @Order 不控制 Bean 创建顺序。

追问

  • 想让事务在最内层还是最外层?通常事务靠近目标方法,日志在外层;但要注意事务回滚后日志仍能记录。
  • 顺序错会怎样?例如权限切面在事务内,鉴权失败也会开启事务。

06.2.1.3-009 Advisor、Advice、Advised 分别是什么?

一句话结论

Advice 是通知逻辑;Advisor 是“切点 + 通知”的组合;Advised 是被代理对象暴露的接口,可查询/添加 Advisor。

概念解释

  • Advisor 负责“在哪里、做什么”,Spring 用它把 Pointcut 和 Advice 绑在一起。
  • Advised 由代理工厂实现,业务可通过它动态增删拦截器(较少用)。
  • ProxyFactory 是底层创建代理的工具,AspectJProxyFactory 支持 AspectJ 注解。

示例

ProxyFactory factory = new ProxyFactory(target);
factory.addAdvice((MethodInterceptor) invocation -> {
    System.out.println("before");
    return invocation.proceed();
});
Object proxy = factory.getProxy();

常见误区

  • 直接 new ProxyFactory 创建的代理不受容器管理,事务等基础设施不会自动生效。
  • Advised 只能操作代理对象,不能操作目标对象。

追问

  • MethodInterceptor 和 @Around 的关系?前者是编程式 AOP,后者是注解式 AOP,最终都走拦截器链。
  • 如何给非 Spring Bean 加事务?手动 ProxyFactory + TransactionInterceptor,或交给容器管理。

06.2.1.3-010 AOP 有哪些性能开销和落地坑?

一句话结论

开销主要来自代理调用链、反射、切点匹配和事务/日志本身的成本;高频方法上避免重量级切面,切点尽量精确。

优化建议

  • 切点精确到包/注解,避免 execution(* *(..)) 全量匹配。
  • 日志切面避免打印大对象、避免同步 IO。
  • 事务切面只包必要方法,避免大事务。
  • 对性能极敏感的方法,考虑编译期织入(AspectJ)或手工埋点。

常见误区

  • 以“AOP 有性能问题”为由完全不用,实际多数业务方法开销可忽略。
  • 在切面里调用远程服务/数据库,放大延迟。

追问

  • 如何定位切面耗时?在 @Around 里打点,或使用 Arthas trace。
  • 代理对象会增加内存吗?每个单例一个代理对象,通常可忽略;原型 Bean 每次创建代理需注意。

本节自检

  • [ ] 能解释 AOP 的核心术语
  • [ ] 能说出 JDK 代理与 CGLIB 的适用边界
  • [ ] 能列出 AOP 失效的 6 种场景
  • [ ] 能画出事务切面的执行链路
  • [ ] 能控制多切面顺序