hhyykk/ipms-sjy
1
1
Fork 0
mirror of https://gitee.com/hhyykk/ipms-sjy.git synced 2025-10-31 18:28:43 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

完成操作日志的记录

Browse Source
This commit is contained in:
YunaiV
2021-01-17 00:28:56 +08:00
parent b6457c0418
commit ec8f181f2f
29 changed files with 691 additions and 261 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
src/main/java/cn/iocoder/dashboard/framework/async/config/AsyncConfiguration.java Normal file
View File

@@ -0,0 +1,9 @@
package cn.iocoder.dashboard.framework.async.config;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
@Configuration
@EnableAsync(proxyTargetClass = true)
public class AsyncConfiguration {
}

4
src/main/java/cn/iocoder/dashboard/framework/async/package-info.java Normal file
View File

@@ -0,0 +1,4 @@
/**
* 异步执行，基于 Spring @Async 实现
*/
package cn.iocoder.dashboard.framework.async;

1
src/main/java/cn/iocoder/dashboard/framework/async/《芋道 Spring Boot 异步任务入门》.md Normal file
View File

@@ -0,0 +1 @@
<http://www.iocoder.cn/Spring-Boot/Async-Job/?dashboard>

15
src/main/java/cn/iocoder/dashboard/framework/logger/operatelog/config/OperateLogConfiguration.java Normal file
View File

@@ -0,0 +1,15 @@
package cn.iocoder.dashboard.framework.logger.operatelog.config;
import cn.iocoder.dashboard.framework.logger.operatelog.core.aop.OperateLogAspect;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class OperateLogConfiguration {
@Bean
public OperateLogAspect operateLogAspect() {
return new OperateLogAspect();
}
}

52
src/main/java/cn/iocoder/dashboard/framework/logger/operatelog/core/annotations/OperateLog.java Normal file
View File

@@ -0,0 +1,52 @@
package cn.iocoder.dashboard.framework.logger.operatelog.core.annotations;
import cn.iocoder.dashboard.modules.system.enums.logger.SysOperateLogTypeEnum;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface OperateLog {
// ========== 模块字段 ==========
/**
* 操作模块
*
* 为空时，会尝试读取 {@link Api#value()} 属性
*/
String module() default "";
/**
* 操作名
*
* 为空时，会尝试读取 {@link ApiOperation#value()} 属性
*/
String name() default "";
/**
* 操作分类
*
* 实际并不是数组，因为枚举不能设置 null 作为默认值
*/
SysOperateLogTypeEnum[] type() default {};
// ========== 开关字段 ==========
/**
* 是否记录操作日志
*/
boolean enable() default true;
/**
* 是否记录方法参数
*/
boolean logArgs() default true;
/**
* 是否记录方法结果的数据
*/
boolean logResultData() default true;
}

320
src/main/java/cn/iocoder/dashboard/framework/logger/operatelog/core/aop/OperateLogAspect.java Normal file
View File

