乐趣区

Spring-Boot-2X八Spring-AOP-实现简单的日志切面

jiezi

AOP

1. 什么是 AOP？

AOP 的全称为 Aspect Oriented Programming，译为面向切面编程，是通过预编译方式和运行期动态代理实现核心业务逻辑之外的横切行为的统一维护的一种技术。AOP 是面向对象编程（OOP）的补充和扩展。
利用 AOP 可以对业务逻辑各部分进行隔离，从而达到降低模块之间的耦合度，并将那些影响多个类的公共行为封装到一个可重用模块，从而到达提高程序的复用性，同时提高了开发效率，提高了系统的可操作性和可维护性。

2. 为什么要用 AOP？

在实际的 Web 项目开发中，我们常常需要对各个层面实现日志记录，性能统计，安全控制，事务处理，异常处理等等功能。如果我们对每个层面的每个类都独立编写这部分代码，那久而久之代码将变得很难维护，所以我们把这些功能从业务逻辑代码中分离出来，聚合在一起维护，而且我们能灵活地选择何处需要使用这些代码。

3.AOP 的核心概念

名词 概念 理解
通知（Advice） 拦截到连接点之后所要执行的代码，通知分为前置、后置、异常、最终、环绕通知五类 我们要实现的功能，如日志记录，性能统计，安全控制，事务处理，异常处理等等，说明什么时候要干什么
连接点（Joint Point） 被拦截到的点，如被拦截的方法、对类成员的访问以及异常处理程序块的执行等等，自身还能嵌套其他的 Joint Point Spring 允许你用通知的地方，方法有关的前前后后（包括抛出异常）
切入点（Pointcut） 对连接点进行拦截的定义 指定通知到哪个方法，说明在哪干
切面（Aspect） 切面类的定义，里面包含了切入点（Pointcut）和通知（Advice）的定义 切面就是通知和切入点的结合
目标对象（Target Object） 切入点选择的对象，也就是需要被通知的对象；由于 Spring AOP 通过代理模式实现，所以该对象永远是被代理对象 业务逻辑本身
织入（Weaving） 把切面应用到目标对象从而创建出 AOP 代理对象的过程。织入可以在编译期、类装载期、运行期进行，而 Spring 采用在运行期完成 切点定义了哪些连接点会得到通知
引入（Introduction） 可以在运行期为类动态添加方法和字段，Spring 允许引入新的接口到所有目标对象 引入就是在一个接口 / 类的基础上引入新的接口增强功能
AOP 代理（AOP Proxy） Spring AOP 可以使用 JDK 动态代理或者 CGLIB 代理，前者基于接口，后者基于类 通过代理来对目标对象应用切面

Spring AOP

1. 简介

AOP 是 Spring 框架中的一个核心内容。在 Spring 中，AOP 代理可以用 JDK 动态代理或者 CGLIB 代理 CglibAopProxy 实现。Spring 中 AOP 代理由 Spring 的 IOC 容器负责生成和管理，其依赖关系也由 IOC 容器负责管理。

2. 相关注解

注解 说明
@Aspect 将一个 java 类定义为切面类
@Pointcut 定义一个切入点，可以是一个规则表达式，比如下例中某个 package 下的所有函数，也可以是一个注解等
@Before 在切入点开始处切入内容
@After 在切入点结尾处切入内容
@AfterReturning 在切入点 return 内容之后处理逻辑
@Around 在切入点前后切入内容，并自己控制何时执行切入点自身的内容
@AfterThrowing 用来处理当切入内容部分抛出异常之后的处理逻辑
@Order(100) AOP 切面执行顺序，@Before 数值越小越先执行，@After 和 @AfterReturning 数值越大越先执行

其中 @Before、@After、@AfterReturning、@Around、@AfterThrowing 都属于通知（Advice）。

利用 AOP 实现 Web 日志处理

1. 构建项目

2. 添加依赖 

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- 热部署模块 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional> <!-- 这个需要为 true 热部署才有效 -->
        </dependency>
        <!-- Spring AOP -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
    </dependencies>

