首页 后端 Spring

# 前言：从面向对象到面向切面的思维跃迁

在我刚开始接触 AOP（面向切面编程）的时候，内心充满了疑惑：为什么需要这种奇怪的编程方式？面向对象不是已经足够强大了吗？直到有一天，我面对一个典型的企业级应用场景，才真正理解了 AOP 的价值。

想象一下这个场景：你有一个包含 50 个 Service 类的系统，现在需要在每个 Service 方法执行前后记录日志、检查权限、监控性能、处理事务... 按照传统的 OOP 方式，你需要在每个方法中都重复编写这些代码。这不仅让代码变得臃肿，更违反了 DRY（Don't Repeat Yourself）原则。

AOP 的出现，就是为了解决这类横切关注点（Cross-cutting Concerns）的问题。它让我们能够将这些分散在各个模块中的相同逻辑提取出来，统一管理。这不仅仅是技术的进步，更是编程思想的一次飞跃。

今天，我想和大家分享我对 Spring AOP 的深度理解和实战经验，希望能帮助你真正掌握这门优雅的编程艺术。

# AOP 核心概念：从理论到实践

# 什么是横切关注点？

在深入 AOP 之前，我们必须先理解什么是横切关注点。让我用一个具体的例子来说明：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
@Service
public class UserService {
    
    public User createUser(User user) {
        // 日志记录 - 横切关注点
        log.info("创建用户开始：{}", user.getName());
        
        // 权限检查 - 横切关注点
        checkPermission("USER_CREATE");
        
        // 性能监控 - 横切关注点
        long startTime = System.currentTimeMillis();
        
        try {
            // 核心业务逻辑 - 核心关注点
            User result = userRepository.save(user);
            
            // 事务提交 - 横切关注点
            transactionManager.commit();
            
            return result;
        } finally {
            // 性能统计 - 横切关注点
            long endTime = System.currentTimeMillis();
            log.info("创建用户完成，耗时：{}ms", endTime - startTime);
        }
    }
}

@Service
public class OrderService {
    
    public Order createOrder(Order order) {
        // 同样的横切关注点代码...
        log.info("创建订单开始：{}", order.getId());
        checkPermission("ORDER_CREATE");
        long startTime = System.currentTimeMillis();
        
        try {
            Order result = orderRepository.save(order);
            transactionManager.commit();
            return result;
        } finally {
            long endTime = System.currentTimeMillis();
            log.info("创建订单完成，耗时：{}ms", endTime - startTime);
        }
    }
}

看到问题了吗？日志、权限、性能监控、事务管理这些横切关注点在多个类中重复出现，让代码变得难以维护。

# AOP 的核心术语

Spring AOP 有一套完整的术语体系，理解这些术语是掌握 AOP 的第一步：

# 1. Join Point（连接点）

程序执行的特定点，如方法调用、字段访问、异常抛出等。在 Spring AOP 中，连接点通常是方法执行。

1
2
3
4
5
6
// 这些都是潜在的连接点
public class UserService {
    public User findById(Long id) { ... }     // 方法执行
    public void save(User user) { ... }       // 方法执行
    public void delete(Long id) { ... }       // 方法执行
}

# 2. Pointcut（切入点）

匹配连接点的表达式，定义了在哪些连接点上应用通知。

1
2
3
// 定义切入点：UserService类的所有public方法
@Pointcut("execution(public * com.example.service.UserService.*(..))")
public void userServiceMethods() {}

# 3. Advice（通知）

在切入点执行的代码，分为前置、后置、环绕、异常、最终五种类型。

# 4. Aspect（切面）

切入点和通知的组合，形成一个完整的横切逻辑模块。

# 5. Target Object（目标对象）

被通知的对象，也就是业务逻辑对象。

# 6. Proxy（代理）

AOP 框架创建的对象，用于拦截对目标对象的调用。

# Spring AOP 的实现原理

# 两种代理模式

Spring AOP 使用代理模式来实现切面功能，主要有两种代理方式：

