懒虫AI助手：一篇搞定Spring AOP核心原理、代码实战与高频面试题（2026.04.09）

public class UserService {
    public void addUser(String name) {
        System.out.println("【日志】开始执行addUser方法");
        // 核心业务逻辑：添加用户
        System.out.println("【日志】addUser方法执行完毕");
    }
    
    public void deleteUser(Long id) {
        System.out.println("【日志】开始执行deleteUser方法");
        // 核心业务逻辑：删除用户
        System.out.println("【日志】deleteUser方法执行完毕");
    }
}

@Service
public class UserService {
    public void addUser(String name) {
        // 只有核心业务逻辑，日志由AOP自动处理
    }
    public void deleteUser(Long id) {
        // 只有核心业务逻辑
    }
}

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

@Service
public class OrderService {
    public String createOrder(String productName, Integer quantity) {
        System.out.println("正在创建订单：" + productName + " x" + quantity);
        // 模拟业务逻辑
        if (quantity == null || quantity <= 0) {
            throw new IllegalArgumentException("数量必须大于0");
        }
        return "订单创建成功，订单号：ORD-" + System.currentTimeMillis();
    }
}

@Aspect
@Component
public class LoggingAspect {
    
    // 定义切点：匹配OrderService中的所有方法
    @Pointcut("execution( com.example.service.OrderService.(..))")
    public void servicePointcut() {}
    
    // 前置通知：方法执行前打印日志
    @Before("servicePointcut()")
    public void logBefore(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        System.out.println("【前置通知】即将执行方法：" + methodName + "，参数：" + Arrays.toString(args));
    }
    
    // 后置通知：方法执行后打印日志
    @After("servicePointcut()")
    public void logAfter(JoinPoint joinPoint) {
        System.out.println("【后置通知】方法执行完毕：" + joinPoint.getSignature().getName());
    }
    
    // 返回通知：方法成功返回后打印返回值
    @AfterReturning(pointcut = "servicePointcut()", returning = "result")
    public void logAfterReturning(JoinPoint joinPoint, Object result) {
        System.out.println("【返回通知】方法返回：" + result);
    }
    
    // 异常通知：方法抛出异常时打印异常信息
    @AfterThrowing(pointcut = "servicePointcut()", throwing = "error")
    public void logAfterThrowing(JoinPoint joinPoint, Throwable error) {
        System.out.println("【异常通知】方法异常：" + error.getMessage());
    }
    
    // 环绕通知：完整控制方法执行（最常用）
    @Around("servicePointcut()")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        long startTime = System.currentTimeMillis();
        String methodName = joinPoint.getSignature().getName();
        
        System.out.println("【环绕通知-前置】进入方法：" + methodName);
        
        try {
            Object result = joinPoint.proceed();  // 执行目标方法
            long endTime = System.currentTimeMillis();
            System.out.println("【环绕通知-后置】方法：" + methodName + "，耗时：" + (endTime - startTime) + "ms");
            return result;
        } catch (Exception e) {
            System.out.println("【环绕通知-异常】方法：" + methodName + "，异常：" + e.getMessage());
            throw e;
        } finally {
            System.out.println("【环绕通知-最终】方法：" + methodName + "执行结束");
        }
    }
}

if (目标类实现了至少一个接口) {
    使用 JDK 动态代理
} else {
    使用 CGLIB
}

@Service
public class OrderService {
    @Transactional  // ⚠️ 这个事务会失效！
    public void createOrder(Order order) {
        // 业务逻辑
    }
    
    public void batchCreate(List<Order> orders) {
        for (Order order : orders) {
            this.createOrder(order);  // this调用不走代理，事务注解失效！
        }
    }
}

@Service
public class OrderService {
    @Autowired
    private OrderService self;  // 注入自身代理对象
    
    public void batchCreate(List<Order> orders) {
        for (Order order : orders) {
            self.createOrder(order);  // 通过代理对象调用，事务生效
        }
    }
}