Spring AOP的注解实现（自定义注解实现日志管理）

一、AOP 与 Spring AOP

AOP： Aspect Oriented Programming（⾯向方⾯编程）。是一种对某一类事情集中处理的思想。
Spring AOP： 就是对AOP思想的一种实现。

AOP的基本概念

Aspect(切面): 其实就是我们定义的切面类，里面可以定义切入点表达式和前后通知
Pointcut(切点): 就是带有通知的连接点，在程序中主要体现为书写切入点表达式
JointPoint(连接点): 程序执行过程中被切面拦截的点，这个点可以是方法也可以是类
Advice(通知): AOP在特定的切入点上执行的增强处理：before,after,afterReturning,afterThrowing,around
AOP代理： AOP框架创建的对象，代理就是目标对象的加强。Spring中的AOP代理可以使JDK动态代理，也可以是CGLIB代理，前者基于接口，后者基于子类

二、Spring AOP简单实现

引入依赖：

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

写AOP实现：

• 类使用注解@Aspect修饰
• 方法参数为ProceedingJoinPoint 类，代表要实现的方法（只能在Around通知下写）
• 方法使用注解@Around，参数是对应的路径的切点
• ProceedingJoinPoint 的参数执行proceed方法。

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;@Aspect
@Component
@Slf4j
public class TimeAspect {@Around("execution(* com.example.library.controller.*.*(..) )")public Object recordTime(ProceedingJoinPoint  proceedingJoinPoint) throws Throwable {//开始时间long start = System.currentTimeMillis();//执行方法Object result = proceedingJoinPoint.proceed();//结束时间long end = System.currentTimeMillis();log.info("执行时间："+ (end-start) + "ms");return result;}
}

三、详解Spring AOP

3.1 Spring AOP 核心概念

Spring AOP 核心概念：切点，连接点，通知，切面。

我们以上面的代码来介绍。

3.1.1 切点（Pointcut）

切点：就是告诉程序哪些方法需要使用到接下来的功能。
上面的@Around注解的参数就是切点表达式。

3.1.2 连接点（Join Point）

连接点：满⾜切点表达式规则的⽅法，就是连接点。也就是可以AOP控制的⽅法。

就像上面的代码的连接点就是：com.example.library.controller路径下的所有方法。

切点和连接点的关系：

• 连接点是满⾜切点表达式的元素。
• 切点可以看做是保存了众多连接点的⼀个集合。

3.1.3 通知（Advice）

通知：这个Spring AOP方法要实现的功能就是通知。

就像上面的实现一个统计每个接口的用时的需求，就是通知。

3.1.4 切面（Aspect）

切⾯(Aspect) = 切点(Pointcut) + 通知(Advice)。

通过切⾯就能够描述当前AOP程序需要针对于哪些⽅法，在什么时候执⾏什么样的操作。
切⾯既包含了通知逻辑的定义，也包括了连接点的定义。

3.2 通知类型

Spring中AOP的通知类型有以下⼏种：

@Around： 环绕通知，此注解标注的通知⽅法在⽬标⽅法前，后都被执⾏。 @Before：前置通知，此注解标注的通知⽅法在⽬标⽅法前被执⾏。
@After： 后置通知，此注解标注的通知⽅法在⽬标⽅法后被执⾏，⽆论是否有异常都会执⾏。
@AfterReturning： 返回后通知，此注解标注的通知⽅法在⽬标⽅法后被执⾏，有异常不会执⾏。
@AfterThrowing： 异常后通知，此注解标注的通知⽅法发⽣异常后执⾏。

package com.example.demoaop;import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;@Component
@Slf4j
@Aspect
public class TestAspect {//前置通知@Before("execution(* com.example.demoaop.*.*(..) )")public void testBefore() {log.info("Before 方法执行前");}//后置通知@After("execution(* com.example.demoaop.*.*(..) )")public void testAfter() {log.info("After 方法执行后");}//返回后通知@AfterReturning("execution(* com.example.demoaop.*.*(..) )")public void testAfterReturning() {log.info("AfterReturning 返回后通知");}//抛出异常后通知@AfterThrowing("execution(* com.example.demoaop.*.*(..) )")public void testAfterThrowing() {log.info("AfterThrowing 抛出异常后通知");}//环绕通知@Around("execution(* com.example.demoaop.*.*(..) )")public void testAround(ProceedingJoinPoint pjp) throws Throwable {log.info("Around 方法执行前");Object proceed = pjp.proceed();log.info("Around 方法执行后");}
}

3.3 公共切点引用@PointCut

当我们的切点表达式是一样的时候，像上面我们还是在每一个通知类型的注解中，都使用了相同的表达式。
我们就可以使用方法注解@PointCut将切点表达式提取出来，然后后面使用只需要写方法名即可。
在其他切点类中也可以调用，需要将@PointCut注解所在类的路径写出来。

package com.example.demoaop;import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;@Component
@Slf4j
@Aspect
public class TestAspect {@Pointcut("execution(* com.example.demoaop.*.*(..) )")public void pc(){}//前置通知@Before("pc()")public void testBefore() {log.info("TestAspect Before 方法执行前");}//后置通知@After("pc()")public void testAfter() {log.info("TestAspect After 方法执行后");}
}

package com.example.demoaop;import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;@Component
@Slf4j
@Aspect
public class TestAspect2 {//前置通知@Before("com.example.demoaop.TestAspect.pc()")public void testBefore() {log.info("TestAspect2 Before 方法执行前");}//后置通知@After("pc()")public void testAfter() {log.info("TestAspect2 After 方法执行后");}}

结果：
可以看见生效了，而且在其他切点类中只有加上了路径的才生效了。

3.4 切点优先级@Order

我们定义3个一样的切点类，看他们的输出顺序：

存在多个切⾯类时,默认按照切⾯类的类名字⺟排序：

@Before 通知： 字⺟排名靠前的先执⾏
@After 通知： 字⺟排名靠前的后执⾏
但这种⽅式不⽅便管理，我们的类名更多还是具备⼀定含义的。
Spring 给我们提供了⼀个新的注解，来控制这些切⾯通知的执⾏顺序：@Order

我们将切点类的优先级换一下：

@Component
@Slf4j
@Aspect
@Order(1)
public class TestAspect3 {//前置通知@Before("com.example.demoaop.TestAspect.pc()")public void testBefore() {log.info("TestAspect3 Before 方法执行前");}//后置通知@After("com.example.demoaop.TestAspect.pc()")public void testAfter() {log.info("TestAspect3 After 方法执行后");}}

@Component
@Slf4j
@Aspect
@Order(2)
public class TestAspect2 {//前置通知@Before("com.example.demoaop.TestAspect.pc()")public void testBefore() {log.info("TestAspect2 Before 方法执行前");}//后置通知@After("com.example.demoaop.TestAspect.pc()")public void testAfter() {log.info("TestAspect2 After 方法执行后");}}

@Component
@Slf4j
@Aspect
@Order(3)
public class TestAspect {@Pointcut("execution(* com.example.demoaop.*.*(..) )")public void pc(){}//前置通知@Before("pc()")public void testBefore() {log.info("TestAspect Before 方法执行前");}//后置通知@After("pc()")public void testAfter() {log.info("TestAspect After 方法执行后");}
}

规律：
@Order 注解标识的切⾯类，执⾏顺序如下:
@Before 通知： 数字越⼩先执⾏
@After 通知： 数字越⼤先执⾏

3.5 切点表达式
切点表达式用来描述切点，常有以下两种类型的切点表达式：execution 和 @annotation

3.5.1 execution

语法：

execution(<访问修饰限定符> <返回类型> <包名.类名.方法名(方法参数)> <异常>)

含义：

访问修饰限定符：表示切点对应的方法的访问修饰限定符
返回类型：表示切点对应的方法的返回类型
包名.类名.方法名(方法参数)：表示切点对应的方法的路径及参数
异常：表示切点对应的方法抛出的异常
访问修饰限定符 和 异常 可以省略

切点表达式⽀持通配符表达：
*匹配任意字符，只匹配⼀个元素(返回类型，包，类名，⽅法或者⽅法参数)
1.1. 包名使⽤ * 表⽰任意包(⼀层包使⽤⼀个 * )
1.2. 类名使⽤ * 表⽰任意类
1.3. 返回值使⽤ * 表⽰任意返回值类型
1.4. ⽅法名使⽤ * 表⽰任意⽅法
1.5. 参数使⽤ * 表⽰⼀个任意类型的参数
两个点 . . 匹配多个连续的任意符号,可以通配任意层级的包，或任意类型，任意个数的参数
2.1. 使⽤ . . 配置包名，标识此包以及此包下的所有⼦包
2.2. 可以使⽤ . . 配置参数，任意个任意类型的参数

例子：

• TestController 下的 public修饰，返回类型为String ⽅法名为t1的⽆参⽅法

execution(public String com.example.demo.TestController.t1())

• 匹配 TestController 下的所有⽆参⽅法

execution(* com.example.demo.TestController.*())

• 匹配controller包下所有的类的所有⽅法

execution(* com.example.demo.controller.*.*(..))

3.5.2 @annotation

当我们要落实到不同类下个几个方法，用上面的execution就有点捉襟见肘。
我们就可以使用⾃定义注解的⽅式以及另⼀种切点表达式 @annotation 来描述这⼀类的切点。

自定义注解：

四、自定义注解

使用AOP和注解实现操作日志记录

在SpringBoot项目中，通过AOP（面向切面编程）和自定义注解来实现操作日志记录具有诸多好处：

• 分离关注点：将日志记录逻辑从业务代码中分离出来，保持代码的清洁和可维护性。
• 减少重复代码：避免在每个业务方法中手动添加日志记录代码，提升开发效率。
• 灵活性与可配置性：通过注解配置不同的日志记录需求，灵活应对各种场景。
• 统一管理与维护：集中管理日志记录逻辑，方便后续的功能扩展和维护。

准备工作

4.1 创建操作日志记录表

CREATE TABLE `sys_oper_log` (`oper_id` bigint NOT NULL AUTO_INCREMENT COMMENT '日志主键',`title` varchar(50) DEFAULT '' COMMENT '模块标题',`business_type` int DEFAULT '0' COMMENT '业务类型（0其它 1新增 2修改 3删除）',`method` varchar(200) DEFAULT '' COMMENT '方法名称',`request_method` varchar(10) DEFAULT '' COMMENT '请求方式',`operator_type` int DEFAULT '0' COMMENT '操作类别（0其它 1后台用户 2手机端用户）',`oper_name` varchar(50) DEFAULT '' COMMENT '操作人员',`dept_name` varchar(50) DEFAULT '' COMMENT '部门名称',`oper_url` varchar(255) DEFAULT '' COMMENT '请求URL',`oper_ip` varchar(128) DEFAULT '' COMMENT '主机地址',`oper_location` varchar(255) DEFAULT '' COMMENT '操作地点',`oper_param` varchar(2000) DEFAULT '' COMMENT '请求参数',`json_result` varchar(2000) DEFAULT '' COMMENT '返回参数',`status` int DEFAULT '0' COMMENT '操作状态（0正常 1异常）',`error_msg` varchar(2000) DEFAULT '' COMMENT '错误消息',`oper_time` datetime DEFAULT NULL COMMENT '操作时间',`cost_time` bigint DEFAULT '0' COMMENT '消耗时间',PRIMARY KEY (`oper_id`),KEY `idx_sys_oper_log_bt` (`business_type`),KEY `idx_sys_oper_log_s` (`status`),KEY `idx_sys_oper_log_ot` (`oper_time`)
) ENGINE=InnoDB AUTO_INCREMENT=146 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='操作日志记录';

4.2 创建系统日志实体类

/*** 操作日志记录** @date 2024/07/14*/
@Data
@Schema(description = "操作日志记录")
public class SysOperLog implements Serializable {private static final long serialVersionUID = 1L;/*** 日志主键*/private Long operId;/*** 操作模块*/private String title;/*** 业务类型（0其它 1新增 2修改 3删除）*/private Integer businessType;/*** 业务类型数组*/private Integer[] businessTypes;/*** 请求方法*/private String method;/*** 请求方式*/private String requestMethod;/*** 操作类别（0其它 1后台用户 2手机端用户）*/private Integer operatorType;/*** 操作人员*/private String operName;/*** 部门名称*/private String deptName;/*** 请求url*/private String operUrl;/*** 操作地址*/private String operIp;/*** 操作地点*/private String operLocation;/*** 请求参数*/private String operParam;/*** 返回参数*/private String jsonResult;/*** 操作状态（0正常 1异常）*/private Integer status;/*** 错误消息*/private String errorMsg;/*** 操作时间*/@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")private Date operTime;/*** 消耗时间*/private Long costTime;public Long getOperId() {return operId;}public void setOperId(Long operId) {this.operId = operId;}public String getTitle() {return title;}public void setTitle(String title) {this.title = title;}public Integer getBusinessType() {return businessType;}public void setBusinessType(Integer businessType) {this.businessType = businessType;}public Integer[] getBusinessTypes() {return businessTypes;}public void setBusinessTypes(Integer[] businessTypes) {this.businessTypes = businessTypes;}public String getMethod() {return method;}public void setMethod(String method) {this.method = method;}public String getRequestMethod() {return requestMethod;}public void setRequestMethod(String requestMethod) {this.requestMethod = requestMethod;}public Integer getOperatorType() {return operatorType;}public void setOperatorType(Integer operatorType) {this.operatorType = operatorType;}public String getOperName() {return operName;}public void setOperName(String operName) {this.operName = operName;}public String getDeptName() {return deptName;}public void setDeptName(String deptName) {this.deptName = deptName;}public String getOperUrl() {return operUrl;}public void setOperUrl(String operUrl) {this.operUrl = operUrl;}public String getOperIp() {return operIp;}public void setOperIp(String operIp) {this.operIp = operIp;}public String getOperLocation() {return operLocation;}public void setOperLocation(String operLocation) {this.operLocation = operLocation;}public String getOperParam() {return operParam;}public void setOperParam(String operParam) {this.operParam = operParam;}public String getJsonResult() {return jsonResult;}public void setJsonResult(String jsonResult) {this.jsonResult = jsonResult;}public Integer getStatus() {return status;}public void setStatus(Integer status) {this.status = status;}public String getErrorMsg() {return errorMsg;}public void setErrorMsg(String errorMsg) {this.errorMsg = errorMsg;}public Date getOperTime() {return operTime;}public void setOperTime(Date operTime) {this.operTime = operTime;}public Long getCostTime() {return costTime;}public void setCostTime(Long costTime) {this.costTime = costTime;}}

代码实现

创建业务枚举类

/*** 操作状态* */
public enum BusinessStatus
{/*** 成功*/SUCCESS,/*** 失败*/FAIL,
}

/*** 业务操作类型**/
public enum BusinessType {/*** 其它*/OTHER,/*** 新增*/INSERT,/*** 修改*/UPDATE,/*** 删除*/DELETE,/*** 授权*/GRANT,/*** 导出*/EXPORT,/*** 导入*/IMPORT,/*** 强退*/FORCE,/*** 生成代码*/GENCODE,/*** 清空数据*/CLEAN,}

/*** 操作人类别**/
public enum OperatorType {/*** 其它*/OTHER,/*** 后台用户*/MANAGE,/*** 手机端用户*/MOBILE
}

创建日志自定义注解

import com.project.log.enums.BusinessType;
import com.project.log.enums.OperatorType;import java.lang.annotation.*;/*** 自定义操作日志记录注解**/
@Target({ElementType.PARAMETER, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Log {/*** 模块*/public String title() default "";/*** 功能*/public BusinessType businessType() default BusinessType.OTHER;/*** 操作人类别*/public OperatorType operatorType() default OperatorType.MANAGE;/*** 是否保存请求的参数*/public boolean isSaveRequestData() default true;/*** 是否保存响应的参数*/public boolean isSaveResponseData() default true;/*** 排除指定的请求参数*/public String[] excludeParamNames() default {};
}

创建工具类

import com.project.log.Utils.ServletUtils;
import com.project.log.Utils.StringUtils;
import jakarta.servlet.http.HttpServletRequest;import java.net.InetAddress;
import java.net.UnknownHostException;/*** 获取IP方法**/
public class IpUtils {public final static String REGX_0_255 = "(25[0-5]|2[0-4]\\d|1\\d{2}|[1-9]\\d|\\d)";// 匹配 ippublic final static String REGX_IP = "((" + REGX_0_255 + "\\.){3}" + REGX_0_255 + ")";public final static String REGX_IP_WILDCARD = "(((\\*\\.){3}\\*)|(" + REGX_0_255 + "(\\.\\*){3})|(" + REGX_0_255 + "\\." + REGX_0_255 + ")(\\.\\*){2}" + "|((" + REGX_0_255 + "\\.){3}\\*))";// 匹配网段public final static String REGX_IP_SEG = "(" + REGX_IP + "\\-" + REGX_IP + ")";/*** 获取客户端IP** @return IP地址*/public static String getIpAddr() {return getIpAddr(ServletUtils.getRequest());}/*** 获取客户端IP** @param request 请求对象* @return IP地址*/public static String getIpAddr(HttpServletRequest request) {if (request == null) {return "unknown";}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("X-Forwarded-For");}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.getHeader("X-Real-IP");}if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {ip = request.getRemoteAddr();}return "0:0:0:0:0:0:0:1".equals(ip) ? "127.0.0.1" : getMultistageReverseProxyIp(ip);}/*** 检查是否为内部IP地址** @param ip IP地址* @return 结果*/public static boolean internalIp(String ip) {byte[] addr = textToNumericFormatV4(ip);return internalIp(addr) || "127.0.0.1".equals(ip);}/*** 检查是否为内部IP地址** @param addr byte地址* @return 结果*/private static boolean internalIp(byte[] addr) {if (StringUtils.isNull(addr) || addr.length < 2) {return true;}final byte b0 = addr[0];final byte b1 = addr[1];// 10.x.x.x/8final byte SECTION_1 = 0x0A;// 172.16.x.x/12final byte SECTION_2 = (byte) 0xAC;final byte SECTION_3 = (byte) 0x10;final byte SECTION_4 = (byte) 0x1F;// 192.168.x.x/16final byte SECTION_5 = (byte) 0xC0;final byte SECTION_6 = (byte) 0xA8;switch (b0) {case SECTION_1:return true;case SECTION_2:if (b1 >= SECTION_3 && b1 <= SECTION_4) {return true;}case SECTION_5:switch (b1) {case SECTION_6:return true;}default:return false;}}/*** 将IPv4地址转换成字节** @param text IPv4地址* @return byte 字节*/public static byte[] textToNumericFormatV4(String text) {if (text.length() == 0) {return null;}byte[] bytes = new byte[4];String[] elements = text.split("\\.", -1);try {long l;int i;switch (elements.length) {case 1:l = Long.parseLong(elements[0]);if ((l < 0L) || (l > 4294967295L)) {return null;}bytes[0] = (byte) (int) (l >> 24 & 0xFF);bytes[1] = (byte) (int) ((l & 0xFFFFFF) >> 16 & 0xFF);bytes[2] = (byte) (int) ((l & 0xFFFF) >> 8 & 0xFF);bytes[3] = (byte) (int) (l & 0xFF);break;case 2:l = Integer.parseInt(elements[0]);if ((l < 0L) || (l > 255L)) {return null;}bytes[0] = (byte) (int) (l & 0xFF);l = Integer.parseInt(elements[1]);if ((l < 0L) || (l > 16777215L)) {return null;}bytes[1] = (byte) (int) (l >> 16 & 0xFF);bytes[2] = (byte) (int) ((l & 0xFFFF) >> 8 & 0xFF);bytes[3] = (byte) (int) (l & 0xFF);break;case 3:for (i = 0; i < 2; ++i) {l = Integer.parseInt(elements[i]);if ((l < 0L) || (l > 255L)) {return null;}bytes[i] = (byte) (int) (l & 0xFF);}l = Integer.parseInt(elements[2]);if ((l < 0L) || (l > 65535L)) {return null;}bytes[2] = (byte) (int) (l >> 8 & 0xFF);bytes[3] = (byte) (int) (l & 0xFF);break;case 4:for (i = 0; i < 4; ++i) {l = Integer.parseInt(elements[i]);if ((l < 0L) || (l > 255L)) {return null;}bytes[i] = (byte) (int) (l & 0xFF);}break;default:return null;}} catch (NumberFormatException e) {return null;}return bytes;}/*** 获取IP地址** @return 本地IP地址*/public static String getHostIp() {try {return InetAddress.getLocalHost().getHostAddress();} catch (UnknownHostException e) {}return "127.0.0.1";}/*** 获取主机名** @return 本地主机名*/public static String getHostName() {try {return InetAddress.getLocalHost().getHostName();} catch (UnknownHostException e) {}return "未知";}/*** 从多级反向代理中获得第一个非unknown IP地址** @param ip 获得的IP地址* @return 第一个非unknown IP地址*/public static String getMultistageReverseProxyIp(String ip) {// 多级反向代理检测if (ip != null && ip.indexOf(",") > 0) {final String[] ips = ip.trim().split(",");for (String subIp : ips) {if (false == isUnknown(subIp)) {ip = subIp;break;}}}return StringUtils.substring(ip, 0, 255);}/*** 检测给定字符串是否为未知，多用于检测HTTP请求相关** @param checkString 被检测的字符串* @return 是否未知*/public static boolean isUnknown(String checkString) {return StringUtils.isBlank(checkString) || "unknown".equalsIgnoreCase(checkString);}/*** 是否为IP*/public static boolean isIP(String ip) {return StringUtils.isNotBlank(ip) && ip.matches(REGX_IP);}/*** 是否为IP，或 *为间隔的通配符地址*/public static boolean isIpWildCard(String ip) {return StringUtils.isNotBlank(ip) && ip.matches(REGX_IP_WILDCARD);}/*** 检测参数是否在ip通配符里*/public static boolean ipIsInWildCardNoCheck(String ipWildCard, String ip) {String[] s1 = ipWildCard.split("\\.");String[] s2 = ip.split("\\.");boolean isMatchedSeg = true;for (int i = 0; i < s1.length && !s1[i].equals("*"); i++) {if (!s1[i].equals(s2[i])) {isMatchedSeg = false;break;}}return isMatchedSeg;}/*** 是否为特定格式如:“10.10.10.1-10.10.10.99”的ip段字符串*/public static boolean isIPSegment(String ipSeg) {return StringUtils.isNotBlank(ipSeg) && ipSeg.matches(REGX_IP_SEG);}/*** 判断ip是否在指定网段中*/public static boolean ipIsInNetNoCheck(String iparea, String ip) {int idx = iparea.indexOf('-');String[] sips = iparea.substring(0, idx).split("\\.");String[] sipe = iparea.substring(idx + 1).split("\\.");String[] sipt = ip.split("\\.");long ips = 0L, ipe = 0L, ipt = 0L;for (int i = 0; i < 4; ++i) {ips = ips << 8 | Integer.parseInt(sips[i]);ipe = ipe << 8 | Integer.parseInt(sipe[i]);ipt = ipt << 8 | Integer.parseInt(sipt[i]);}if (ips > ipe) {long t = ips;ips = ipe;ipe = t;}return ips <= ipt && ipt <= ipe;}/*** 校验ip是否符合过滤串规则** @param filter 过滤IP列表,支持后缀'*'通配,支持网段如:`10.10.10.1-10.10.10.99`* @param ip     校验IP地址* @return boolean 结果*/public static boolean isMatchedIp(String filter, String ip) {if (StringUtils.isEmpty(filter) || StringUtils.isEmpty(ip)) {return false;}String[] ips = filter.split(";");for (String iStr : ips) {if (isIP(iStr) && iStr.equals(ip)) {return true;} else if (isIpWildCard(iStr) && ipIsInWildCardNoCheck(iStr, ip)) {return true;} else if (isIPSegment(iStr) && ipIsInNetNoCheck(iStr, ip)) {return true;}}return false;}
}

import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.nio.ByteBuffer;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.text.NumberFormat;
import java.util.Set;/*** 类型转换器**/
public class Convert {/*** 转换为字符串<br>* 如果给定的值为null，或者转换失败，返回默认值<br>* 转换失败不会报错** @param value        被转换的值* @param defaultValue 转换错误时的默认值* @return 结果*/public static String toStr(Object value, String defaultValue) {if (null == value) {return defaultValue;}if (value instanceof String) {return (String) value;}return value.toString();}/*** 转换为字符串<br>* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>* 转换失败不会报错** @param value 被转换的值* @return 结果*/public static String toStr(Object value) {return toStr(value, null);}/*** 转换为字符<br>* 如果给定的值为null，或者转换失败，返回默认值<br>* 转换失败不会报错** @param value        被转换的值* @param defaultValue 转换错误时的默认值* @return 结果*/public static Character toChar(Object value, Character defaultValue) {if (null == value) {return defaultValue;}if (value instanceof Character) {return (Character) value;}final String valueStr = toStr(value, null);return StringUtils.isEmpty(valueStr) ? defaultValue : valueStr.charAt(0);}/*** 转换为字符<br>* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>* 转换失败不会报错** @param value 被转换的值* @return 结果*/public static Character toChar(Object value) {return toChar(value, null);}/*** 转换为byte<br>* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<br>* 转换失败不会报错** @param value        被转换的值* @param defaultValue 转换错误时的默认值* @return 结果*/public static Byte toByte(Object value, Byte defaultValue) {if (value == null) {return defaultValue;}if (value instanceof Byte) {return (Byte) value;}if (value instanceof Number) {return ((Number) value).byteValue();}final String valueStr = toStr(value, null);if (StringUtils.isEmpty(valueStr)) {return defaultValue;}try {return Byte.parseByte(valueStr);} catch (Exception e) {return defaultValue;}}/*** 转换为byte<br>* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>* 转换失败不会报错** @param value 被转换的值* @return 结果*/public static Byte toByte(Object value) {return toByte(value, null);}/*** 转换为Short<br>* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<br>* 转换失败不会报错** @param value        被转换的值* @param defaultValue 转换错误时的默认值* @return 结果*/public static Short toShort(Object value, Short defaultValue) {if (value == null) {return defaultValue;}if (value instanceof Short) {return (Short) value;}if (value instanceof Number) {return ((Number) value).shortValue();}final String valueStr = toStr(value, null);if (StringUtils.isEmpty(valueStr)) {return defaultValue;}try {return Short.parseShort(valueStr.trim());} catch (Exception e) {return defaultValue;}}/*** 转换为Short<br>* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>* 转换失败不会报错** @param value 被转换的值* @return 结果*/public static Short toShort(Object value) {return toShort(value, null);}/*** 转换为Number<br>* 如果给定的值为空，或者转换失败，返回默认值<br>* 转换失败不会报错** @param value        被转换的值* @param defaultValue 转换错误时的默认值* @return 结果*/public static Number toNumber(Object value, Number defaultValue) {if (value == null) {return defaultValue;}if (value instanceof Number) {return (Number) value;}final String valueStr = toStr(value, null);if (StringUtils.isEmpty(valueStr)) {return defaultValue;}try {return NumberFormat.getInstance().parse(valueStr);} catch (Exception e) {return defaultValue;}}/*** 转换为Number<br>* 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>* 转换失败不会报错** @param value 被转换的值* @return 结果*/public static Number toNumber(Object value) {return toNumber(value, null);}/*** 转换为int<br>* 如果给定的值为空，或者转换失败，返回默认值<br>* 转换失败不会报错** @param value        被转换的值* @param defaultValue 转换错误时的默认值* @return 结果*/public static Integer toInt(Object value, Integer defaultValue) {if (value == null) {return defaultValue;}if (value instanceof Integer) {return (Integer) value;}if (value instanceof Number) {return ((Number) value).intValue();}final String valueStr = toStr(value, null);if (StringUtils.isEmpty(valueStr)) {return defaultValue;}try {return Integer.parseInt(valueStr.trim());} catch (Exception e) {return defaultValue;}}/*** 转换为int<br>* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>* 转换失败不会报错** @param value 被转换的值* @return 结果*/public static Integer toInt(Object value) {return toInt(value, null);}/*** 转换为Integer数组<br>** @param str 被转换的值* @return 结果*/public static Integer[] toIntArray(String str) {return toIntArray(",", str);}/*** 转换为Long数组<br>** @param str 被转换的值* @return 结果*/public static Long[] toLongArray(String str) {return toLongArray(",", str);}/*** 转换为Integer数组<br>** @param split 分隔符* @param split 被转换的值* @return 结果*/public static Integer[] toIntArray(String split, String str) {if (StringUtils.isEmpty(str)) {return new Integer[]{};}String[] arr = str.split(split);final Integer[] ints = new Integer[arr.length];for (int i = 0; i < arr.length; i++) {final Integer v = toInt(arr[i], 0);ints[i] = v;}return ints;}/*** 转换为Long数组<br>** @param split 分隔符* @param str   被转换的值* @return 结果*/public static Long[] toLongArray(String split, String str) {if (StringUtils.isEmpty(str)) {return new Long[]{};}String[] arr = str.split(split);final Long[] longs = new Long[arr.length];for (int i = 0; i < arr.length; i++) {final Long v = toLong(arr[i], null);longs[i] = v;}return longs;}/*** 转换为String数组<br>** @param str 被转换的值* @return 结果*/public static String[] toStrArray(String str) {if (StringUtils.isEmpty(str)) {return new String[]{};}return toStrArray(",", str);}/*** 转换为String数组<br>** @param split 分隔符* @param split 被转换的值* @return 结果*/public static String[] toStrArray(String split, String str) {return str.split(split);}/*** 转换为long<br>* 如果给定的值为空，或者转换失败，返回默认值<br>* 转换失败不会报错** @param value        被转换的值* @param defaultValue 转换错误时的默认值* @return 结果*/public static Long toLong(Object value, Long defaultValue) {if (value == null) {return defaultValue;}if (value instanceof Long) {return (Long) value;}if (value instanceof Number) {return ((Number) value).longValue();}final String valueStr = toStr(value, null);if (StringUtils.isEmpty(valueStr)) {return defaultValue;}try {// 支持科学计数法return new BigDecimal(valueStr.trim()).longValue();} catch (Exception e) {return defaultValue;}}/*** 转换为long<br>* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>* 转换失败不会报错** @param value 被转换的值* @return 结果*/public static Long toLong(Object value) {return toLong(value, null);}/*** 转换为double<br>* 如果给定的值为空，或者转换失败，返回默认值<br>* 转换失败不会报错** @param value        被转换的值* @param defaultValue 转换错误时的默认值* @return 结果*/public static Double toDouble(Object value, Double defaultValue) {if (value == null) {return defaultValue;}if (value instanceof Double) {return (Double) value;}if (value instanceof Number) {return ((Number) value).doubleValue();}final String valueStr = toStr(value, null);if (StringUtils.isEmpty(valueStr)) {return defaultValue;}try {// 支持科学计数法return new BigDecimal(valueStr.trim()).doubleValue();} catch (Exception e) {return defaultValue;}}/*** 转换为double<br>* 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>* 转换失败不会报错** @param value 被转换的值* @return 结果*/public static Double toDouble(Object value) {return toDouble(value, null);}/*** 转换为Float<br>* 如果给定的值为空，或者转换失败，返回默认值<br>* 转换失败不会报错** @param value        被转换的值* @param defaultValue 转换错误时的默认值* @return 结果*/public static Float toFloat(Object value, Float defaultValue) {if (value == null) {return defaultValue;}if (value instanceof Float) {return (Float) value;}if (value instanceof Number) {return ((Number) value).floatValue();}final String valueStr = toStr(value, null);if (StringUtils.isEmpty(valueStr)) {return defaultValue;}try {return Float.parseFloat(valueStr.trim());} catch (Exception e) {return defaultValue;}}/*** 转换为Float<br>* 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>* 转换失败不会报错** @param value 被转换的值* @return 结果*/public static Float toFloat(Object value) {return toFloat(value, null);}/*** 转换为boolean<br>* String支持的值为：true、false、yes、ok、no、1、0、是、否, 如果给定的值为空，或者转换失败，返回默认值<br>* 转换失败不会报错** @param value        被转换的值* @param defaultValue 转换错误时的默认值* @return 结果*/public static Boolean toBool(Object value, Boolean defaultValue) {if (value == null) {return defaultValue;}if (value instanceof Boolean) {return (Boolean) value;}String valueStr = toStr(value, null);if (StringUtils.isEmpty(valueStr)) {return defaultValue;}valueStr = valueStr.trim().toLowerCase();switch (valueStr) {case "true":case "yes":case "ok":case "1":case "是":return true;case "false":case "no":case "0":case "否":return false;default:return defaultValue;}}/*** 转换为boolean<br>* 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>* 转换失败不会报错** @param value 被转换的值* @return 结果*/public static Boolean toBool(Object value) {return toBool(value, null);}/*** 转换为Enum对象<br>* 如果给定的值为空，或者转换失败，返回默认值<br>** @param clazz        Enum的Class* @param value        值* @param defaultValue 默认值* @return Enum*/public static <E extends Enum<E>> E toEnum(Class<E> clazz, Object value, E defaultValue) {if (value == null) {return defaultValue;}if (clazz.isAssignableFrom(value.getClass())) {@SuppressWarnings("unchecked")E myE = (E) value;return myE;}final String valueStr = toStr(value, null);if (StringUtils.isEmpty(valueStr)) {return defaultValue;}try {return Enum.valueOf(clazz, valueStr);} catch (Exception e) {return defaultValue;}}/*** 转换为Enum对象<br>* 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>** @param clazz Enum的Class* @param value 值* @return Enum*/public static <E extends Enum<E>> E toEnum(Class<E> clazz, Object value) {return toEnum(clazz, value, null);}/*** 转换为BigInteger<br>* 如果给定的值为空，或者转换失败，返回默认值<br>* 转换失败不会报错** @param value        被转换的值* @param defaultValue 转换错误时的默认值* @return 结果*/public static BigInteger toBigInteger(Object value, BigInteger defaultValue) {if (value == null) {return defaultValue;}if (value instanceof BigInteger) {return (BigInteger) value;}if (value instanceof Long) {return BigInteger.valueOf((Long) value);}final String valueStr = toStr(value, null);if (StringUtils.isEmpty(valueStr)) {return defaultValue;}try {return new BigInteger(valueStr);} catch (Exception e) {return defaultValue;}}/*** 转换为BigInteger<br>* 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>* 转换失败不会报错** @param value 被转换的值* @return 结果*/public static BigInteger toBigInteger(Object value) {return toBigInteger(value, null);}/*** 转换为BigDecimal<br>* 如果给定的值为空，或者转换失败，返回默认值<br>* 转换失败不会报错** @param value        被转换的值* @param defaultValue 转换错误时的默认值* @return 结果*/public static BigDecimal toBigDecimal(Object value, BigDecimal defaultValue) {if (value == null) {return defaultValue;}if (value instanceof BigDecimal) {return (BigDecimal) value;}if (value instanceof Long) {return new BigDecimal((Long) value);}if (value instanceof Double) {return BigDecimal.valueOf((Double) value);}if (value instanceof Integer) {return new BigDecimal((Integer) value);}final String valueStr = toStr(value, null);if (StringUtils.isEmpty(valueStr)) {return defaultValue;}try {return new BigDecimal(valueStr);} catch (Exception e) {return defaultValue;}}/*** 转换为BigDecimal<br>* 如果给定的值为空，或者转换失败，返回默认值<br>* 转换失败不会报错** @param value 被转换的值* @return 结果*/public static BigDecimal toBigDecimal(Object value) {return toBigDecimal(value, null);}/*** 将对象转为字符串<br>* 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法** @param obj 对象* @return 字符串*/public static String utf8Str(Object obj) {return str(obj, StandardCharsets.UTF_8);}/*** 将对象转为字符串<br>* 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法** @param obj         对象* @param charsetName 字符集* @return 字符串*/public static String str(Object obj, String charsetName) {return str(obj, Charset.forName(charsetName));}/*** 将对象转为字符串<br>* 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法** @param obj     对象* @param charset 字符集* @return 字符串*/public static String str(Object obj, Charset charset) {if (null == obj) {return null;}if (obj instanceof String) {return (String) obj;} else if (obj instanceof byte[] || obj instanceof Byte[]) {if (obj instanceof byte[]) {return str((byte[]) obj, charset);} else {Byte[] bytes = (Byte[]) obj;int length = bytes.length;byte[] dest = new byte[length];for (int i = 0; i < length; i++) {dest[i] = bytes[i];}return str(dest, charset);}} else if (obj instanceof ByteBuffer) {return str((ByteBuffer) obj, charset);}return obj.toString();}/*** 将byte数组转为字符串** @param bytes   byte数组* @param charset 字符集* @return 字符串*/public static String str(byte[] bytes, String charset) {return str(bytes, StringUtils.isEmpty(charset) ? Charset.defaultCharset() : Charset.forName(charset));}/*** 解码字节码** @param data    字符串* @param charset 字符集，如果此字段为空，则解码的结果取决于平台* @return 解码后的字符串*/public static String str(byte[] data, Charset charset) {if (data == null) {return null;}if (null == charset) {return new String(data);}return new String(data, charset);}/*** 将编码的byteBuffer数据转换为字符串** @param data    数据* @param charset 字符集，如果为空使用当前系统字符集* @return 字符串*/public static String str(ByteBuffer data, String charset) {if (data == null) {return null;}return str(data, Charset.forName(charset));}/*** 将编码的byteBuffer数据转换为字符串** @param data    数据* @param charset 字符集，如果为空使用当前系统字符集* @return 字符串*/public static String str(ByteBuffer data, Charset charset) {if (null == charset) {charset = Charset.defaultCharset();}return charset.decode(data).toString();}// ----------------------------------------------------------------------- 全角半角转换/*** 半角转全角** @param input String.* @return 全角字符串.*/public static String toSBC(String input) {return toSBC(input, null);}/*** 半角转全角** @param input         String* @param notConvertSet 不替换的字符集合* @return 全角字符串.*/public static String toSBC(String input, Set<Character> notConvertSet) {char[] c = input.toCharArray();for (int i = 0; i < c.length; i++) {if (null != notConvertSet && notConvertSet.contains(c[i])) {// 跳过不替换的字符continue;}if (c[i] == ' ') {c[i] = '\u3000';} else if (c[i] < '\177') {c[i] = (char) (c[i] + 65248);}}return new String(c);}/*** 全角转半角** @param input String.* @return 半角字符串*/public static String toDBC(String input) {return toDBC(input, null);}/*** 替换全角为半角** @param text          文本* @param notConvertSet 不替换的字符集合* @return 替换后的字符*/public static String toDBC(String text, Set<Character> notConvertSet) {char[] c = text.toCharArray();for (int i = 0; i < c.length; i++) {if (null != notConvertSet && notConvertSet.contains(c[i])) {// 跳过不替换的字符continue;}if (c[i] == '\u3000') {c[i] = ' ';} else if (c[i] > '\uFF00' && c[i] < '\uFF5F') {c[i] = (char) (c[i] - 65248);}}return new String(c);}/*** 数字金额大写转换 先写个完整的然后将如零拾替换成零** @param n 数字* @return 中文大写数字*/public static String digitUppercase(double n) {String[] fraction = {"角", "分"};String[] digit = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};String[][] unit = {{"元", "万", "亿"}, {"", "拾", "佰", "仟"}};String head = n < 0 ? "负" : "";n = Math.abs(n);String s = "";for (int i = 0; i < fraction.length; i++) {// 优化double计算精度丢失问题BigDecimal nNum = new BigDecimal(n);BigDecimal decimal = new BigDecimal(10);BigDecimal scale = nNum.multiply(decimal).setScale(2, RoundingMode.HALF_EVEN);double d = scale.doubleValue();s += (digit[(int) (Math.floor(d * Math.pow(10, i)) % 10)] + fraction[i]).replaceAll("(零.)+", "");}if (s.length() < 1) {s = "整";}int integerPart = (int) Math.floor(n);for (int i = 0; i < unit[0].length && integerPart > 0; i++) {String p = "";for (int j = 0; j < unit[1].length && n > 0; j++) {p = digit[integerPart % 10] + unit[1][j] + p;integerPart = integerPart / 10;}s = p.replaceAll("(零.)*零$", "").replaceAll("^$", "零") + unit[0][i] + s;}return head + s.replaceAll("(零.)*零元", "元").replaceFirst("(零.)+", "").replaceAll("(零.)+", "零").replaceAll("^整$", "零元整");}
}

package com.project.log.Utils;import org.apache.commons.lang3.exception.ExceptionUtils;import java.io.PrintWriter;
import java.io.StringWriter;/*** 错误信息处理类。**/
public class ExceptionUtil {/*** 获取exception的详细错误信息。*/public static String getExceptionMessage(Throwable e) {StringWriter sw = new StringWriter();e.printStackTrace(new PrintWriter(sw, true));return sw.toString();}public static String getRootErrorMessage(Exception e) {Throwable root = ExceptionUtils.getRootCause(e);root = (root == null ? e : root);if (root == null) {return "";}String msg = root.getMessage();if (msg == null) {return "null";}return StringUtils.defaultString(msg);}
}

package com.project.log.Utils;import jakarta.servlet.ServletRequest;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.servlet.http.HttpSession;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import com.project.log.constant.Constants;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;/*** 客户端工具类**/
public class ServletUtils {/*** 获取String参数*/public static String getParameter(String name) {return getRequest().getParameter(name);}/*** 获取String参数*/public static String getParameter(String name, String defaultValue) {return Convert.toStr(getRequest().getParameter(name), defaultValue);}/*** 获取Integer参数*/public static Integer getParameterToInt(String name) {return Convert.toInt(getRequest().getParameter(name));}/*** 获取Integer参数*/public static Integer getParameterToInt(String name, Integer defaultValue) {return Convert.toInt(getRequest().getParameter(name), defaultValue);}/*** 获取Boolean参数*/public static Boolean getParameterToBool(String name) {return Convert.toBool(getRequest().getParameter(name));}/*** 获取Boolean参数*/public static Boolean getParameterToBool(String name, Boolean defaultValue) {return Convert.toBool(getRequest().getParameter(name), defaultValue);}/*** 获得所有请求参数** @param request 请求对象{@link ServletRequest}* @return Map*/public static Map<String, String[]> getParams(ServletRequest request) {final Map<String, String[]> map = request.getParameterMap();return Collections.unmodifiableMap(map);}/*** 获得所有请求参数** @param request 请求对象{@link ServletRequest}* @return Map*/public static Map<String, String> getParamMap(ServletRequest request) {Map<String, String> params = new HashMap<>();for (Map.Entry<String, String[]> entry : getParams(request).entrySet()) {params.put(entry.getKey(), StringUtils.join(entry.getValue(), ","));}return params;}/*** 获取request*/public static HttpServletRequest getRequest() {return getRequestAttributes().getRequest();}/*** 获取response*/public static HttpServletResponse getResponse() {return getRequestAttributes().getResponse();}/*** 获取session*/public static HttpSession getSession() {return getRequest().getSession();}public static ServletRequestAttributes getRequestAttributes() {RequestAttributes attributes = RequestContextHolder.getRequestAttributes();return (ServletRequestAttributes) attributes;}/*** 将字符串渲染到客户端** @param response 渲染对象* @param string   待渲染的字符串*/public static void renderString(HttpServletResponse response, String string) {try {response.setStatus(200);response.setContentType("application/json");response.setCharacterEncoding("utf-8");response.getWriter().print(string);} catch (IOException e) {e.printStackTrace();}}/*** 是否是Ajax异步请求** @param request*/public static boolean isAjaxRequest(HttpServletRequest request) {String accept = request.getHeader("accept");if (accept != null && accept.contains("application/json")) {return true;}String xRequestedWith = request.getHeader("X-Requested-With");if (xRequestedWith != null && xRequestedWith.contains("XMLHttpRequest")) {return true;}String uri = request.getRequestURI();if (StringUtils.inStringIgnoreCase(uri, ".json", ".xml")) {return true;}String ajax = request.getParameter("__ajax");return StringUtils.inStringIgnoreCase(ajax, "json", "xml");}/*** 内容编码** @param str 内容* @return 编码后的内容*/public static String urlEncode(String str) {try {return URLEncoder.encode(str, Constants.UTF8);} catch (UnsupportedEncodingException e) {return StringUtils.EMPTY;}}/*** 内容解码** @param str 内容* @return 解码后的内容*/public static String urlDecode(String str) {try {return URLDecoder.decode(str, Constants.UTF8);} catch (UnsupportedEncodingException e) {return StringUtils.EMPTY;}}
}

package com.project.log.Utils;/*** 字符串格式化**/
public class StrFormatter {public static final String EMPTY_JSON = "{}";public static final char C_BACKSLASH = '\\';public static final char C_DELIM_START = '{';public static final char C_DELIM_END = '}';/*** 格式化字符串<br>* 此方法只是简单将占位符 {} 按照顺序替换为参数<br>* 如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可<br>* 例：<br>* 通常使用：format("this is {} for {}", "a", "b") -> this is a for b<br>* 转义{}： format("this is \\{} for {}", "a", "b") -> this is \{} for a<br>* 转义\： format("this is \\\\{} for {}", "a", "b") -> this is \a for b<br>** @param strPattern 字符串模板* @param argArray   参数列表* @return 结果*/public static String format(final String strPattern, final Object... argArray) {if (StringUtils.isEmpty(strPattern) || StringUtils.isEmpty(argArray)) {return strPattern;}final int strPatternLength = strPattern.length();// 初始化定义好的长度以获得更好的性能StringBuilder sbuf = new StringBuilder(strPatternLength + 50);int handledPosition = 0;int delimIndex;// 占位符所在位置for (int argIndex = 0; argIndex < argArray.length; argIndex++) {delimIndex = strPattern.indexOf(EMPTY_JSON, handledPosition);if (delimIndex == -1) {if (handledPosition == 0) {return strPattern;} else { // 字符串模板剩余部分不再包含占位符，加入剩余部分后返回结果sbuf.append(strPattern, handledPosition, strPatternLength);return sbuf.toString();}} else {if (delimIndex > 0 && strPattern.charAt(delimIndex - 1) == C_BACKSLASH) {if (delimIndex > 1 && strPattern.charAt(delimIndex - 2) == C_BACKSLASH) {// 转义符之前还有一个转义符，占位符依旧有效sbuf.append(strPattern, handledPosition, delimIndex - 1);sbuf.append(Convert.utf8Str(argArray[argIndex]));handledPosition = delimIndex + 2;} else {// 占位符被转义argIndex--;sbuf.append(strPattern, handledPosition, delimIndex - 1);sbuf.append(C_DELIM_START);handledPosition = delimIndex + 1;}} else {// 正常占位符sbuf.append(strPattern, handledPosition, delimIndex);sbuf.append(Convert.utf8Str(argArray[argIndex]));handledPosition = delimIndex + 2;}}}// 加入最后一个占位符后所有的字符sbuf.append(strPattern, handledPosition, strPattern.length());return sbuf.toString();}
}

package com.project.log.Utils;import com.project.log.constant.Constants;
import org.springframework.util.AntPathMatcher;import java.util.*;/*** 字符串工具类**/
public class StringUtils extends org.apache.commons.lang3.StringUtils {/*** 空字符串*/private static final String NULLSTR = "";/*** 下划线*/private static final char SEPARATOR = '_';/*** 星号*/private static final char ASTERISK = '*';/*** 获取参数不为空值** @param value defaultValue 要判断的value* @return value 返回值*/public static <T> T nvl(T value, T defaultValue) {return value != null ? value : defaultValue;}/*** * 判断一个Collection是否为空， 包含List，Set，Queue** @param coll 要判断的Collection* @return true：为空 false：非空*/public static boolean isEmpty(Collection<?> coll) {return isNull(coll) || coll.isEmpty();}/*** * 判断一个Collection是否非空，包含List，Set，Queue** @param coll 要判断的Collection* @return true：非空 false：空*/public static boolean isNotEmpty(Collection<?> coll) {return !isEmpty(coll);}/*** * 判断一个对象数组是否为空** @param objects 要判断的对象数组*                * @return true：为空 false：非空*/public static boolean isEmpty(Object[] objects) {return isNull(objects) || (objects.length == 0);}/*** * 判断一个对象数组是否非空** @param objects 要判断的对象数组* @return true：非空 false：空*/public static boolean isNotEmpty(Object[] objects) {return !isEmpty(objects);}/*** * 判断一个Map是否为空** @param map 要判断的Map* @return true：为空 false：非空*/public static boolean isEmpty(Map<?, ?> map) {return isNull(map) || map.isEmpty();}/*** * 判断一个Map是否为空** @param map 要判断的Map* @return true：非空 false：空*/public static boolean isNotEmpty(Map<?, ?> map) {return !isEmpty(map);}/*** * 判断一个字符串是否为空串** @param str String* @return true：为空 false：非空*/public static boolean isEmpty(String str) {return isNull(str) || NULLSTR.equals(str.trim());}/*** * 判断一个字符串是否为非空串** @param str String* @return true：非空串 false：空串*/public static boolean isNotEmpty(String str) {return !isEmpty(str);}/*** * 判断一个对象是否为空** @param object Object* @return true：为空 false：非空*/public static boolean isNull(Object object) {return object == null;}/*** * 判断一个对象是否非空** @param object Object* @return true：非空 false：空*/public static boolean isNotNull(Object object) {return !isNull(object);}/*** * 判断一个对象是否是数组类型（Java基本型别的数组）** @param object 对象* @return true：是数组 false：不是数组*/public static boolean isArray(Object object) {return isNotNull(object) && object.getClass().isArray();}/*** 去空格*/public static String trim(String str) {return (str == null ? "" : str.trim());}/*** 替换指定字符串的指定区间内字符为"*"** @param str          字符串* @param startInclude 开始位置（包含）* @param endExclude   结束位置（不包含）* @return 替换后的字符串*/public static String hide(CharSequence str, int startInclude, int endExclude) {if (isEmpty(str)) {return NULLSTR;}final int strLength = str.length();if (startInclude > strLength) {return NULLSTR;}if (endExclude > strLength) {endExclude = strLength;}if (startInclude > endExclude) {// 如果起始位置大于结束位置，不替换return NULLSTR;}final char[] chars = new char[strLength];for (int i = 0; i < strLength; i++) {if (i >= startInclude && i < endExclude) {chars[i] = ASTERISK;} else {chars[i] = str.charAt(i);}}return new String(chars);}/*** 截取字符串** @param str   字符串* @param start 开始* @return 结果*/public static String substring(final String str, int start) {if (str == null) {return NULLSTR;}if (start < 0) {start = str.length() + start;}if (start < 0) {start = 0;}if (start > str.length()) {return NULLSTR;}return str.substring(start);}/*** 截取字符串** @param str   字符串* @param start 开始* @param end   结束* @return 结果*/public static String substring(final String str, int start, int end) {if (str == null) {return NULLSTR;}if (end < 0) {end = str.length() + end;}if (start < 0) {start = str.length() + start;}if (end > str.length()) {end = str.length();}if (start > end) {return NULLSTR;}if (start < 0) {start = 0;}if (end < 0) {end = 0;}return str.substring(start, end);}/*** 在字符串中查找第一个出现的 `open` 和最后一个出现的 `close` 之间的子字符串** @param str   要截取的字符串* @param open  起始字符串* @param close 结束字符串* @return 截取结果*/public static String substringBetweenLast(final String str, final String open, final String close) {if (isEmpty(str) || isEmpty(open) || isEmpty(close)) {return NULLSTR;}final int start = str.indexOf(open);if (start != INDEX_NOT_FOUND) {final int end = str.lastIndexOf(close);if (end != INDEX_NOT_FOUND) {return str.substring(start + open.length(), end);}}return NULLSTR;}/*** 判断是否为空，并且不是空白字符** @param str 要判断的value* @return 结果*/public static boolean hasText(String str) {return (str != null && !str.isEmpty() && containsText(str));}private static boolean containsText(CharSequence str) {int strLen = str.length();for (int i = 0; i < strLen; i++) {if (!Character.isWhitespace(str.charAt(i))) {return true;}}return false;}/*** 格式化文本, {} 表示占位符<br>* 此方法只是简单将占位符 {} 按照顺序替换为参数<br>* 如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可<br>* 例：<br>* 通常使用：format("this is {} for {}", "a", "b") -> this is a for b<br>* 转义{}： format("this is \\{} for {}", "a", "b") -> this is \{} for a<br>* 转义\： format("this is \\\\{} for {}", "a", "b") -> this is \a for b<br>** @param template 文本模板，被替换的部分用 {} 表示* @param params   参数值* @return 格式化后的文本*/public static String format(String template, Object... params) {if (isEmpty(params) || isEmpty(template)) {return template;}return StrFormatter.format(template, params);}/*** 是否为http(s)://开头** @param link 链接* @return 结果*/public static boolean ishttp(String link) {return StringUtils.startsWithAny(link, Constants.HTTP, Constants.HTTPS);}/*** 字符串转set** @param str 字符串* @param sep 分隔符* @return set集合*/public static final Set<String> str2Set(String str, String sep) {return new HashSet<String>(str2List(str, sep, true, false));}/*** 字符串转list** @param str         字符串* @param sep         分隔符* @param filterBlank 过滤纯空白* @param trim        去掉首尾空白* @return list集合*/public static final List<String> str2List(String str, String sep, boolean filterBlank, boolean trim) {List<String> list = new ArrayList<String>();if (StringUtils.isEmpty(str)) {return list;}// 过滤空白字符串if (filterBlank && StringUtils.isBlank(str)) {return list;}String[] split = str.split(sep);for (String string : split) {if (filterBlank && StringUtils.isBlank(string)) {continue;}if (trim) {string = string.trim();}list.add(string);}return list;}/*** 判断给定的collection列表中是否包含数组array 判断给定的数组array中是否包含给定的元素value** @param collection 给定的集合* @param array      给定的数组* @return boolean 结果*/public static boolean containsAny(Collection<String> collection, String... array) {if (isEmpty(collection) || isEmpty(array)) {return false;} else {for (String str : array) {if (collection.contains(str)) {return true;}}return false;}}/*** 查找指定字符串是否包含指定字符串列表中的任意一个字符串同时串忽略大小写** @param cs                  指定字符串* @param searchCharSequences 需要检查的字符串数组* @return 是否包含任意一个字符串*/public static boolean containsAnyIgnoreCase(CharSequence cs, CharSequence... searchCharSequences) {if (isEmpty(cs) || isEmpty(searchCharSequences)) {return false;}for (CharSequence testStr : searchCharSequences) {if (containsIgnoreCase(cs, testStr)) {return true;}}return false;}/*** 驼峰转下划线命名*/public static String toUnderScoreCase(String str) {if (str == null) {return null;}StringBuilder sb = new StringBuilder();// 前置字符是否大写boolean preCharIsUpperCase = true;// 当前字符是否大写boolean curreCharIsUpperCase = true;// 下一字符是否大写boolean nexteCharIsUpperCase = true;for (int i = 0; i < str.length(); i++) {char c = str.charAt(i);if (i > 0) {preCharIsUpperCase = Character.isUpperCase(str.charAt(i - 1));} else {preCharIsUpperCase = false;}curreCharIsUpperCase = Character.isUpperCase(c);if (i < (str.length() - 1)) {nexteCharIsUpperCase = Character.isUpperCase(str.charAt(i + 1));}if (preCharIsUpperCase && curreCharIsUpperCase && !nexteCharIsUpperCase) {sb.append(SEPARATOR);} else if ((i != 0 && !preCharIsUpperCase) && curreCharIsUpperCase) {sb.append(SEPARATOR);}sb.append(Character.toLowerCase(c));}return sb.toString();}/*** 是否包含字符串** @param str  验证字符串* @param strs 字符串组* @return 包含返回true*/public static boolean inStringIgnoreCase(String str, String... strs) {if (str != null && strs != null) {for (String s : strs) {if (str.equalsIgnoreCase(trim(s))) {return true;}}}return false;}/*** 将下划线大写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。 例如：HELLO_WORLD->HelloWorld** @param name 转换前的下划线大写方式命名的字符串* @return 转换后的驼峰式命名的字符串*/public static String convertToCamelCase(String name) {StringBuilder result = new StringBuilder();// 快速检查if (name == null || name.isEmpty()) {// 没必要转换return "";} else if (!name.contains("_")) {// 不含下划线，仅将首字母大写return name.substring(0, 1).toUpperCase() + name.substring(1);}// 用下划线将原始字符串分割String[] camels = name.split("_");for (String camel : camels) {// 跳过原始字符串中开头、结尾的下换线或双重下划线if (camel.isEmpty()) {continue;}// 首字母大写result.append(camel.substring(0, 1).toUpperCase());result.append(camel.substring(1).toLowerCase());}return result.toString();}/*** 驼峰式命名法* 例如：user_name->userName*/public static String toCamelCase(String s) {if (s == null) {return null;}if (s.indexOf(SEPARATOR) == -1) {return s;}s = s.toLowerCase();StringBuilder sb = new StringBuilder(s.length());boolean upperCase = false;for (int i = 0; i < s.length(); i++) {char c = s.charAt(i);if (c == SEPARATOR) {upperCase = true;} else if (upperCase) {sb.append(Character.toUpperCase(c));upperCase = false;} else {sb.append(c);}}return sb.toString();}/*** 查找指定字符串是否匹配指定字符串列表中的任意一个字符串** @param str  指定字符串* @param strs 需要检查的字符串数组* @return 是否匹配*/public static boolean matches(String str, List<String> strs) {if (isEmpty(str) || isEmpty(strs)) {return false;}for (String pattern : strs) {if (isMatch(pattern, str)) {return true;}}return false;}/*** 判断url是否与规则配置:* ? 表示单个字符;* * 表示一层路径内的任意字符串，不可跨层级;* ** 表示任意层路径;** @param pattern 匹配规则* @param url     需要匹配的url* @return*/public static boolean isMatch(String pattern, String url) {AntPathMatcher matcher = new AntPathMatcher();return matcher.match(pattern, url);}@SuppressWarnings("unchecked")public static <T> T cast(Object obj) {return (T) obj;}/*** 数字左边补齐0，使之达到指定长度。注意，如果数字转换为字符串后，长度大于size，则只保留 最后size个字符。** @param num  数字对象* @param size 字符串指定长度* @return 返回数字的字符串格式，该字符串为指定长度。*/public static final String padl(final Number num, final int size) {return padl(num.toString(), size, '0');}/*** 字符串左补齐。如果原始字符串s长度大于size，则只保留最后size个字符。** @param s    原始字符串* @param size 字符串指定长度* @param c    用于补齐的字符* @return 返回指定长度的字符串，由原字符串左补齐或截取得到。*/public static final String padl(final String s, final int size, final char c) {final StringBuilder sb = new StringBuilder(size);if (s != null) {final int len = s.length();if (s.length() <= size) {for (int i = size - len; i > 0; i--) {sb.append(c);}sb.append(s);} else {return s.substring(len - size, len);}} else {for (int i = size; i > 0; i--) {sb.append(c);}}return sb.toString();}
}

package com.project.log.constant;import java.util.Locale;/*** 通用常量信息**/
public class Constants {/*** UTF-8 字符集*/public static final String UTF8 = "UTF-8";/*** GBK 字符集*/public static final String GBK = "GBK";/*** 系统语言*/public static final Locale DEFAULT_LOCALE = Locale.SIMPLIFIED_CHINESE;/*** www主域*/public static final String WWW = "www.";/*** http请求*/public static final String HTTP = "http://";/*** https请求*/public static final String HTTPS = "https://";/*** 通用成功标识*/public static final String SUCCESS = "0";/*** 通用失败标识*/public static final String FAIL = "1";/*** 登录成功*/public static final String LOGIN_SUCCESS = "Success";/*** 注销*/public static final String LOGOUT = "Logout";/*** 注册*/public static final String REGISTER = "Register";/*** 登录失败*/public static final String LOGIN_FAIL = "Error";/*** 所有权限标识*/public static final String ALL_PERMISSION = "*:*:*";/*** 管理员角色权限标识*/public static final String SUPER_ADMIN = "admin";/*** 角色权限分隔符*/public static final String ROLE_DELIMETER = ",";/*** 权限标识分隔符*/public static final String PERMISSION_DELIMETER = ",";/*** 验证码有效期（分钟）*/public static final Integer CAPTCHA_EXPIRATION = 2;/*** 令牌*/public static final String TOKEN = "token";/*** 令牌前缀*/public static final String TOKEN_PREFIX = "Bearer ";/*** 令牌前缀*/public static final String LOGIN_USER_KEY = "login_user_key";/*** 用户ID*/public static final String JWT_USERID = "userid";/*** 用户名称*/public static final String JWT_USERNAME = "sub";/*** 用户头像*/public static final String JWT_AVATAR = "avatar";/*** 创建时间*/public static final String JWT_CREATED = "created";/*** 用户权限*/public static final String JWT_AUTHORITIES = "authorities";/*** 资源映射路径 前缀*/public static final String RESOURCE_PREFIX = "/profile";/*** RMI 远程方法调用*/public static final String LOOKUP_RMI = "rmi:";/*** LDAP 远程方法调用*/public static final String LOOKUP_LDAP = "ldap:";/*** LDAPS 远程方法调用*/public static final String LOOKUP_LDAPS = "ldaps:";/*** 自动识别json对象白名单配置（仅允许解析的包名，范围越小越安全）*/public static final String[] JSON_WHITELIST_STR = {"org.springframework", "com.project"};/*** 定时任务白名单配置（仅允许访问的包名，如其他需要可以自行添加）*/public static final String[] JOB_WHITELIST_STR = {"com.project.quartz.task"};/*** 定时任务违规的字符*/public static final String[] JOB_ERROR_STR = {"java.net.URL", "javax.naming.InitialContext", "org.yaml.snakeyaml","org.springframework", "org.apache", "com.project.common.utils.file", "com.project.common.config", "com.project.generator"};
}

排除JSON敏感属性

import com.alibaba.fastjson2.filter.SimplePropertyPreFilter;/*** 排除JSON敏感属性**/
public class PropertyPreExcludeFilter extends SimplePropertyPreFilter {public PropertyPreExcludeFilter() {}public PropertyPreExcludeFilter addExcludes(String... filters) {for (int i = 0; i < filters.length; i++) {this.getExcludes().add(filters[i]);}return this;}
}

创建切面类

注意：这里不同的spring-web依赖版本ServletRequestAttributes的getResponse()返回结果是不同的，新版本返回值为jakarta包下面的HttpServletResponse，而一些旧版本的就会返回javax包下的，因此要根据自身版本进行修改。

package com.project.log.aspectj;import java.util.Collection;
import java.util.Map;import com.project.log.Utils.ExceptionUtil;
import com.project.log.Utils.ServletUtils;
import com.project.log.Utils.Convert;
import com.project.log.Utils.StringUtils;
import com.project.log.Utils.ip.IpUtils;
import com.project.log.annotation.Log;
import com.project.log.domain.SysOperLog;
import com.project.log.enums.BusinessStatus;
import com.project.log.filter.PropertyPreExcludeFilter;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.apache.commons.lang3.ArrayUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.NamedThreadLocal;
import org.springframework.http.HttpMethod;
import org.springframework.stereotype.Component;
import org.springframework.validation.BindingResult;
import org.springframework.web.multipart.MultipartFile;
import com.alibaba.fastjson2.JSON;/*** 操作日志记录处理** @author ruoyi*/
@Aspect
@Component
public class LogAspect {private static final Logger log = LoggerFactory.getLogger(LogAspect.class);/*** 排除敏感属性字段*/public static final String[] EXCLUDE_PROPERTIES = {"password", "oldPassword", "newPassword", "confirmPassword"};/*** 计算操作消耗时间*/private static final ThreadLocal<Long> TIME_THREADLOCAL = new NamedThreadLocal<Long>("Cost Time");/*** 处理请求前执行*/@Before(value = "@annotation(controllerLog)")public void doBefore(JoinPoint joinPoint, Log controllerLog) {TIME_THREADLOCAL.set(System.currentTimeMillis());}/*** 处理完请求后执行** @param joinPoint 切点*/@AfterReturning(pointcut = "@annotation(controllerLog)", returning = "jsonResult")public void doAfterReturning(JoinPoint joinPoint, Log controllerLog, Object jsonResult) {handleLog(joinPoint, controllerLog, null, jsonResult);}/*** 拦截异常操作** @param joinPoint 切点* @param e         异常*/@AfterThrowing(value = "@annotation(controllerLog)", throwing = "e")public void doAfterThrowing(JoinPoint joinPoint, Log controllerLog, Exception e) {handleLog(joinPoint, controllerLog, e, null);}protected void handleLog(final JoinPoint joinPoint, Log controllerLog, final Exception e, Object jsonResult) {try {// 获取当前的用户// TODO: 具体的用户实体信息 和 获取用户信息的工具类// LoginUser loginUser = SecurityUtils.getLoginUser();// *========数据库日志=========*//SysOperLog operLog = new SysOperLog();operLog.setStatus(BusinessStatus.SUCCESS.ordinal());// 请求的地址String ip = IpUtils.getIpAddr();operLog.setOperIp(ip);operLog.setOperUrl(StringUtils.substring(ServletUtils.getRequest().getRequestURI(), 0, 255));//TODO: 往操作日志中填冲用户信息/*if (loginUser != null) {operLog.setOperName(loginUser.getUsername());SysUser currentUser = loginUser.getUser();if (StringUtils.isNotNull(currentUser) && StringUtils.isNotNull(currentUser.getDept())) {operLog.setDeptName(currentUser.getDept().getDeptName());}}*/if (e != null) {operLog.setStatus(BusinessStatus.FAIL.ordinal());operLog.setErrorMsg(StringUtils.substring(Convert.toStr(e.getMessage(), ExceptionUtil.getExceptionMessage(e)), 0, 2000));}// 设置方法名称String className = joinPoint.getTarget().getClass().getName();String methodName = joinPoint.getSignature().getName();operLog.setMethod(className + "." + methodName + "()");// 设置请求方式operLog.setRequestMethod(ServletUtils.getRequest().getMethod());// 处理设置注解上的参数getControllerMethodDescription(joinPoint, controllerLog, operLog, jsonResult);// 设置消耗时间operLog.setCostTime(System.currentTimeMillis() - TIME_THREADLOCAL.get());//TODO: 日志保存数据库//AsyncManager.me().execute(AsyncFactory.recordOper(operLog));} catch (Exception exp) {// 记录本地异常日志log.error("异常信息:{}", exp.getMessage());exp.printStackTrace();} finally {TIME_THREADLOCAL.remove();}}/*** 获取注解中对方法的描述信息 用于Controller层注解** @param log     日志* @param operLog 操作日志* @throws Exception*/public void getControllerMethodDescription(JoinPoint joinPoint, Log log, SysOperLog operLog, Object jsonResult) throws Exception {// 设置action动作operLog.setBusinessType(log.businessType().ordinal());// 设置标题operLog.setTitle(log.title());// 设置操作人类别operLog.setOperatorType(log.operatorType().ordinal());// 是否需要保存request，参数和值if (log.isSaveRequestData()) {// 获取参数的信息，传入到数据库中。setRequestValue(joinPoint, operLog, log.excludeParamNames());}// 是否需要保存response，参数和值if (log.isSaveResponseData() && StringUtils.isNotNull(jsonResult)) {operLog.setJsonResult(StringUtils.substring(JSON.toJSONString(jsonResult), 0, 2000));}}/*** 获取请求的参数，放到log中** @param operLog 操作日志* @throws Exception 异常*/private void setRequestValue(JoinPoint joinPoint, SysOperLog operLog, String[] excludeParamNames) throws Exception {Map<?, ?> paramsMap = ServletUtils.getParamMap(ServletUtils.getRequest());String requestMethod = operLog.getRequestMethod();if (StringUtils.isEmpty(paramsMap) && StringUtils.equalsAny(requestMethod, HttpMethod.PUT.name(), HttpMethod.POST.name(), HttpMethod.DELETE.name())) {String params = argsArrayToString(joinPoint.getArgs(), excludeParamNames);operLog.setOperParam(StringUtils.substring(params, 0, 2000));} else {operLog.setOperParam(StringUtils.substring(JSON.toJSONString(paramsMap, excludePropertyPreFilter(excludeParamNames)), 0, 2000));}}/*** 参数拼装*/private String argsArrayToString(Object[] paramsArray, String[] excludeParamNames) {String params = "";if (paramsArray != null && paramsArray.length > 0) {for (Object o : paramsArray) {if (StringUtils.isNotNull(o) && !isFilterObject(o)) {try {String jsonObj = JSON.toJSONString(o, excludePropertyPreFilter(excludeParamNames));params += jsonObj.toString() + " ";} catch (Exception e) {}}}}return params.trim();}/*** 忽略敏感属性*/public PropertyPreExcludeFilter excludePropertyPreFilter(String[] excludeParamNames) {return new PropertyPreExcludeFilter().addExcludes(ArrayUtils.addAll(EXCLUDE_PROPERTIES, excludeParamNames));}/*** 判断是否需要过滤的对象。** @param o 对象信息。* @return 如果是需要过滤的对象，则返回true；否则返回false。*/@SuppressWarnings("rawtypes")public boolean isFilterObject(final Object o) {Class<?> clazz = o.getClass();if (clazz.isArray()) {return clazz.getComponentType().isAssignableFrom(MultipartFile.class);} else if (Collection.class.isAssignableFrom(clazz)) {Collection collection = (Collection) o;for (Object value : collection) {return value instanceof MultipartFile;}} else if (Map.class.isAssignableFrom(clazz)) {Map map = (Map) o;for (Object value : map.entrySet()) {Map.Entry entry = (Map.Entry) value;return entry.getValue() instanceof MultipartFile;}}return o instanceof MultipartFile || o instanceof HttpServletRequest || o instanceof HttpServletResponse|| o instanceof BindingResult;}
}

以下内容需要自行替换

2. 方法执行：

• 正常返回： 如果目标方法执行成功并返回结果，切面会执行doAfterReturning方法。这个方法会调用handleLog方法来处理操作日志。

/*** 处理完请求后执行** @param joinPoint 切点*/@AfterReturning(pointcut = "@annotation(controllerLog)", returning = "jsonResult")public void doAfterReturning(JoinPoint joinPoint, Log controllerLog, Object jsonResult) {handleLog(joinPoint, controllerLog, null, jsonResult);}

• 异常返回： 如果目标方法执行过程中抛出异常，切面会执行doAfterThrowing方法。这个方法也会调用handleLog方法来处理操作日志，并记录异常信息。

/*** 拦截异常操作** @param joinPoint 切点* @param e         异常*/@AfterThrowing(value = "@annotation(controllerLog)", throwing = "e")public void doAfterThrowing(JoinPoint joinPoint, Log controllerLog, Exception e) {handleLog(joinPoint, controllerLog, e, null);}

3. 日志处理： 在handleLog方法中，切面会收集各种请求信息、方法信息、执行时长等数据，并将这些数据封装到一个SysOperLog对象中，最后通过sysOperLogService保存该日志对象。
4. 获取和设置日志信息： 在handleLog方法内部，通过调用一些辅助方法来获取和设置日志的详细信息，包括请求参数、响应数据等。

操作日志注解使用

    /*** 获取用户信息** @param id 用户id* @return {@link Result }<{@link UserInfo }>*/@Log(title = "获取用户信息", businessType = BusinessType.OTHER)@Operation(description = "获取用户信息")@GetMapping("/{id}")public Result<UserInfo> getUser(@PathVariable Long id) {return Result.success(userInfoService.getById(id));}/*** 插入用户信息** @param userInfo 用户信息* @return {@link Result }<{@link String }>*/@Log(title = "插入用户信息", businessType = BusinessType.INSERT)@Operation(description = "插入用户信息")@PostMappingpublic Result<String> insertUser(@RequestBody UserInfo userInfo) {boolean saved = userInfoService.save(userInfo);if (!saved) {return Result.error("插入失败");}return Result.success();}/*** 更新用户信息** @param userInfo 用户信息* @return {@link Result }<{@link String }>*/@Log(title = "更新用户信息", businessType = BusinessType.UPDATE)@Operation(description = "更新用户信息")@PutMappingpublic Result<String> updateUser(@RequestBody UserInfo userInfo) {boolean updated = userInfoService.updateById(userInfo);if (!updated) {return Result.error("更新失败");}return Result.success();}/*** 删除用户信息* @param id i用户id* @return {@link Result }<{@link String }>*/@Log(title = "删除用户信息", businessType = BusinessType.DELETE)@Operation(description = "删除用户信息")@DeleteMapping("/{id}")public Result<String> deleteUser(@PathVariable Long id) {boolean deleted = userInfoService.removeById(id);if (!deleted) {return Result.error("删除失败");}return Result.success();}