当前位置：首页 > news >正文

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

news 来源：原创 2025/5/23 9:03:28

这篇文章我将通过一个最常用的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 {
    
    @Autowired
    private 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;
}