【Spring】小白速通AOP-日志记录Demo

这篇文章我将通过一个最常用的AOP场景-方法调用日志记录，带你彻底理解AOP的使用。例子使用Spring Boot+Spring AOP实现。
如果对你有帮助可以点个赞和关注。谢谢大家的支持！！

一、Demo实操步骤：

1.首先添加Maven依赖

<!-- Spring AOP支持 -->
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-aop</artifactId>
</dependency>

2.创建日志切面类

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;@Aspect     // 标识这是一个切面类
@Component  // 让Spring能够扫描到这个组件
public class LoggingAspect {// 创建日志记录器private final Logger logger = LoggerFactory.getLogger(this.getClass());/*** 定义切点：拦截service包下的所有方法* execution(返回值类型 包名.类名.方法名(参数列表))*/@Pointcut("execution(* com.example.demo.service.*.*(..))")public void serviceLayer() {}/*** 前置通知：在目标方法执行前执行*/@Before("serviceLayer()")public void logBefore(JoinPoint joinPoint) {// joinPoint包含目标方法的信息logger.info("准备执行 {} 方法", joinPoint.getSignature().getName());logger.info("参数: {}", Arrays.toString(joinPoint.getArgs()));}/*** 后置通知：在目标方法正常返回后执行*/@AfterReturning(pointcut = "serviceLayer()", returning = "result")public void logAfterReturning(JoinPoint joinPoint, Object result) {logger.info("方法 {} 执行成功，返回值: {}", joinPoint.getSignature().getName(), result);}/*** 异常通知：在目标方法抛出异常后执行*/@AfterThrowing(pointcut = "serviceLayer()", throwing = "ex")public void logAfterThrowing(JoinPoint joinPoint, Exception ex) {logger.error("方法 {} 执行异常: {}", joinPoint.getSignature().getName(), ex.getMessage());}/*** 环绕通知：最强大的通知类型，可以控制方法执行*/@Around("serviceLayer()")public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {long start = System.currentTimeMillis();logger.info("进入方法: {}", joinPoint.getSignature().getName());try {// 执行目标方法Object result = joinPoint.proceed();long elapsedTime = System.currentTimeMillis() - start;logger.info("方法执行完成，耗时: {} ms", elapsedTime);return result;} catch (Exception e) {long elapsedTime = System.currentTimeMillis() - start;logger.error("方法执行异常，耗时: {} ms，异常: {}", elapsedTime, e.getMessage());throw e;}}
}

3.创建测试服务类

@Service
public class UserService {public String getUserById(Long id) {// 模拟数据库查询if (id == 1) {return "用户张三";} else if (id == 2) {return "用户李四";}throw new RuntimeException("用户不存在");}public void updateUser(String user) {// 模拟更新操作System.out.println("更新用户: " + user);}
}

4.测试Controller

@RestController
public class UserController {@Autowiredprivate UserService userService;@GetMapping("/user/{id}")public String getUser(@PathVariable Long id) {return userService.getUserById(id);}@PostMapping("/user")public void updateUser(@RequestBody String user) {userService.updateUser(user);}
}

二、代码讲解：

1.切面(Aspect):

LoggingAspect类 就是一个切面，它封装了横切关注点(这里是日志记录)。

2.切点(Pointcut)：

@Pointcut("execution(* com.example.demo.service.*.*(..))")

定义了"哪些方法需要被拦截"
execution是匹配方法执行的连接点
*表示任意返回值
com.example.demo.service指定包名
第一个*表示所有类
第二个*表示所有方法
(. .)表示任意参数

3.通知(Advice):

@Before：方法执行前
@AfterReturning：方法正常返回后
@AfterThrowing：方法抛出异常后
@Around：最强大，可以控制方法是否执行

三、执行流程演示：

场景1：调用GET/user/1

1.请求进入UserController.getUser(1)
2.调用userService.getUserById(1)时被AOP拦截
3.执行顺序:

@Around的开始部分（记录开始时间）
@Before（记录方法准备执行）
实际执行getUserById方法
@AfterReturning（记录成功返回）
@Around的结束部分（计算耗时）

控制台输出执行结果：

进入方法: getUserById
准备执行 getUserById 方法
参数: [1]
方法 getUserById 执行成功，返回值: 用户张三
方法执行完成，耗时: 12 ms

场景2.调用GET/user/3(会抛出异常)

1.请求进入UserController.getUser(3)
2.调用userService.getUserById(3)时被AOP拦截
3.执行顺序：

@Around的开始部分
@Before
执行getUserById抛出异常
@AfterThrowing（记录异常信息）
@Around的异常处理部分

控制台输出执行结果：

进入方法: getUserById
准备执行 getUserById 方法
参数: [3]
方法 getUserById 执行异常: 用户不存在
方法执行异常，耗时: 5 ms，异常: 用户不存在

四、为什么要用AOP？

对比传统写法，如果不用AOP，我们需要在每个方法中写日志代码，重复代码太多，显得冗杂。

@Service
public class UserService {private final Logger logger = LoggerFactory.getLogger(this.getClass());public String getUserById(Long id) {long start = System.currentTimeMillis();logger.info("准备执行 getUserById 方法");logger.info("参数: " + id);try {if (id == 1) {String result = "用户张三";logger.info("方法执行成功，返回值: " + result);return result;}throw new RuntimeException("用户不存在");} catch (Exception e) {logger.error("方法执行异常: " + e.getMessage());throw e;} finally {long elapsedTime = System.currentTimeMillis() - start;logger.info("方法耗时: " + elapsedTime + " ms");}}
}

此时就可以使用AOP来解决。

AOP的优势：

1.消除重复代码：日志逻辑只写一次，应用到所有方法。
2.业务更纯净：业务方法只关注核心逻辑。
3.维护方便：修改日志格式只需改切面类。
4.灵活扩展：可以随时添加新的横切逻辑(如权限检查)。

五、应用场景：

1. 统一日志记录(如上面的例子)

2.性能监控：统计方法执行时间

@Around("serviceLayer()")
public Object monitorPerformance(ProceedingJoinPoint jp) throws Throwable {long start = System.currentTimeMillis();Object result = jp.proceed();long elapsed = System.currentTimeMillis() - start;if (elapsed > 500) { // 超过500ms记录警告logger.warn("方法 {} 执行耗时 {} ms", jp.getSignature(), elapsed);}return result;
}

3.事务管理（Spring的@Transactional就是基于AOP实现的）

4.权限控制：

@Before("@annotation(requiresAuth)")
public void checkAuth(JoinPoint jp, RequiresAuth requiresAuth) {if (!SecurityUtils.hasRole(requiresAuth.value())) {throw new AccessDeniedException("无权限访问");}
}

5.缓存处理：

@Around("@annotation(cacheable)")
public Object handleCache(ProceedingJoinPoint jp, Cacheable cacheable) throws Throwable {String key = generateKey(jp, cacheable);Object cached = cache.get(key);if (cached != null) return cached;Object result = jp.proceed();cache.put(key, result);return result;
}