3.Web 日志注解 

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface ControllerWebLog {String name();// 所调用接口的名称
     boolean intoDb() default false;// 标识该条操作日志是否需要持久化存储}

4. 实现切面逻辑 

@Aspect
@Component
@Order(100)
public class WebLogAspect {private static final Logger logger = LoggerFactory.getLogger(WebLogAspect.class);

    private ThreadLocal<Map<String, Object>> threadLocal = new ThreadLocal<Map<String, Object>>();

    /**
     * 横切点
     */
    @Pointcut("execution(public * cn.zwqh.springboot.controller..*.*(..))")
    public void webLog() {}
    /**
     * 接收请求，并记录数据
     * @param joinPoint
     * @param controllerWebLog
     */
    @Before(value = "webLog()&& @annotation(controllerWebLog)")
    public void doBefore(JoinPoint joinPoint, ControllerWebLog controllerWebLog) {
        // 接收到请求
        RequestAttributes ra = RequestContextHolder.getRequestAttributes();
        ServletRequestAttributes sra = (ServletRequestAttributes) ra;
        HttpServletRequest request = sra.getRequest();
        // 记录请求内容，threadInfo 存储所有内容
        Map<String, Object> threadInfo = new HashMap<>();
        logger.info("URL :" + request.getRequestURL());
        threadInfo.put("url", request.getRequestURL());
        logger.info("URI :" + request.getRequestURI());
        threadInfo.put("uri", request.getRequestURI());
        logger.info("HTTP_METHOD :" + request.getMethod());
        threadInfo.put("httpMethod", request.getMethod());
        logger.info("REMOTE_ADDR :" + request.getRemoteAddr());
        threadInfo.put("ip", request.getRemoteAddr());
        logger.info("CLASS_METHOD :" + joinPoint.getSignature().getDeclaringTypeName() + "."
                + joinPoint.getSignature().getName());
        threadInfo.put("classMethod",
                joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName());
        logger.info("ARGS :" + Arrays.toString(joinPoint.getArgs()));
        threadInfo.put("args", Arrays.toString(joinPoint.getArgs()));
        logger.info("USER_AGENT"+request.getHeader("User-Agent"));
        threadInfo.put("userAgent", request.getHeader("User-Agent"));
        logger.info("执行方法：" + controllerWebLog.name());
        threadInfo.put("methodName", controllerWebLog.name());
        threadLocal.set(threadInfo);
    }
    /**
     * 执行成功后处理
     * @param controllerWebLog
     * @param ret
     * @throws Throwable
     */
    @AfterReturning(value = "webLog()&& @annotation(controllerWebLog)", returning = "ret")
    public void doAfterReturning(ControllerWebLog controllerWebLog, Object ret) throws Throwable {Map<String, Object> threadInfo = threadLocal.get();
        threadInfo.put("result", ret);
        if (controllerWebLog.intoDb()) {
            // 插入数据库操作
            //insertResult(threadInfo);
        }
        // 处理完请求，返回内容
        logger.info("RESPONSE :" + ret);
    }
    /**
     * 获取执行时间
     * @param proceedingJoinPoint
     * @return
     * @throws Throwable
     */
    @Around(value = "webLog()")
    public Object doAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {long startTime = System.currentTimeMillis();
        Object ob = proceedingJoinPoint.proceed();
        Map<String, Object> threadInfo = threadLocal.get();
        Long takeTime = System.currentTimeMillis() - startTime;
        threadInfo.put("takeTime", takeTime);
        logger.info("耗时：" + takeTime);
        threadLocal.set(threadInfo);
        return ob;
    }
    /**
     * 异常处理
     * @param throwable
     */
    @AfterThrowing(value = "webLog()", throwing = "throwable")
    public void doAfterThrowing(Throwable throwable) {RequestAttributes ra = RequestContextHolder.getRequestAttributes();

        ServletRequestAttributes sra = (ServletRequestAttributes) ra;

        HttpServletRequest request = sra.getRequest();
        // 异常信息
        logger.error("{} 接口调用异常，异常信息 {}", request.getRequestURI(), throwable);
    }

}

5. 测试接口 

@RestController
@RequestMapping("/user")
public class UserController {@GetMapping("/getOne")
    @ControllerWebLog(name = "查询", intoDb = true)
    public String getOne(Long id, String name) {return "1234";}
}

6. 运行测试

浏览器请求：http://127.0.0.1:8080/user/getOne?id=1&name=zwqh，可以看到后台日志输出：

小结

日志记录只是一个简单的示例，而 Spring AOP 的应用让整个系统变的更加有条不紊，在其他场景应用也很强大。
它帮助我们降低模块间耦合度，提高程序复用性，提高开发效率，提高系统可做性和可维护性。

示例代码

github

码云

非特殊说明，本文版权归 朝雾轻寒 所有，转载请注明出处.

原文标题：Spring Boot 2.X(八)：Spring AOP 实现简单的日志切面

原文地址：https://www.zwqh.top/article/info/14

如果文章对您有帮助，请扫码关注下我的公众号，文章持续更新中 …

退出移动版