SpringBoot入门建站全系列（三十六）AspectJ做AOP日志管理

一、概述

Spring的两大特性，AOP和IOC，AOP面向切面编程，可以对当前代码无侵入的情况下，使用AspectJ对切点数据进行分析存储。常常被用来做日志/流水的存储记录。

本篇对如何使用spring-boot-starter-aop做简要说明，并补充常用的表达式。

首发地址：SpringBoot入门建站全系列（三十六）AspectJ做AOP日志管理）

如果大家正在寻找一个java的学习环境，或者在开发中遇到困难，可以加入我们的java学习圈，点击即可加入，共同学习，节约学习时间，减少很多在学习中遇到的难题。

二、配置

本文假设你已经引入spring-boot-starter-web。已经是个SpringBoot项目了,如果不会搭建，可以打开这篇文章看一看《SpringBoot入门建站全系列（一）项目建立》。

2.1 Maven依赖

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

引入spring-boot-starter-aop即可，不需要额外引入其他jar包。

2.2 配置文件

无需额外的配置。

三、SpringBoot应用

3.1 Service层（被切面的业务逻辑层）

这里简单写一个业务逻辑，内容不是重点，重点是怎么切面。

BusinessService：

package com.cff.springbootwork.aspectj.service;

import javax.servlet.http.HttpServletRequest;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import com.cff.springbootwork.aspectj.util.IPUtil;
import com.cff.springbootwork.dto.IpModel;

@Service
public class BusinessService {
    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    /**
     * 获取ip地址
     * 
     * @param request
     * @return
     */
    public IpModel getIpInfo(HttpServletRequest request, int type) {
        logger.info("进入getIpInfo方法。");
        IpModel ipModel = new IpModel();
        ipModel.setClientIpAddress(IPUtil.getIpAddr(request));
        ipModel.setServerIpAddress(IPUtil.localIp());
        return ipModel;
    }

    /**
     * 测试
     * 
     * @param type
     * @return
     */
    public Integer getTestInfo(int type) {
        logger.info("进入getTestInfo方法。");
        return type;
    }
}

3.2 Aspect切面

有了上面的Service，可以直接使用@Component@Aspect来写切面逻辑。

OperateLogAspect:

package com.cff.springbootwork.aspectj;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class OperateLogAspect {
    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @Pointcut("execution(* com.cff.springbootwork.aspectj.service.BusinessService.*(..)) && !execution(* com.cff.springbootwork.aspectj.service.BusinessService.getTest*(..)) ")
    private void log() {
    }

    @Before("log()")
    public void beforeMethod(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        joinPoint.getArgs();
        logger.info("方法为:" + methodName + ", 这是一个前置测试 ");
    }

    @After("execution(* com.cff.springbootwork.aspectj.service.BusinessService.*(..))")
    public void afterMethod(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        logger.info("方法为:" + methodName + ", 这是一个后置测试 ");
    }
    
    @Around("execution(* com.cff.springbootwork.aspectj.service.BusinessService.getTestInfo(..))")
    public void test(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        logger.info("方法为:" + methodName + ", 测水水水水水水水水水水 ");
    }

    @AfterReturning(value = "log()", returning = "result")
    public void afterReturning(JoinPoint point, Object result) {
        String methodName = point.getSignature().getName();
        logger.info("方法为：" + methodName + "，目标方法执行结果为：" + result);
    }

    @Around("log()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        logger.info("请求参数：{}", joinPoint.getArgs());
        Object[] arr = joinPoint.getArgs();
        Integer type = (Integer) arr[1];
        logger.info("请求类型：{}", type);
        long startTime = System.currentTimeMillis();
        Object obj = joinPoint.proceed();
        long timeTaken = System.currentTimeMillis() - startTime;
        logger.info("执行时间：{}", timeTaken);
        return obj;
    }
}

这里，

@Pointcut可以定义切点，定义之后，其他地方使用同样的切点就不需要再写execution，直接写切点的方法名即可。
@Before是在被切方法调用前执行，可以获取到被切方法的参数。
@After是在被切方法执行后执行，无法获取到被切方法的返回值。
@AfterReturning是被被切方法执行后执行，可以获取到被切方法的返回值。
@Around是环绕被切方法，记住需要调用joinPoint.proceed()执行被切方法，如果有返回值，注意return返回值。
@AfterThrowing: 异常通知, 在方法抛出异常之后执行。
如果切面方法外有事务，切面执行的方法也是会回滚的。

四、运行结果

测试中，我调用BusinessService的getIpInfo方法。

切面测试结果:

2020-09-02 15:36:59,755 [http-nio-8086-exec-1][IP:|USER:][INFO  com.cff.springbootwork.aspectj.OperateLogAspect] 请求参数：org.apache.catalina.connector.RequestFacade@71138566
2020-09-02 15:36:59,755 [http-nio-8086-exec-1][IP:|USER:][INFO  com.cff.springbootwork.aspectj.OperateLogAspect] 请求类型：1
2020-09-02 15:36:59,757 [http-nio-8086-exec-1][IP:|USER:][INFO  com.cff.springbootwork.aspectj.OperateLogAspect] 方法为:getIpInfo, 这是一个前置测试 
2020-09-02 15:36:59,761 [http-nio-8086-exec-1][IP:|USER:][INFO  com.cff.springbootwork.aspectj.service.BusinessService] 进入getIpInfo方法。
2020-09-02 15:36:59,765 [http-nio-8086-exec-1][IP:|USER:][INFO  com.cff.springbootwork.aspectj.OperateLogAspect] 执行时间：10
2020-09-02 15:36:59,766 [http-nio-8086-exec-1][IP:|USER:][INFO  com.cff.springbootwork.aspectj.OperateLogAspect] 方法为:getIpInfo, 这是一个后置测试 
2020-09-02 15:36:59,766 [http-nio-8086-exec-1][IP:|USER:][INFO  com.cff.springbootwork.aspectj.OperateLogAspect] 方法为：getIpInfo，目标方法执行结果为：IpModel [clientIpAddress=10.4.45.120, serverIpAddress=10.4.45.120]