@@ -0,0 +1,320 @@
package cn.iocoder.dashboard.framework.logger.operatelog.core.aop;
import cn.hutool.core.exceptions.ExceptionUtil;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.extra.servlet.ServletUtil;
import cn.iocoder.dashboard.common.pojo.CommonResult;
import cn.iocoder.dashboard.framework.logger.operatelog.core.annotations.OperateLog;
import cn.iocoder.dashboard.framework.logger.operatelog.core.service.OperateLogFrameworkService;
import cn.iocoder.dashboard.framework.security.core.util.SecurityUtils;
import cn.iocoder.dashboard.framework.tracer.core.util.TracerUtils;
import cn.iocoder.dashboard.modules.system.controller.logger.vo.SysOperateLogCreateReqVO;
import cn.iocoder.dashboard.modules.system.enums.logger.SysOperateLogTypeEnum;
import cn.iocoder.dashboard.util.servlet.ServletUtils;
import com.alibaba.fastjson.JSON;
import com.google.common.collect.Maps;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.multipart.MultipartFile;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.annotation.Annotation;
import java.lang.reflect.Array;
import java.util.*;
import java.util.function.Predicate;
import java.util.stream.IntStream;
import static cn.iocoder.dashboard.common.exception.enums.GlobalErrorCodeConstants.INTERNAL_SERVER_ERROR;
import static cn.iocoder.dashboard.common.exception.enums.GlobalErrorCodeConstants.SUCCESS;
/**
* 拦截使用 @ApiOperation 注解，如果满足条件，则生成操作日志。
* 满足如下任一条件，则会进行记录：
* 1. 使用 @ApiOperation + 非 @GetMapping
* 2. 使用 @OperateLog 注解
*
* 但是，如果声明 @OperateLog 注解时，将 enable 属性设置为 false 时，强制不记录。
*
* 为什么考虑使用 @ApiOperation 记录呢？避免有小伙伴忘记添加 @OperateLog 注解
*
* @author 芋道源码
*/
@Aspect
@Slf4j
public class OperateLogAspect {
@Resource
private OperateLogFrameworkService operateLogFrameworkService;
@Around("@annotation(apiOperation)")
public Object around(ProceedingJoinPoint joinPoint, ApiOperation apiOperation) throws Throwable {
// 可能也添加了 @ApiOperation 注解
OperateLog operateLog = getMethodAnnotation(joinPoint, OperateLog.class);
return around0(joinPoint, operateLog, apiOperation);
}
@Around("!@annotation(io.swagger.annotations.ApiOperation) && @annotation(operateLog)") // 兼容处理，只添加 @OperateLog 注解的情况
public Object around(ProceedingJoinPoint joinPoint, OperateLog operateLog) throws Throwable {
return around0(joinPoint, operateLog, null);
}
private Object around0(ProceedingJoinPoint joinPoint, OperateLog operateLog, ApiOperation apiOperation) throws Throwable {
// 记录开始时间
Date startTime = new Date();
try {
// 执行原有方法
Object result = joinPoint.proceed();
// 记录正常执行时的操作日志
this.log(joinPoint, operateLog, apiOperation, startTime, result, null);
return result;
} catch (Throwable exception) {
this.log(joinPoint, operateLog, apiOperation, startTime, null, exception);
throw exception;
}
}
private void log(ProceedingJoinPoint joinPoint, OperateLog operateLog, ApiOperation apiOperation,
Date startTime, Object result, Throwable exception) {
try {
// 判断不记录的情况
if (!isLogEnable(joinPoint, operateLog)) {
return;
}
// 真正记录操作日志
this.log0(joinPoint, operateLog, apiOperation, startTime, result, exception);
} catch (Throwable ex) {
log.error("[log][记录操作日志时，发生异常，其中参数是 joinPoint({}) operateLog({}) apiOperation({}) result({}) exception({}) ]",
joinPoint, operateLog, apiOperation, result, exception, ex);
}
}
private void log0(ProceedingJoinPoint joinPoint, OperateLog operateLog, ApiOperation apiOperation,
Date startTime, Object result, Throwable exception) {
SysOperateLogCreateReqVO operateLogVO = new SysOperateLogCreateReqVO();
// 补全通用字段
operateLogVO.setTraceId(TracerUtils.getTraceId());
operateLogVO.setStartTime(startTime);
// 补充用户信息
fillUserFields(operateLogVO);
// 补全模块信息
fillModuleFields(operateLogVO, joinPoint, operateLog, apiOperation);
// 补全请求信息
fillRequestFields(operateLogVO);
// 补全方法信息
fillMethodFields(operateLogVO, joinPoint, operateLog, startTime, result, exception);
// 异步记录日志
operateLogFrameworkService.createOperateLogAsync(operateLogVO);
}
private static void fillUserFields(SysOperateLogCreateReqVO operateLogVO) {
operateLogVO.setUserId(SecurityUtils.getLoginUserId());
}
private static void fillModuleFields(SysOperateLogCreateReqVO operateLogVO,
ProceedingJoinPoint joinPoint, OperateLog operateLog, ApiOperation apiOperation) {
// module 属性
if (operateLog != null) {
operateLogVO.setModule(operateLog.module());
}
if (StrUtil.isEmpty(operateLogVO.getModule())) {
Api api = getClassAnnotation(joinPoint, Api.class);
if (api != null) {
operateLogVO.setModule(Optional.of(api.value())
.orElse(ArrayUtil.isEmpty(api.tags()) ? api.tags()[0] : null));
}
}
// name 属性
if (operateLog != null) {
operateLogVO.setName(operateLog.name());
}
if (StrUtil.isEmpty(operateLogVO.getName()) && apiOperation != null) {
operateLogVO.setName(apiOperation.value());
}
// type 属性
if (operateLog != null && ArrayUtil.isNotEmpty(operateLog.type())) {
operateLogVO.setType(operateLog.type()[0].getType());
}
if (operateLogVO.getType() == null) {
RequestMethod requestMethod = obtainFirstMatchRequestMethod(obtainRequestMethod(joinPoint));
SysOperateLogTypeEnum operateLogType = convertOperateLogType(requestMethod);
operateLogVO.setType(operateLogType != null ? operateLogType.getType() : null);
}
}
private static void fillRequestFields(SysOperateLogCreateReqVO operateLogVO) {
// 获得 Request 对象
RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
if (!(requestAttributes instanceof ServletRequestAttributes)) {
return;
}
HttpServletRequest request = ((ServletRequestAttributes) requestAttributes).getRequest();
// 补全请求信息
operateLogVO.setRequestMethod(request.getMethod());
operateLogVO.setRequestUrl(request.getRequestURI());
operateLogVO.setUserIp(ServletUtil.getClientIP(request));
operateLogVO.setUserAgent(ServletUtils.getUserAgent(request));
}
private static void fillMethodFields(SysOperateLogCreateReqVO operateLogVO,
ProceedingJoinPoint joinPoint, OperateLog operateLog,
Date startTime, Object result, Throwable exception) {
MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
operateLogVO.setJavaMethod(methodSignature.toString());
if (operateLog == null || operateLog.logArgs()) {
operateLogVO.setJavaMethodArgs(obtainMethodArgs(joinPoint));
}
if (operateLog == null || operateLog.logResultData()) {
operateLogVO.setResultData(obtainResultData(result));
}
operateLogVO.setDuration((int) (System.currentTimeMillis() - startTime.getTime()));
// （正常）处理 resultCode 和 resultMsg 字段
if (result != null) {
if (result instanceof CommonResult) {
CommonResult<?> commonResult = (CommonResult<?>) result;
operateLogVO.setResultCode(commonResult.getCode());
operateLogVO.setResultMsg(commonResult.getMsg());
} else {
operateLogVO.setResultCode(SUCCESS.getCode());
}
}
// （异常）处理 resultCode 和 resultMsg 字段
if (exception != null) {
operateLogVO.setResultCode(INTERNAL_SERVER_ERROR.getCode());
operateLogVO.setResultMsg(ExceptionUtil.getRootCauseMessage(exception));
}
}
private static boolean isLogEnable(ProceedingJoinPoint joinPoint, OperateLog operateLog) {
// 有 @OperateLog 注解的情况下
if (operateLog != null) {
return operateLog.enable();
}
// 没有 @ApiOperation 注解的情况下，只记录 POST、PUT、DELETE 的情况
return obtainFirstLogRequestMethod(obtainRequestMethod(joinPoint)) != null;
}
private static RequestMethod obtainFirstLogRequestMethod(RequestMethod[] requestMethods) {
if (ArrayUtil.isEmpty(requestMethods)) {
return null;
}
return Arrays.stream(requestMethods).filter(requestMethod ->
requestMethod == RequestMethod.POST
|| requestMethod == RequestMethod.PUT
|| requestMethod == RequestMethod.DELETE)
.findFirst().orElse(null);
}
private static RequestMethod obtainFirstMatchRequestMethod(RequestMethod[] requestMethods) {
if (ArrayUtil.isEmpty(requestMethods)) {
return null;
}
// 优先，匹配最优的 POST、PUT、DELETE
RequestMethod result = obtainFirstLogRequestMethod(requestMethods);
if (result != null) {
return result;
}
// 然后，匹配次优的 GET
result = Arrays.stream(requestMethods).filter(requestMethod -> requestMethod == RequestMethod.GET)
.findFirst().orElse(null);
if (result != null) {
return result;
}
// 兜底，获得第一个
return requestMethods[0];
}
private static SysOperateLogTypeEnum convertOperateLogType(RequestMethod requestMethod) {
if (requestMethod == null) {
return null;
}
switch (requestMethod) {
case GET:
return SysOperateLogTypeEnum.GET;
case POST:
return SysOperateLogTypeEnum.CREATE;
case PUT:
return SysOperateLogTypeEnum.UPDATE;
case DELETE:
return SysOperateLogTypeEnum.DELETE;
default:
return SysOperateLogTypeEnum.OTHER;
}
}
private static RequestMethod[] obtainRequestMethod(ProceedingJoinPoint joinPoint) {
RequestMapping requestMapping = AnnotationUtils.getAnnotation( // 使用 Spring 的工具类，可以处理 @RequestMapping 别名注解
((MethodSignature) joinPoint.getSignature()).getMethod(), RequestMapping.class);
return requestMapping != null ? requestMapping.method() : new RequestMethod[]{};
}
@SuppressWarnings("SameParameterValue")
private static <T extends Annotation> T getMethodAnnotation(ProceedingJoinPoint joinPoint, Class<T> annotationClass) {
return ((MethodSignature) joinPoint.getSignature()).getMethod().getAnnotation(annotationClass);
}
@SuppressWarnings("SameParameterValue")
private static <T extends Annotation> T getClassAnnotation(ProceedingJoinPoint joinPoint, Class<T> annotationClass) {
return ((MethodSignature) joinPoint.getSignature()).getMethod().getDeclaringClass().getAnnotation(annotationClass);
}
private static Map<String, Object> obtainMethodArgs(ProceedingJoinPoint joinPoint) {
// TODO 提升：参数脱敏和忽略
MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
String[] argNames = methodSignature.getParameterNames();
Object[] argValues = joinPoint.getArgs();
// 拼接参数
Map<String, Object> args = Maps.newHashMapWithExpectedSize(argValues.length);
for (int i = 0; i < argNames.length; i++) {
String argName = argNames[i];
Object argValue = argValues[i];
// 被忽略时，标记为 ignore 字符串，避免和 null 混在一起
args.put(argName, !isIgnoreArgs(argValue) ? argValue : "[ignore]");
}
return args;
}
private static String obtainResultData(Object result) {
// TODO 提升：结果脱敏和忽略
if (result instanceof CommonResult) {
result = ((CommonResult<?>) result).getData();
}
return JSON.toJSONString(result);
}
private static boolean isIgnoreArgs(Object object) {
Class<?> clazz = object.getClass();
// 处理数组的情况
if (clazz.isArray()) {
return IntStream.range(0, Array.getLength(object))
.anyMatch(index -> isIgnoreArgs(Array.get(object, index)));
}
// 递归，处理数组、Collection、Map 的情况
if (Collection.class.isAssignableFrom(clazz)) {
return ((Collection<?>) object).stream()
.anyMatch((Predicate<Object>) o -> isIgnoreArgs(object));
}
if (Map.class.isAssignableFrom(clazz)) {
return isIgnoreArgs(((Map<?, ?>) object).values());
}
// obj
return object instanceof MultipartFile
|| object instanceof HttpServletRequest
|| object instanceof HttpServletResponse;
}
}

