spring中aop Spring AOP底层实现大揭秘：事务为何不生效？性能为何变慢？

为什么我明明加了@注解，事务却不生效？

为什么在同一个类内部的方法调用，AOP拦截会失效？

为什么有时候性能会莫名其妙地变慢？

如果你遇到过这些问题，那么本期这篇文章能够帮助你。让咱们一起来探讨 AOP底层实现。

为什么需要了解底层原理？1. 避免踩坑，提升开发效率

很多开发者在遇到AOP不生效时，第一反应是" AOP有bug"，但事实上，90%的问题都是因为对底层机制理解不够深入。

比如这个常见的坑：

@Service
public class UserService {
    
    @Transactional
    public void createUser(User user) {
        // 这里的事务注解会失效！
        validateUser(user);
        saveUser(user);
    }
    
    @Transactional
    public void validateUser(User user) {
        // 验证逻辑
    }
    
    @Transactional
    public void saveUser(User user) {
        // 保存逻辑
    }
}

为什么失效？因为在同一个类内部的方法调用不会经过代理对象！只有了解AOP的代理机制，你才能理解并避免这个问题。

2. 写出更高效的代码

不同的代理方式（JDK动态代理 vs CGLIB）在性能上有差异，了解它们的区别可以帮助你在特定场景下做出更优选择。

3. 更好的调试和问题定位

当AOP相关的问题出现时，了解底层原理可以让你快速定位问题根源，而不是盲目地尝试各种解决方案。

AOP的核心原理：动态代理的魔法世界

现在，让我们正式进入 AOP的底层世界。 AOP的实现基于动态代理技术，当你调用一个被AOP增强的Bean的方法时，实际上调用的是创建的代理对象的方法。

两种代理方式的较量

1. JDK动态代理 - 接口的舞者

JDK动态代理是默认采用的代理方式，但它有个重要特点：只能为实现了接口的类创建代理。

// JDK动态代理示例
public class JdkProxyDemo {
    public static void main(String[] args) {
        UserService target = new UserServiceImpl();
        
        UserService proxy = (UserService) Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            (p, method, args1) -> {
                System.out.println("前置处理");
                Object result = method.invoke(target, args1);
                System.out.println("后置处理");
                return result;
            }
        );
        
        proxy.doSomething(); // 这里调用的是代理方法
    }
}

2. CGLIB代理 - 继承的王者

当目标类没有实现接口时，会使用CGLIB来创建代理。CGLIB通过继承目标类并重写方法来实现代理。

// CGLIB代理示例
public class CglibProxyDemo {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(UserService.class);
        enhancer.setCallback(new MethodInterceptor() {
            @Override

            public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
                System.out.println("前置处理");
                Object result = proxy.invokeSuper(obj, args);
                System.out.println("后置处理");
                return result;
            }
        });
        
        UserService proxy = (UserService) enhancer.create();
        proxy.doSomething(); // 调用代理方法
    }
}

的智能选择

按照以下策略选择代理方式：

如果目标对象实现了接口 → 默认使用JDK动态代理如果目标对象没有实现接口 → 使用CGLIB代理可以通过@xy( = true)强制使用CGLIB实际开发中的陷阱与解决方案陷阱1：内部方法调用失效

问题：

@Service
public class OrderService {
    
    public void processOrder(Order order) {
        // 这里的事务不会生效！
        validateOrder(order);
    }
    
    @Transactional
    public void validateOrder(Order order) {
        // 验证逻辑
    }
}

解决方案：

@Service
@RequiredArgsConstructor
public class OrderService {
    
    private final OrderService self; // 注入自身代理
    
    public void processOrder(Order order) {
        // 通过代理调用，事务生效
        self.validateOrder(order);
    }
    
    @Transactional
    public void validateOrder(Order order) {
        // 验证逻辑
    }
}

陷阱2：final方法和类无法被代理

问题：

@Service
public final class PaymentService { // final类无法被CGLIB代理
    @Transactional
    public final void processPayment() { // final方法无法被重写
        // 支付逻辑
    }
}

解决方案：

性能优化建议切点表达式优化：避免使用过于宽泛的表达式

// 不推荐 - 太宽泛
@Before("execution(* com..*(..))")
// 推荐 - 具体明确
@Before("execution(* com.example.service.*.*(..))")

代理方式选择：根据具体场景选择JDK动态代理：适合接口较多的场景CGLIB代理：适合没有接口但需要代理的场景避免不必要的代理：不是所有Bean都需要AOP增强

小编认为了解 AOP的底层原理不仅仅是为了满足好奇心，更是为了成为更好的开发者。它能帮助你：

希望这篇文章能帮你真正理解 AOP的底层机制。

代理 public AOP void 方法 CGLIB