编辑“︁Spring环绕通知（Around Advice）”︁

{{Note|本文是Spring AOP系列教程的一部分，主要讲解环绕通知（Around Advice）的核心概念与使用方法。适合已掌握[[Spring AOP基础]]的读者。}}

= Spring环绕通知（Around Advice） =
环绕通知是Spring AOP中最强大的通知类型，它允许开发者**完全控制目标方法的执行过程**。与其他通知不同，环绕通知可以决定是否执行目标方法、修改参数值或返回值，甚至捕获和处理异常。

== 核心特性 ==
* '''完全控制流程'''：通过<code>ProceedingJoinPoint</code>决定是否调用目标方法
* '''参数与返回值处理'''：可修改方法参数和返回值
* '''异常处理'''：能捕获并转换异常
* '''性能监控'''：常用于记录方法执行时间

== 语法结构 ==
基本语法示例：
<syntaxhighlight lang="java">
@Around("execution(* com.example.service.*.*(..))")
public Object aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
    // 前置逻辑
    Object result = joinPoint.proceed(); // 调用目标方法
    // 后置逻辑
    return result;
}
</syntaxhighlight>

=== 关键组件解析 ===
{| class="wikitable"
|-
! 组件 !! 说明
|-
| <code>@Around</code> || 声明环绕通知的注解
|-
| <code>ProceedingJoinPoint</code> || 提供访问目标方法信息的接口
|-
| <code>proceed()</code> || 执行目标方法的核心方法
|}

== 完整示例 ==
以下是一个包含性能监控和异常处理的完整案例：

<syntaxhighlight lang="java">
@Aspect
@Component
public class MonitoringAspect {

    @Around("execution(* com.example.service.*.*(..))")
    public Object monitorMethod(ProceedingJoinPoint pjp) throws Throwable {
        long start = System.currentTimeMillis();
        
        try {
            // 可在此修改参数
            Object[] args = pjp.getArgs();
            if (args.length > 0 && args[0] instanceof String) {
                args[0] = ((String) args[0]).trim();
            }
            
            Object result = pjp.proceed(args);
            
            // 可在此修改返回值
            if (result instanceof List) {
                ((List<?>) result).removeIf(Objects::isNull);
            }
            
            return result;
        } catch (Exception e) {
            // 异常转换示例
            throw new ServiceException("操作失败: " + e.getMessage(), e);
        } finally {
            long duration = System.currentTimeMillis() - start;
            System.out.printf("方法 %s 执行耗时: %dms%n", 
                pjp.getSignature().getName(), duration);
        }
    }
}
</syntaxhighlight>

== 执行流程 ==
<mermaid>
sequenceDiagram
    participant Client
    participant Aspect
    participant Target
    
    Client->>Aspect: 调用代理方法
    Aspect->>Target: 前置处理 → 条件性调用proceed()
    Target-->>Aspect: 返回结果/异常
    Aspect->>Client: 返回处理后的结果/转换后的异常
</mermaid>

== 实际应用场景 ==
=== 1. 事务管理 ===
通过环绕通知实现声明式事务：
<syntaxhighlight lang="java">
@Around("@annotation(transactional)")
public Object manageTransaction(ProceedingJoinPoint pjp, Transactional transactional) throws Throwable {
    TransactionStatus status = transactionManager.getTransaction(new DefaultTransactionDefinition());
    try {
        Object result = pjp.proceed();
        transactionManager.commit(status);
        return result;
    } catch (Exception e) {
        transactionManager.rollback(status);
        throw e;
    }
}
</syntaxhighlight>

=== 2. 缓存控制 ===
实现缓存-穿透保护模式：
<syntaxhighlight lang="java">
@Around("@annotation(cacheable)")
public Object checkCache(ProceedingJoinPoint pjp, Cacheable cacheable) throws Throwable {
    String key = generateCacheKey(pjp);
    Object cached = cache.get(key);
    if (cached != null) return cached;
    
    Object result = pjp.proceed();
    if (result != null) {
        cache.put(key, result, cacheable.expire());
    }
    return result;
}
</syntaxhighlight>

== 高级技巧 ==
=== 嵌套调用处理 ===
当多个环绕通知作用于同一方法时，执行顺序由aspect的<code>@Order</code>注解决定：
<syntaxhighlight lang="java">
@Aspect
@Order(1)
public class LoggingAspect {
    @Around("execution(* com..*(..))")
    public Object log(ProceedingJoinPoint pjp) throws Throwable {
        // 日志逻辑
        return pjp.proceed();
    }
}

@Aspect
@Order(2)
public class SecurityAspect {
    @Around("execution(* com..*(..))")
    public Object checkPermission(ProceedingJoinPoint pjp) throws Throwable {
        // 权限检查
        return pjp.proceed();
    }
}
</syntaxhighlight>

=== 性能优化建议 ===
* 避免在环绕通知中执行耗时操作
* 对高频调用方法考虑使用<code>@Around</code>的<code>if()</code>条件
* 使用<code>joinPoint.getArgs()</code>的缓存结果

== 常见问题 ==
{{Warning|1=环绕通知中必须调用`proceed()`，否则目标方法不会执行}}

{| class="wikitable"
|-
! 问题 !! 解决方案
|-
| 忘记调用proceed() || 使用IDE模板确保基本结构正确
|-
| 修改不可变参数 || 对String等不可变对象需要特殊处理
|-
| 异常处理覆盖 || 确保不会意外吞没关键异常
|}

== 数学表达 ==
环绕通知的执行时间公式：
<math>
T_{total} = T_{before} + T_{method} + T_{after}
</math>
其中：
* <math>T_{before}</math> = 前置处理时间
* <math>T_{method}</math> = 目标方法执行时间
* <math>T_{after}</math> = 后置处理时间

[[Category:Spring Framework]]
[[Category:AOP]]

[[Category:后端框架]]
[[Category:Spring]]
[[Category:Spring AOP]]