1
src/main/java/cn/iocoder/dashboard/framework/logger/operatelog/core/package-info.java Normal file
View File

@@ -0,0 +1 @@
package cn.iocoder.dashboard.framework.logger.operatelog.core;

14
src/main/java/cn/iocoder/dashboard/framework/logger/operatelog/core/service/OperateLogFrameworkService.java Normal file
View File

@@ -0,0 +1,14 @@
package cn.iocoder.dashboard.framework.logger.operatelog.core.service;
import cn.iocoder.dashboard.modules.system.controller.logger.vo.SysOperateLogCreateReqVO;
public interface OperateLogFrameworkService {
/**
* 要不记录操作日志
*
* @param reqVO 操作日志请求
*/
void createOperateLogAsync(SysOperateLogCreateReqVO reqVO);
}

2
src/main/java/cn/iocoder/dashboard/framework/logger/package-info.java
View File

@@ -5,6 +5,6 @@
* 2. API 日志：包含两类
* 2.1 API 访问日志：记录用户访问 API 的访问日志，定期归档历史日志。
* 2.2 API 异常日志：记录用户访问 API 的系统异常，方便日常排查问题与告警。
* 3. 通用 Logger 日志：将 {@link org.slf4j.Logger} 打印的日志，只满足大于等于 {@link org.slf4j.event.Level} 进行持久化，可以理解成简易的“日志中心”。
* 3. 通用 Logger 日志：将 {@link org.slf4j.Logger} 打印的日志，只满足大于等于配置的 {@link org.slf4j.event.Level} 进行持久化，可以理解成简易的“日志中心”。
*/
package cn.iocoder.dashboard.framework.logger;

