RuoYi模块功能分析：第二章 日志

文章目录

• 一、若以的使用
• 二、@Log解析
• 三、LogAspect解析
• • 2.1、boBefore方法解析
  • 2.2、doAfterReturning方法解析
  • 2.3、doAfterThrowing方法解析
  • 2.4、handleLog方法解析
  • 2.5、getControllerMethodDescription方法解析
  • 2.6、setRequestValue方法解析
  • 2.7、excludePropertyPreFilter方法解析
  • 2.8、argsArrayToString方法解析
  • 2.9、isFilterObject方法解析

---

一、若以的使用

@log注解是若以自定义的注解类，用于接口调用记录日志

@Log(title = "参数管理", businessType = BusinessType.EXPORT)
@PreAuthorize("@ss.hasPermi('system:config:export')")
@PostMapping("/export")
public void export(HttpServletResponse response, SysConfig config)
{
    List<SysConfig> list = configService.selectConfigList(config);
    ExcelUtil<SysConfig> util = new ExcelUtil<SysConfig>(SysConfig.class);
    util.exportExcel(response, list, "参数数据");
}

---

二、@Log解析

如下就是若以自定义的日志注解

• @Target({ ElementType.PARAMETER, ElementType.METHOD }) 表示用于可以修饰方法 和参数
• @Retention(RetentionPolicy.RUNTIME) 表示注解在运行起来之后依然存在，程序可以通过反射获取这些信息
• @Documented 表示在用javadoc命令生成API文档后，文档里会出现该注解说明

package com.ruoyi.common.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 {};
}

三、LogAspect解析

前面都是对日志做的一些定义，真真实现逻辑的是如下代码。方法内容会在后文中逐一解析

• @Aspect 作用是把当前类标识为一个切面供容器读取
• @Component 将类注入容器

package com.ruoyi.framework.aspectj;

/**
 * 操作日志记录处理
 */
@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 boBefore(JoinPoint joinPoint, Log controllerLog)
    {
    }

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

    /**
     * 拦截异常操作
     * 
     * @param joinPoint 切点
     * @param e 异常
     */
    @AfterThrowing(value = "@annotation(controllerLog)", throwing = "e")
    public void doAfterThrowing(JoinPoint joinPoint, Log controllerLog, Exception e)
    {
    }
	
    /**
     * 填充日志并写入数据库
     * @param joinPoint
     * @param controllerLog
     * @param e
     * @param jsonResult
     */
    protected void handleLog(final JoinPoint joinPoint, Log controllerLog, final Exception e, Object jsonResult)
    {
    }

    /**
     * 获取注解中对方法的描述信息 用于Controller层注解
     * 
     * @param log 日志
     * @param operLog 操作日志
     * @throws Exception
     */
    public void getControllerMethodDescription(JoinPoint joinPoint, Log log, SysOperLog operLog, Object jsonResult) throws Exception
    {
    }

    /**
     * 获取请求的参数，放到log中
     * 
     * @param operLog 操作日志
     * @throws Exception 异常
     */
    private void setRequestValue(JoinPoint joinPoint, SysOperLog operLog, String[] excludeParamNames) throws Exception
    {
    }

    /**
     * 参数拼装
     */
    private String argsArrayToString(Object[] paramsArray, String[] excludeParamNames)
    {
    }

    /**
     * 忽略敏感属性
     */
    public PropertyPreExcludeFilter excludePropertyPreFilter(String[] excludeParamNames)
    {
    }

    /**
     * 判断是否需要过滤的对象。
     * 
     * @param o 对象信息。
     * @return 如果是需要过滤的对象，则返回true；否则返回false。
     */
    @SuppressWarnings("rawtypes")
    public boolean isFilterObject(final Object o)
    {
    }
}

2.1、boBefore方法解析

• @Before定义在方法执行前执行的代码
• @annotation(controllerLog)定义的执行条件，必须被Log注解所注释
• JoinPoint joinPoint参数可以获取到当前执行方法的所有相关信息，Log controllerLog参数可以获取到日志注解定义的所有参数信息

/**
 * 处理请求前执行
 */
@Before(value = "@annotation(controllerLog)")
public void boBefore(JoinPoint joinPoint, Log controllerLog)
{
	// 在当前name为Cost Time的线程中存入当前系统时间戳
    TIME_THREADLOCAL.set(System.currentTimeMillis());
}

2.2、doAfterReturning方法解析

• @AfterReturning定义在方法完毕后执行的代码
• returning定义了返回结果接收的参数为jsonResult
• Object jsonResult在jsonResult中存放了所有的方法返回信息

/**
 * 处理完请求后执行
 *
 * @param joinPoint 切点
 */
@AfterReturning(pointcut = "@annotation(controllerLog)", returning = "jsonResult")
public void doAfterReturning(JoinPoint joinPoint, Log controllerLog, Object jsonResult)
{
	// 调用具体记录日志的方法，具体内容在后文
    handleLog(joinPoint, controllerLog, null, jsonResult);
}

2.3、doAfterThrowing方法解析

• @AfterThrowing定义在抛出异常后执行的代码
• throwing定义了异常结果接收的参数为e
• Exception在e中存放了所有的异常结果信息

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

2.4、handleLog方法解析