# 1. JDK 动态代理

当目标对象实现了接口时，Spring 会使用 JDK 动态代理：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
// 目标接口
public interface UserService {
    User findById(Long id);
    void save(User user);
}

// 目标实现
@Service
public class UserServiceImpl implements UserService {
    public User findById(Long id) {
        return userRepository.findById(id);
    }
    
    public void save(User user) {
        userRepository.save(user);
    }
}

// Spring创建的代理（简化版）
public class UserServiceProxy implements UserService {
    private UserService target;
    private List<Interceptor> interceptors;
    
    public User findById(Long id) {
        // 前置通知
        for (Interceptor interceptor : interceptors) {
            interceptor.before();
        }
        
        try {
            // 调用目标方法
            User result = target.findById(id);
            
            // 后置通知
            for (Interceptor interceptor : interceptors) {
                interceptor.afterReturning(result);
            }
            
            return result;
        } catch (Exception e) {
            // 异常通知
            for (Interceptor interceptor : interceptors) {
                interceptor.afterThrowing(e);
            }
            throw e;
        } finally {
            // 最终通知
            for (Interceptor interceptor : interceptors) {
                interceptor.after();
            }
        }
    }
}

# 2. CGLIB 代理

当目标对象没有实现接口时，Spring 会使用 CGLIB 创建子类代理：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
// 目标类（没有实现接口）
@Service
public class UserService {
    public User findById(Long id) {
        return userRepository.findById(id);
    }
}

// CGLIB创建的代理子类（简化版）
public class UserService$$EnhancerBySpringCGLIB extends UserService {
    private UserService target;
    private List<Interceptor> interceptors;
    
    @Override
    public User findById(Long id) {
        // 拦截逻辑，与JDK代理类似
        MethodInterceptor interceptor = new MethodInterceptor() {
            @Override
            public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
                // 前置通知
                for (Interceptor i : interceptors) {
                    i.before();
                }
                
                try {
                    Object result = proxy.invokeSuper(obj, args);
                    // 后置通知
                    return result;
                } catch (Exception e) {
                    // 异常通知
                    throw e;
                } finally {
                    // 最终通知
                }
            }
        };
        
        return interceptor.intercept(this, method, args, null);
    }
}

# 代理选择策略

Spring 的代理选择策略如下：

1
2
3
4
5
@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = false) // false优先使用JDK代理
public class AopConfig {
    // 配置类
}

  • proxyTargetClass = false ：优先使用 JDK 代理，只有当目标对象没有实现接口时才使用 CGLIB
  • proxyTargetClass = true ：强制使用 CGLIB 代理

# 切面开发的实战技巧

# 1. 基础切面定义

让我们从一个简单的日志切面开始：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
/**
 * 日志切面
 * 负责记录方法执行的详细信息
 */
@Aspect
@Component
@Slf4j
public class LoggingAspect {
    
    /**
     * 定义切入点：Service层的所有public方法
     */
    @Pointcut("execution(public * com.example.service.*.*(..))")
    public void serviceLayer() {}
    
    /**
     * 前置通知：方法执行前记录日志
     */
    @Before("serviceLayer()")
    public void logBefore(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        
        log.info("开始执行方法：{}，参数：{}", methodName, Arrays.toString(args));
    }
    
    /**
     * 后置通知：方法执行成功后记录日志
     */
    @AfterReturning(pointcut = "serviceLayer()", returning = "result")
    public void logAfterReturning(JoinPoint joinPoint, Object result) {
        String methodName = joinPoint.getSignature().getName();
        log.info("方法执行成功：{}，返回值：{}", methodName, result);
    }
    
    /**
     * 异常通知：方法抛出异常时记录日志
     */
    @AfterThrowing(pointcut = "serviceLayer()", throwing = "exception")
    public void logAfterThrowing(JoinPoint joinPoint, Exception exception) {
        String methodName = joinPoint.getSignature().getName();
        log.error("方法执行异常：{}，异常信息：{}", methodName, exception.getMessage(), exception);
    }
}