36
src/main/java/cn/iocoder/dashboard/framework/tracer/core/util/TracerUtils.java Normal file
View File

@@ -0,0 +1,36 @@
package cn.iocoder.dashboard.framework.tracer.core.util;
import cn.hutool.core.util.StrUtil;
import org.apache.skywalking.apm.toolkit.trace.TraceContext;
import java.util.UUID;
/**
* 链路追踪工具类
*
* @author 芋道源码
*/
public class TracerUtils {
/**
* 获得链路追踪编号
*
* 一般来说，通过链路追踪编号，可以将访问日志，错误日志，链路追踪日志，logger 打印日志等，结合在一起，从而进行排错。
*
* 默认情况下，我们使用 Apache SkyWalking 的 traceId 作为链路追踪编号。当然，可能会存在并未引入 Skywalking 的情况，此时使用 UUID 。
*
* @return 链路追踪编号
*/
public static String getTraceId() {
// 通过 SkyWalking 获取链路编号
try {
String traceId = TraceContext.traceId();
if (StrUtil.isNotBlank(traceId)) {
return traceId;
}
} catch (Throwable ignore) {}
// TODO 芋艿 多次调用会问题
return UUID.randomUUID().toString();
}
}

6
src/main/java/cn/iocoder/dashboard/framework/tracer/package-info.java Normal file
View File