handleLog是核心处理日志的核心方法方法

    /**
     * 处理日志
     * @param joinPoint
     * @param controllerLog
     * @param e
     * @param jsonResult
     */
    protected void handleLog(final JoinPoint joinPoint, Log controllerLog, final Exception e, Object jsonResult)
    {
        try
        {
            // 获取当前登录用户，SecurityUtils工具类封装了对Security处理的方法。
            LoginUser loginUser = SecurityUtils.getLoginUser();

            // 日志实体类
            SysOperLog operLog = new SysOperLog();

            // 填充数据
            operLog.setStatus(BusinessStatus.SUCCESS.ordinal()); // 成功状态(0)
            String ip = IpUtils.getIpAddr(); // 获取请求ip地址
            operLog.setOperIp(ip); 
            operLog.setOperUrl(StringUtils.substring(ServletUtils.getRequest().getRequestURI(), 0, 255));
            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(e.getMessage(), 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());
            // 异步写入数据库
            AsyncManager.me().execute(AsyncFactory.recordOper(operLog));
        }
        catch (Exception exp)
        {
            // 记录本地异常日志
            log.error("异常信息:{}", exp.getMessage());
            exp.printStackTrace();
        }
        finally
        {
            // 移除记录时间戳
            TIME_THREADLOCAL.remove();
        }
    }

2.5、getControllerMethodDescription方法解析

getControllerMethodDescription方法用于填充日志参数

/**
 * 获取注解中对方法的描述信息 用于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))
    {
    	// 讲响应参数转化为字符串，并且截取2000个字符
        operLog.setJsonResult(StringUtils.substring(JSON.toJSONString(jsonResult), 0, 2000));
    }
}

2.6、setRequestValue方法解析

setRequestValue方法主要用于保存请求参数

    /**
     * 获取请求的参数，放到log中
     * 
     * @param operLog 操作日志
     * @throws Exception 异常
     */
    private void setRequestValue(JoinPoint joinPoint, SysOperLog operLog, String[] excludeParamNames) throws Exception
    {
        // 获取所有url参数
        Map<?, ?> paramsMap = ServletUtils.getParamMap(ServletUtils.getRequest());
        // 获取请求方法
        String requestMethod = operLog.getRequestMethod();
        if (StringUtils.isEmpty(paramsMap)
                && (HttpMethod.PUT.name().equals(requestMethod) || HttpMethod.POST.name().equals(requestMethod)))
        {
            // 如果paramsMap为null并且是put请求或者post请求。对参数进行过滤和拼接
            String params = argsArrayToString(joinPoint.getArgs(), excludeParamNames);
            // 填充请求参数并截取2000个字符
            operLog.setOperParam(StringUtils.substring(params, 0, 2000));
        }
        else
        {
            // 否则
            operLog.setOperParam(StringUtils.substring(JSON.toJSONString(paramsMap, excludePropertyPreFilter(excludeParamNames)), 0, 2000));
        }
    }

2.7、excludePropertyPreFilter方法解析

此方法主要用于过滤敏感数据，使用了alibaba的fastjson2。并且使用PropertyPreExcludeFilter继承了SimplePropertyPreFilter通过addExcludes方法添加过滤字段

/**
 * 忽略敏感属性
 */
public PropertyPreExcludeFilter excludePropertyPreFilter(String[] excludeParamNames)
{
    return new PropertyPreExcludeFilter().addExcludes(ArrayUtils.addAll(EXCLUDE_PROPERTIES, excludeParamNames));
}

2.8、argsArrayToString方法解析

此方法主要用于请求参数的过滤和转换为json处理

/**
 * 参数拼装
 * @param paramsArray
 * @param excludeParamNames
 * @return
 */
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
                {
                    // 对单个参数进行过滤并且转换为json
                    String jsonObj = JSON.toJSONString(o, excludePropertyPreFilter(excludeParamNames));
                    
                    // 拼接参数
                    params += jsonObj.toString() + " ";
                }
                catch (Exception e)
                {
                }
            }
        }
    }

    // 返回处理后的参数并且去除前后空格
    return params.trim();
}

2.9、isFilterObject方法解析

此方法主要用于判断是否文件上传相关的其他特定类型如果是就不拼接写入数据库的参数

• @SuppressWarnings用于告诉编译器对指定类型不进行提示警告
• getComponentType()用于获取数组的class
• isAssignableFrom()用于判断俩个class对象是否存在关系
• instanceof用于判断俩个对象是否存在关系

    /**
     * 判断是否需要过滤的对象。
     * @param o 对象信息。
     * @return 如果是需要过滤的对象，则返回true；否则返回false。
     */
    @SuppressWarnings("rawtypes") // @SuppressWarnings，表示警告抑制，告诉编译器不用提示相关的警告信息
    public boolean isFilterObject(final Object o)
    {
        // 获取class对象
        Class<?> clazz = o.getClass();

        // 判断是否为数组
        if (clazz.isArray())
        {
            // 判断是否为MultipartFile或其子类
            return clazz.getComponentType().isAssignableFrom(MultipartFile.class);
        }

        // 判断是否为集合
        else if (Collection.class.isAssignableFrom(clazz))
        {
            // 转换为集合类型
            Collection collection = (Collection) o;

            // 遍历集合
            for (Object value : collection)
            {
                // 判断是否为MultipartFile或其子类。
                return value instanceof MultipartFile;
            }
        }

        // 判断是否为map
        else if (Map.class.isAssignableFrom(clazz))
        {
            // 转换为map类型
            Map map = (Map) o;

            // 遍历map
            for (Object value : map.entrySet())
            {
                // 判断是否为MultipartFile或其子类。
                Map.Entry entry = (Map.Entry) value;
                return entry.getValue() instanceof MultipartFile;
            }
        }

        // 如果对象不是数组、集合、映射类型中的一种，直接判断对象是否是 MultipartFile，或是 HttpServletRequest、HttpServletResponse、BindingResult 类型的实例。
        return o instanceof MultipartFile || o instanceof HttpServletRequest || o instanceof HttpServletResponse
                || o instanceof BindingResult;
    }