# 2. 性能监控切面

性能监控是 AOP 的经典应用场景：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
/**
 * 性能监控切面
 * 监控方法执行时间，超过阈值时记录警告
 */
@Aspect
@Component
@Slf4j
public class PerformanceAspect {
    
    // 性能阈值（毫秒）
    private static final long PERFORMANCE_THRESHOLD = 1000;
    
    /**
     * 定义切入点：所有标注了@Monitor注解的方法
     */
    @Pointcut("@annotation(com.example.annotation.Monitor)")
    public void monitorMethods() {}
    
    /**
     * 环绕通知：监控方法执行时间
     */
    @Around("monitorMethods()")
    public Object monitorPerformance(ProceedingJoinPoint joinPoint) throws Throwable {
        String methodName = joinPoint.getSignature().toShortString();
        long startTime = System.currentTimeMillis();
        
        try {
            // 执行目标方法
            Object result = joinPoint.proceed();
            
            // 计算执行时间
            long endTime = System.currentTimeMillis();
            long executionTime = endTime - startTime;
            
            if (executionTime > PERFORMANCE_THRESHOLD) {
                log.warn("性能警告：方法 {} 执行时间过长，耗时：{}ms", methodName, executionTime);
            } else {
                log.info("性能监控：方法 {} 执行完成，耗时：{}ms", methodName, executionTime);
            }
            
            return result;
        } catch (Throwable throwable) {
            long endTime = System.currentTimeMillis();
            long executionTime = endTime - startTime;
            log.error("性能监控：方法 {} 执行异常，耗时：{}ms", methodName, executionTime, throwable);
            throw throwable;
        }
    }
}

/**
 * 性能监控注解
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Monitor {
    String value() default "";
}

使用这个切面：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Service
public class UserService {
    
    @Monitor("用户查询")
    public User findById(Long id) {
        // 业务逻辑
        return userRepository.findById(id);
    }
    
    @Monitor("用户保存")
    public User save(User user) {
        // 业务逻辑
        return userRepository.save(user);
    }
}

# 3. 权限控制切面

权限控制是另一个 AOP 的重要应用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
/**
 * 权限控制切面
 * 基于注解实现方法级别的权限控制
 */
@Aspect
@Component
@Slf4j
public class SecurityAspect {
    
    @Autowired
    private PermissionService permissionService;
    
    /**
     * 定义切入点：所有标注了@RequirePermission注解的方法
     */
    @Pointcut("@annotation(com.example.annotation.RequirePermission)")
    public void permissionRequiredMethods() {}
    
    /**
     * 前置通知：权限检查
     */
    @Before("permissionRequiredMethods() && @annotation(requirePermission)")
    public void checkPermission(JoinPoint joinPoint, RequirePermission requirePermission) {
        // 获取当前用户
        User currentUser = SecurityContextHolder.getCurrentUser();
        if (currentUser == null) {
            throw new AuthenticationException("用户未登录");
        }
        
        // 获取所需权限
        String requiredPermission = requirePermission.value();
        
        // 检查权限
        if (!permissionService.hasPermission(currentUser, requiredPermission)) {
            String methodName = joinPoint.getSignature().getName();
            log.warn("权限不足：用户 {} 尝试访问需要 {} 权限的方法 {}", 
                    currentUser.getId(), requiredPermission, methodName);
            throw new AuthorizationException("权限不足");
        }
        
        log.debug("权限检查通过：用户 {} 访问方法 {}", currentUser.getId(), 
                joinPoint.getSignature().getName());
    }
}

/**
 * 权限要求注解
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RequirePermission {
    String value();
}

使用权限控制：

1
2
3
4
5
6
7
8
9
10
11
12
13
@Service
public class UserService {
    
    @RequirePermission("USER_VIEW")
    public User findById(Long id) {
        return userRepository.findById(id);
    }
    
    @RequirePermission("USER_DELETE")
    public void deleteById(Long id) {
        userRepository.deleteById(id);
    }
}

# 4. 缓存切面

缓存是提升系统性能的重要手段：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
/**
 * 缓存切面
 * 基于注解实现方法级别的缓存
 */