五、切面表达式浅谈

execution(<修饰符模式>? <返回类型模式> <方法名模式>(<参数模式>) <异常模式>?) 除了返回类型模式、方法名模式和参数模式外，其它项都是可选的。

？表示可省略，

修饰符模式如public、protected等；

返回类型模式表示方法返回类型；

方法名模式表示类+方法；

参数模式表示参数；

异常模式表示抛出的异常；

表达式中，可以使用*来代表任意字符，用..来表示任意个参数。

示例：

execution(* com.cff.springbootwork.aspectj.service.BusinessService.*(..))

切面表达式是从execution开始的，()内是表达式主体。
第一个号：表示返回类型，号表示所有的类型。
com.cff.springbootwork.aspectj.service.BusinessService.*表示匹配该类的所有方法。
(..)表示参数个数任意。
多个execution可以合并，可以使用||、&&等进行连接。

六、测试用的其他类

AspectJTestServerRest:

package com.cff.springbootwork.aspectj.web;

import javax.servlet.http.HttpServletRequest;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.cff.springbootwork.aspectj.service.BusinessService;
import com.cff.springbootwork.dto.IpModel;
import com.cff.springbootwork.dto.ResultModel;

@RestController
@RequestMapping("/asp")
public class AspectJTestServerRest {
    @Autowired
    private BusinessService businessService;

    @RequestMapping(value = "/ip", method = { RequestMethod.GET })
    public ResultModel welCome(HttpServletRequest request) {
        IpModel ipModel = businessService.getIpInfo(request, 1);
        return ResultModel.ok(ipModel);
    }

    @RequestMapping(value = "/test", method = { RequestMethod.GET })
    public ResultModel test(HttpServletRequest request) {
        Integer ipModel = businessService.getTestInfo(1);
        return ResultModel.ok(ipModel);
    }
}

IpModel:

package com.cff.springbootwork.dto;

public class IpModel {
    private String clientIpAddress;
    private String serverIpAddress;

    public String getClientIpAddress() {
        return clientIpAddress;
    }

    public void setClientIpAddress(String clientIpAddress) {
        this.clientIpAddress = clientIpAddress;
    }

    public String getServerIpAddress() {
        return serverIpAddress;
    }

    public void setServerIpAddress(String serverIpAddress) {
        this.serverIpAddress = serverIpAddress;
    }

    @Override
    public String toString() {
        return "IpModel [clientIpAddress=" + clientIpAddress + ", serverIpAddress=" + serverIpAddress + "]";
    }
}

IPUtil:

package com.cff.springbootwork.aspectj.util;

import java.net.InetAddress;
import java.net.UnknownHostException;

import javax.servlet.http.HttpServletRequest;

public class IPUtil {
    /**
     * @Description: 获取客户端IP地址
     */
    public static String getIpAddr(HttpServletRequest request) {
        String ip = request.getHeader("x-forwarded-for");
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
            if (ip.equals("127.0.0.1")) {
                // 根据网卡取本机配置的IP
                InetAddress inet = null;
                try {
                    inet = InetAddress.getLocalHost();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                ip = inet.getHostAddress();
            }
        }
        // 多个代理的情况，第一个IP为客户端真实IP,多个IP按照','分割
        if (ip != null && ip.length() > 15) {
            if (ip.indexOf(",") > 0) {
                ip = ip.substring(0, ip.indexOf(","));
            }
        }
        return ip;
    }

    /**
     * 获取的是本地的IP地址
     * 
     * @return
     */
    public static String localIp() {
        String result = "";
        try {
            InetAddress address = InetAddress.getLocalHost();
            result = address.getHostAddress();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
        return result;
    }
}

ResultModel:

package com.cff.springbootwork.dto;

/**
 * @author cff
 */
public class ResultModel {

    private String errorCode;
    private String message;
    private Object data;

    public ResultModel() {

    }

    public ResultModel(String errorCode, String message) {
        this.errorCode = errorCode;
        this.message = message;
    }

    public ResultModel(String errorCode, String message, Object data) {
        this.errorCode = errorCode;
        this.message = message;
        this.data = data;
    }

    public String geterrorCode() {
        return errorCode;
    }

    public void seterrorCode(String errorCode) {
        this.errorCode = errorCode;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public static ResultModel ok(Object data) {
        return new ResultModel("0000", "成功", data);
    }

    public static ResultModel error(String msg) {
        return new ResultModel("1111", msg);
    }

    public static ResultModel error(String msg, Object data) {
        return new ResultModel("1111", msg, data);
    }
}

品茗IT-博客专题:https://www.pomit.cn/lecture.html汇总了Spring专题、Springboot专题、SpringCloud专题、web基础配置专题。

快速构建项目

Spring项目快速开发工具：

一键快速构建Spring项目工具

一键快速构建SpringBoot项目工具

一键快速构建SpringCloud项目工具

一站式Springboot项目生成

Mysql一键生成Mybatis注解Mapper

Spring组件化构建

SpringBoot组件化构建

SpringCloud服务化构建