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

时间:2022-07-24
本文章向大家介绍SpringBoot入门建站全系列（三十六）AspectJ做AOP日志管理，主要内容包括其使用实例、应用技巧、基本知识点总结和需要注意事项，具有一定的参考价值，需要的朋友可以参考一下。

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;
	}
}

这里，

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

四、运行结果

测试中，我调用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.*(..))
  1. 切面表达式是从execution开始的，()内是表达式主体。
  2. 第一个号：表示返回类型，号表示所有的类型。
  3. com.cff.springbootwork.aspectj.service.BusinessService.*表示匹配该类的所有方法。
  4. (..)表示参数个数任意。
  5. 多个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);
	}
}

随机文章
java知识点必读
最近更新