@Aspect
@Component
@Slf4j
public class CacheAspect {
    
    @Autowired
    private CacheManager cacheManager;
    
    /**
     * 定义切入点：所有标注了@Cacheable注解的方法
     */
    @Pointcut("@annotation(com.example.annotation.Cacheable)")
    public void cacheableMethods() {}
    
    /**
     * 环绕通知：实现缓存逻辑
     */
    @Around("cacheableMethods() && @annotation(cacheable)")
    public Object aroundCacheable(ProceedingJoinPoint joinPoint, Cacheable cacheable) throws Throwable {
        // 生成缓存键
        String cacheKey = generateCacheKey(joinPoint, cacheable);
        
        // 尝试从缓存获取
        Cache cache = cacheManager.getCache(cacheable.cacheName());
        Object cachedValue = cache.get(cacheKey);
        
        if (cachedValue != null) {
            log.debug("缓存命中：{} = {}", cacheKey, cachedValue);
            return cachedValue;
        }
        
        // 缓存未命中，执行目标方法
        log.debug("缓存未命中，执行方法：{}", joinPoint.getSignature().getName());
        Object result = joinPoint.proceed();
        
        // 将结果放入缓存
        cache.put(cacheKey, result);
        log.debug("缓存更新：{} = {}", cacheKey, result);
        
        return result;
    }
    
    /**
     * 生成缓存键
     */
    private String generateCacheKey(ProceedingJoinPoint joinPoint, Cacheable cacheable) {
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        
        if (cacheable.key().isEmpty()) {
            // 使用默认键生成策略
            return methodName + ":" + Arrays.hashCode(args);
        } else {
            // 使用自定义键生成策略（支持SpEL）
            return parseSpEL(cacheable.key(), joinPoint);
        }
    }
    
    /**
     * 解析SpEL表达式
     */
    private String parseSpEL(String expression, ProceedingJoinPoint joinPoint) {
        // SpEL解析逻辑（简化版）
        // 实际实现会更复杂，支持参数引用等
        return expression.replace("#args", Arrays.toString(joinPoint.getArgs()));
    }
}

/**
 * 缓存注解
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Cacheable {
    String cacheName() default "default";
    String key() default "";
    int expire() default 3600; // 过期时间（秒）
}

# 高级切面技巧

# 1. 复杂切入点表达式

Spring AOP 支持强大的切入点表达式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
@Aspect
@Component
public class ComplexPointcutAspect {
    
    /**
     * 组合切入点：Service层且不是以get开头的方法
     */
    @Pointcut("execution(* com.example.service.*.*(..)) && !execution(* com.example.service.*.get*(..))")
    public void serviceNonGetterMethods() {}
    
    /**
     * 基于注解的切入点：标注了@Transactional的方法
     */
    @Pointcut("@annotation(org.springframework.transaction.annotation.Transactional)")
    public void transactionalMethods() {}
    
    /**
     * 基于参数的切入点：第一个参数是Long类型的方法
     */
    @Pointcut("execution(* *(Long, ..))")
    public void methodsWithLongFirstParam() {}
    
    /**
     * 组合多个条件
     */
    @Pointcut("serviceNonGetterMethods() && transactionalMethods()")
    public void complexCondition() {}
    
    @Before("complexCondition()")
    public void beforeComplexCondition(JoinPoint joinPoint) {
        log.info("复杂切入点匹配：{}", joinPoint.getSignature());
    }
}

# 2. 切面优先级

当一个连接点匹配多个切面时，可以通过 @Order 注解控制执行顺序：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
@Aspect
@Component
@Order(1) // 优先级最高
public class SecurityAspect {
    @Before("@annotation(RequirePermission)")
    public void checkPermission() {
        // 权限检查
    }
}

@Aspect
@Component
@Order(2) // 优先级次之
public class LoggingAspect {
    @Before("@annotation(RequirePermission)")
    public void logBefore() {
        // 日志记录
    }
}