@@ -0,0 +1,6 @@
/**
* 链路追踪
*
* 主要目的，是生成全局的链路追踪编号
*/
package cn.iocoder.dashboard.framework.tracer;

5
src/main/java/cn/iocoder/dashboard/modules/system/controller/auth/SysAuthController.java
View File

@@ -2,6 +2,7 @@ package cn.iocoder.dashboard.modules.system.controller.auth;
import cn.iocoder.dashboard.common.enums.CommonStatusEnum;
import cn.iocoder.dashboard.common.pojo.CommonResult;
import cn.iocoder.dashboard.framework.logger.operatelog.core.annotations.OperateLog;
import cn.iocoder.dashboard.modules.system.controller.auth.vo.SysAuthLoginReqVO;
import cn.iocoder.dashboard.modules.system.controller.auth.vo.SysAuthLoginRespVO;
import cn.iocoder.dashboard.modules.system.controller.auth.vo.SysAuthMenuRespVO;
@@ -28,7 +29,7 @@ import static cn.iocoder.dashboard.common.pojo.CommonResult.success;
import static cn.iocoder.dashboard.framework.security.core.util.SecurityUtils.getLoginUserId;
import static cn.iocoder.dashboard.framework.security.core.util.SecurityUtils.getLoginUserRoleIds;
@Api(tags = "认证 API")
@Api("认证 API")
@RestController
@RequestMapping("/")
public class SysAuthController {
@@ -44,6 +45,7 @@ public class SysAuthController {
@ApiOperation("使用账号密码登录")
@PostMapping("/login")
@OperateLog(enable = false) // 避免 Post 请求被记录操作日志
public CommonResult<SysAuthLoginRespVO> login(@RequestBody @Valid SysAuthLoginReqVO reqVO) {
String token = authService.login(reqVO.getUsername(), reqVO.getPassword(), reqVO.getUuid(), reqVO.getCode());
// 返回结果
@@ -52,6 +54,7 @@ public class SysAuthController {
@ApiOperation("获取登陆用户的权限信息")
@GetMapping("/get-permission-info")
@OperateLog
public CommonResult<SysAuthPermissionInfoRespVO> getPermissionInfo() {
// 获得用户信息
SysUserDO user = userService.getUser(getLoginUserId());

1
src/main/java/cn/iocoder/dashboard/modules/system/controller/logger/package-info.java Normal file
View File

@@ -0,0 +1 @@
package cn.iocoder.dashboard.modules.system.controller.logger;

79
src/main/java/cn/iocoder/dashboard/modules/system/controller/logger/vo/SysOperateLogBaseVO.java Normal file
View File

@@ -0,0 +1,79 @@
package cn.iocoder.dashboard.modules.system.controller.logger.vo;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
import java.util.Date;
import java.util.Map;
/**
* 操作日志 Base VO，提供给添加、修改、详细的子 VO 使用
* 如果子 VO 存在差异的字段，请不要添加到这里，影响 Swagger 文档生成
*/
@Data
public class SysOperateLogBaseVO {
@ApiModelProperty(value = "链路追踪编号", required = true, example = "89aca178-a370-411c-ae02-3f0d672be4ab")
@NotEmpty(message = "链路追踪编号不能为空")
private String traceId;
@ApiModelProperty(value = "用户编号", required = true, example = "1024")
@NotNull(message = "用户编号不能为空")
private Long userId;
@ApiModelProperty(value = "操作模块", required = true, example = "订单")
@NotEmpty(message = "操作模块不能为空")
private String module;
@ApiModelProperty(value = "操作名", required = true, example = "创建订单")
@NotEmpty(message = "操作名")
private String name;
@ApiModelProperty(value = "操作分类", required = true, example = "操作分类", notes = "参见 SysOperateLogTypeEnum 枚举类")
@NotNull(message = "操作分类不能为空")
private Integer type;
@ApiModelProperty(value = "请求方法名", required = true, example = "GET")
@NotEmpty(message = "请求方法名不能为空")
private String requestMethod;
@ApiModelProperty(value = "请求地址", required = true, example = "/xxx/yyy")
@NotEmpty(message = "请求地址不能为空")
private String requestUrl;
@ApiModelProperty(value = "用户 IP", required = true, example = "127.0.0.1")
@NotEmpty(message = "用户 IP 不能为空")
private String userIp;
@ApiModelProperty(value = "浏览器 UserAgent", required = true, example = "Mozilla/5.0")
@NotEmpty(message = "浏览器 UserAgent 不能为空")
private String userAgent;
@ApiModelProperty(value = "Java 方法名", required = true, example = "cn.iocoder.dashboard.UserController.save(...)")
@NotEmpty(message = "Java 方法名不能为空")
private String javaMethod;
@ApiModelProperty(value = "Java 方法的参数")
private Map<String, Object> javaMethodArgs;
@ApiModelProperty(value = "开始时间", required = true)
@NotNull(message = "开始时间不能为空")
private Date startTime;
@ApiModelProperty(value = "执行时长，单位：毫秒", required = true)
@NotNull(message = "执行时长不能为空")
private Integer duration;
@ApiModelProperty(value = "结果码", required = true)
@NotNull(message = "结果码不能为空")
private Integer resultCode;
@ApiModelProperty(value = "结果提示")
private String resultMsg;
@ApiModelProperty(value = "结果数据")
private String resultData;
}

13
src/main/java/cn/iocoder/dashboard/modules/system/controller/logger/vo/SysOperateLogCreateReqVO.java Normal file
View File

@@ -0,0 +1,13 @@
package cn.iocoder.dashboard.modules.system.controller.logger.vo;
import io.swagger.annotations.ApiModel;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.ToString;
@ApiModel(value = "操作日志创建 Request VO", description = "暂时提供给前端，仅仅后端切面记录操作日志时，进行使用")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class SysOperateLogCreateReqVO extends SysOperateLogBaseVO {
}

1
src/main/java/cn/iocoder/dashboard/modules/system/controller/logger/vo/package-info.java Normal file
View File

@@ -0,0 +1 @@
package cn.iocoder.dashboard.modules.system.controller.logger.vo;

15
src/main/java/cn/iocoder/dashboard/modules/system/convert/logger/SysOperateLogConvert.java Normal file
View File

@@ -0,0 +1,15 @@
package cn.iocoder.dashboard.modules.system.convert.logger;
import cn.iocoder.dashboard.modules.system.controller.logger.vo.SysOperateLogCreateReqVO;
import cn.iocoder.dashboard.modules.system.dal.mysql.dataobject.logger.SysOperateLogDO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
@Mapper
public interface SysOperateLogConvert {
SysOperateLogConvert INSTANCE = Mappers.getMapper(SysOperateLogConvert.class);
SysOperateLogDO convert(SysOperateLogCreateReqVO bean);
}

9
src/main/java/cn/iocoder/dashboard/modules/system/dal/mysql/dao/logger/SysOperateLogMapper.java Normal file
View File

@@ -0,0 +1,9 @@
package cn.iocoder.dashboard.modules.system.dal.mysql.dao.logger;
import cn.iocoder.dashboard.modules.system.dal.mysql.dataobject.logger.SysOperateLogDO;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface SysOperateLogMapper extends BaseMapper<SysOperateLogDO> {
}

19
src/main/java/cn/iocoder/dashboard/modules/system/dal/mysql/dataobject/logger/SysOperateLogDO.java
View File

@@ -36,7 +36,7 @@ public class SysOperateLogDO extends BaseDO {
*/
private String traceId;
/**
* 操作人
* 用户编号
*
* {@link SysUserDO#getId()}
*/
@@ -69,7 +69,7 @@ public class SysOperateLogDO extends BaseDO {
* TODO 预留字段
*/
@TableField(typeHandler = FastjsonTypeHandler.class)
private Map<String, Object> ext;
private Map<String, Object> exts;
/**
* 请求方法名
@@ -79,11 +79,6 @@ public class SysOperateLogDO extends BaseDO {
* 请求地址
*/
private String requestUrl;
/**
* 请求参数
*/
@TableField(typeHandler = FastjsonTypeHandler.class)
private Map<String, Object> requestParams;
/**
* 用户 IP
*/
@@ -97,6 +92,11 @@ public class SysOperateLogDO extends BaseDO {
* Java 方法名
*/
private String javaMethod;
/**
* Java 方法的参数
*/
@TableField(typeHandler = FastjsonTypeHandler.class)
private Map<String, Object> javaMethodArgs;
/**
* 开始时间
*/
@@ -119,8 +119,9 @@ public class SysOperateLogDO extends BaseDO {
private String resultMsg;
/**
* 结果数据
*
* 如果是对象，则使用 JSON 格式化
*/
@TableField(typeHandler = FastjsonTypeHandler.class)
private Map<String, Object> resultData;
private String resultData;
}

18
src/main/java/cn/iocoder/dashboard/modules/system/enums/logger/SysOperateLogTypeEnum.java
View File

@@ -1,5 +1,6 @@
package cn.iocoder.dashboard.modules.system.enums.logger;
import cn.iocoder.dashboard.framework.logger.operatelog.core.annotations.OperateLog;
import lombok.AllArgsConstructor;
import lombok.Getter;
@@ -12,26 +13,33 @@ import lombok.Getter;
@AllArgsConstructor
public enum SysOperateLogTypeEnum {
/**
* 查询
*
* 绝大多数情况下，不会记录查询动作，因为过于大量显得没有意义。
* 在有需要的时候，通过声明 {@link OperateLog} 注解来记录
*/
GET(1),
/**
* 新增
*/
CREATE(1),
CREATE(2),
/**
* 修改
*/
UPDATE(2),
UPDATE(3),
/**
* 删除
*/
DELETE(3),
DELETE(4),
/**
* 导出
*/
EXPORT(4),
EXPORT(5),
/**
* 导入
*/
IMPORT(5),
IMPORT(6),
/**
* 其它
*

9
src/main/java/cn/iocoder/dashboard/modules/system/service/logger/SysOperateLogService.java Normal file
View File

@@ -0,0 +1,9 @@
package cn.iocoder.dashboard.modules.system.service.logger;
import cn.iocoder.dashboard.framework.logger.operatelog.core.service.OperateLogFrameworkService;
/**
* 操作日志 Service 接口
*/
public interface SysOperateLogService extends OperateLogFrameworkService {
}

33
src/main/java/cn/iocoder/dashboard/modules/system/service/logger/impl/SysOperateLogServiceImpl.java Normal file
View File

@@ -0,0 +1,33 @@
package cn.iocoder.dashboard.modules.system.service.logger.impl;
import cn.iocoder.dashboard.modules.system.controller.logger.vo.SysOperateLogCreateReqVO;
import cn.iocoder.dashboard.modules.system.convert.logger.SysOperateLogConvert;
import cn.iocoder.dashboard.modules.system.dal.mysql.dao.logger.SysOperateLogMapper;
import cn.iocoder.dashboard.modules.system.dal.mysql.dataobject.logger.SysOperateLogDO;
import cn.iocoder.dashboard.modules.system.service.logger.SysOperateLogService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class SysOperateLogServiceImpl implements SysOperateLogService {
@Resource
private SysOperateLogMapper operateLogMapper;
@Override
@Async
public void createOperateLogAsync(SysOperateLogCreateReqVO reqVO) {
SysOperateLogDO logDO = SysOperateLogConvert.INSTANCE.convert(reqVO);
try {
operateLogMapper.insert(logDO);
} catch (Throwable throwable) {
// 仅仅打印日志，不对外抛出。原因是，还是要保留现场数据。
log.error("[createOperateLogAsync][记录操作日志异常，日志为 ({})]", reqVO, throwable);
}
}
}

21
src/main/java/cn/iocoder/dashboard/util/json/JSONUtils.java Normal file
View File

@@ -0,0 +1,21 @@
package cn.iocoder.dashboard.util.json;
/**
* JSON 工具类
*
* @author 芋道源码
*/
public class JSONUtils {
// public static Map<String, Object> toJSONMap(Object javaObject) {
// return (Map<String, Object>) JSON.toJSON(javaObject);
// }
//
// public static void main(String[] args) {
// SysDictTypeCreateReqVO createReqVO = new SysDictTypeCreateReqVO();
// createReqVO.setType("1");
// createReqVO.setRemark("2");
// System.out.println(toJSONMap(createReqVO));
// }
}

10
src/main/java/cn/iocoder/dashboard/util/servlet/ServletUtils.java
View File

@@ -5,6 +5,7 @@ import cn.hutool.extra.servlet.ServletUtil;
import com.alibaba.fastjson.JSON;
import org.springframework.http.MediaType;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.net.URLEncoder;
@@ -44,4 +45,13 @@ public class ServletUtils {
IoUtil.write(response.getOutputStream(), false, content);
}
/**
* @param request 请求
* @return ua
*/
public static String getUserAgent(HttpServletRequest request) {
String ua = request.getHeader("User-Agent");
return ua != null ? ua : "";
}
}