@Aspect
@Component
@Order(3) // 优先级最低
public class PerformanceAspect {
    @Around("@annotation(Monitor)")
    public Object monitor() {
        // 性能监控
    }
}

# 3. 引入增强（Introduction）

引入增强可以为现有类添加新的接口和方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
/**
 * 引入增强：为Service添加审计功能
 */
@Aspect
@Component
public class AuditIntroduction {
    
    /**
     * 引入接口：审计功能
     */
    public interface Auditable {
        void audit(String operation);
        List<String> getAuditLogs();
    }
    
    /**
     * 引入实现：审计功能实现
     */
    public static class AuditableImpl implements Auditable {
        private List<String> auditLogs = new ArrayList<>();
        
        @Override
        public void audit(String operation) {
            auditLogs.add(LocalDateTime.now() + ": " + operation);
        }
        
        @Override
        public List<String> getAuditLogs() {
            return new ArrayList<>(auditLogs);
        }
    }
    
    /**
     * 为所有Service类引入审计功能
     */
    @DeclareParents(
        value = "com.example.service.*+", // 匹配所有Service实现类
        defaultImpl = AuditableImpl.class   // 默认实现
    )
    public static Auditable auditable;
}

使用引入增强：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
@Service
public class UserService {
    public User save(User user) {
        return userRepository.save(user);
    }
}

// 在其他地方使用审计功能
@Controller
public class UserController {
    
    @Autowired
    private UserService userService;
    
    public void saveUser(User user) {
        userService.save(user);
        
        // 强制转换为审计接口
        Auditable auditable = (Auditable) userService;
        auditable.audit("保存用户：" + user.getName());
        
        List<String> logs = auditable.getAuditLogs();
        logs.forEach(System.out::println);
    }
}

# AOP 最佳实践

# 1. 合理使用 AOP

适合使用 AOP 的场景：

  • 日志记录
  • 性能监控
  • 权限控制
  • 缓存管理
  • 事务管理
  • 异常处理

不适合使用 AOP 的场景：

  • 核心业务逻辑
  • 需要细粒度控制的逻辑
  • 性能敏感的代码（AOP 有一定开销）

# 2. 避免过度使用 AOP

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
// ❌ 过度使用AOP，让代码难以理解
@Aspect
@Component
public class OverUsedAspect {
    
    @Before("execution(* com.example.service.*.*(..))")
    public void before1() { /* 逻辑1 */ }
    
    @Before("execution(* com.example.service.*.*(..))")
    public void before2() { /* 逻辑2 */ }
    
    @After("execution(* com.example.service.*.*(..))")
    public void after1() { /* 逻辑1 */ }
    
    @After("execution(* com.example.service.*.*(..))")
    public void after2() { /* 逻辑2 */ }
}

// ✅ 合理使用AOP，逻辑清晰
@Aspect
@Component
public class WellUsedAspect {
    
    @Around("execution(* com.example.service.*.*(..))")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        // 统一的前置逻辑
        beforeLogic();
        
        try {
            Object result = joinPoint.proceed();
            // 统一的后置逻辑
            afterLogic(result);
            return result;
        } catch (Exception e) {
            // 统一的异常处理
            exceptionLogic(e);
            throw e;
        }
    }
}

# 3. 性能优化

AOP 会带来一定的性能开销，需要注意优化：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
@Aspect
@Component
public class PerformanceOptimizedAspect {
    
    // 使用缓存避免重复计算
    private final Map<String, Boolean> pointcutCache = new ConcurrentHashMap<>();
    
    /**
     * 使用精确的切入点，避免不必要的拦截
     */
    @Pointcut("execution(public * com.example.service.*.*(..))")
    public void serviceMethods() {}
    
    /**
     * 使用条件判断，减少不必要的处理
     */
    @Around("serviceMethods()")
    public Object optimizedAround(ProceedingJoinPoint joinPoint) throws Throwable {
        String methodName = joinPoint.getSignature().getName();
        
        // 快速路径：对于已知安全的方法，直接执行
        if (isFastPathMethod(methodName)) {
            return joinPoint.proceed();
        }
        
        // 慢速路径：需要AOP处理的方法
        return processWithAop(joinPoint);
    }
    
    private boolean isFastPathMethod(String methodName) {
        return pointcutCache.computeIfAbsent(methodName, 
            name -> name.startsWith("get") || name.startsWith("is"));
    }
}

# 4. 测试 AOP 切面

切面也需要单元测试：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
@SpringBootTest
public class LoggingAspectTest {
    
    @Autowired
    private UserService userService;
    
    @MockBean
    private UserRepository userRepository;
    
    @Test
    public void testLoggingAspect() {
        // 准备测试数据
        User user = new User(1L, "test");
        when(userRepository.findById(1L)).thenReturn(user);
        
        // 执行测试
        User result = userService.findById(1L);
        
        // 验证结果
        assertEquals(user, result);
        
        // 验证日志输出（需要配合日志测试框架）
        // 这里可以使用Logback的测试配置或者Mockito的ArgumentCaptor
    }
}

# 常见问题与解决方案

# 1. 代理失效问题

有时候 AOP 不生效，常见原因包括：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
// ❌ 自调用问题，AOP不生效
@Service
public class UserService {
    
    public void methodA() {
        // 自调用，不会触发AOP
        methodB();
    }
    
    @Transactional
    public void methodB() {
        // 事务不会生效
    }
}

// ✅ 解决方案1：注入自身
@Service
public class UserService {
    
    @Autowired
    private UserService self; // 注入自身代理
    
    public void methodA() {
        // 通过代理调用，AOP生效
        self.methodB();
    }
    
    @Transactional
    public void methodB() {
        // 事务生效
    }
}

// ✅ 解决方案2：使用AopContext
@Service
public class UserService {
    
    public void methodA() {
        // 通过AopContext获取代理
        ((UserService) AopContext.currentProxy()).methodB();
    }
    
    @Transactional
    public void methodB() {
        // 事务生效
    }
}

# 2. 切入点表达式错误

1
2
3
4
5
6
7
8
9
10
11
12
13
// ❌ 常见错误：包名拼写错误
@Pointcut("execution(* com.example.servicee.*.*(..))") // servicee拼写错误

// ❌ 常见错误：访问修饰符不匹配
@Pointcut("execution(private * com.example.service.*.*(..))") // private方法无法被代理

// ✅ 正确的切入点表达式
@Pointcut("execution(public * com.example.service.*.*(..))")
public void publicServiceMethods() {}

// ✅ 使用within限制范围
@Pointcut("within(com.example.service.*)")
public void withinServicePackage() {}

# 3. 循环依赖问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// ❌ 可能导致循环依赖
@Aspect
@Component
public class AspectA {
    @Autowired
    private ServiceB serviceB;
}

@Service
public class ServiceB {
    @Autowired
    private AspectA aspectA; // 循环依赖
}

// ✅ 解决方案：使用ApplicationContextAware或者@Lazy
@Aspect
@Component
public class AspectA {
    @Autowired
    @Lazy
    private ServiceB serviceB;
}

# 总结：AOP 的艺术之美

AOP 不仅仅是一种技术，更是一种编程思想的升华。它让我们能够：

  1. 关注点分离：将横切关注点从业务逻辑中分离出来
  2. 代码复用：避免在多个地方重复编写相同的逻辑
  3. 维护性提升：修改横切逻辑只需要在一个地方进行
  4. 非侵入性：不需要修改原有的业务代码

但也要记住，AOP 不是银弹。过度使用 AOP 会让代码变得难以理解和调试。合理使用 AOP，才能发挥它的最大价值。

在学习 AOP 的过程中，我最大的感悟是：技术本身并不复杂，复杂的是如何正确地使用它。理解了 AOP 的核心思想，掌握了基本的实现原理，你就能在实际项目中游刃有余地运用这门技术。