登录
当前位置： 首页 > 知识库问答 >
问题：

java - 请问若依的这段日志aop代码是什么意思啊?

杨飞
2024-07-08

请问若依的这段日志aop代码是什么意思啊
问题代码

    @Before(value = "@annotation(controllerLog)")
    public void boBefore(JoinPoint joinPoint, Log controllerLog)
    {
        TIME_THREADLOCAL.set(System.currentTimeMillis());
    }

首先@annotation里不是要全限定类名的注解吗
其次controllerLog又是哪来的，项目中都找不到这个注解啊，而且业务方法上是加的@Log啊，为什么不是@annotation("com.xxx.Log")
最后，idea是怎么分辨出controllerLog是Log类的
image.png

以下是完整代码

package com.ruoyi.framework.aspectj;

import java.util.Collection;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.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.stereotype.Component;
import org.springframework.validation.BindingResult;
import org.springframework.web.multipart.MultipartFile;
import com.alibaba.fastjson2.JSON;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.enums.BusinessStatus;
import com.ruoyi.common.enums.HttpMethod;
import com.ruoyi.common.filter.PropertyPreExcludeFilter;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.ServletUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.ip.IpUtils;
import com.ruoyi.framework.manager.AsyncManager;
import com.ruoyi.framework.manager.factory.AsyncFactory;
import com.ruoyi.system.domain.SysOperLog;

/**
 * 操作日志记录处理
 * 
 * @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 boBefore(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
        {
            // 获取当前的用户
            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));
            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();
        }
    }

    /**
     * 获取注解中对方法的描述信息 用于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)
                && (HttpMethod.PUT.name().equals(requestMethod) || HttpMethod.POST.name().equals(requestMethod)))
        {
            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个答案

龙枫
2024-07-08

image.png

框架和IDEA都是根据读取的是方法参数上的类型信息

凌长恨
2024-07-08 
@Before(value = "@annotation(controllerLog)")
public void boBefore(JoinPoint joinPoint, Log controllerLog)
{
    TIME_THREADLOCAL.set(System.currentTimeMillis());
}

这段代码的意思是在对被注解标记的方法执行之前，将当前的时间记录下来，这样做是为了在被注解标记的方法执行之后通过计算两者之间的时间差就可以得出切入点(被增强方法)的执行时间，若依框架就是通过这样来简化获得方法的执行时间并存入数据库日志的，这段代码往下看就有@doAfterReturning(处理完请求后执行)和@doAfterThrowing(拦截异常操作),都是执行handleLog方法,注意看这里:

// 设置消耗时间
operLog.setCostTime(System.currentTimeMillis() - TIME_THREADLOCAL.get());
// 保存数据库
AsyncManager.me().execute(AsyncFactory.recordOper(operLog));

就是这段逻辑。注意这里若依用了ThreadLocal线程本地类来保证线程安全，每个线程都会持有一份只属于它自己的变量拷贝。

@annotation里不是要全限定类名的注解?其次controllerLog又是哪来的，项目中都找不到这个注解啊，而且业务方法上是加的@Log啊，为什么不是@annotation("com.xxx.Log")?最后，idea是怎么分辨出controllerLog是Log类的

可以是全限定类名的注解，但在这里用的其实就是形参Log controllerLog代表的全限定类名的注解的意思，对应的全限定类名就是 com.ruoyi.common.annotation.Log,这种写法就方便你可以直接把指定类写在方法入参里使用IDLE来帮助你补全引入。最后IDEA是根据aspectj的源代码里对于切面表达式的解析规则来分辨的。

 类似资料：
  • 在火花日志中阶段是什么意思？

    当我使用spark运行一个作业时，我会得到以下日志？

  • 这是什么意思？

    问题内容： 我是Go的新手，在浏览其他一些线程时遇到了以下代码行： 含义是什么？它是否指定将在if条件中分配某些内容（因为err似乎正在发生这种情况）？我在Wiki上找不到这种语法的示例，并且我很好奇它的用途。 问题答案： 因为返回两个值，所以如果需要它们中的任何一个，都必须在某个地方接收这些值。该是一个占位符，基本的意思是“我不关心这个特殊的返回值。” 在这里，我们只关心检查错误，而无需对实际的

  • 这行Java流是什么意思？

    所以我有这行代码。它给了我输出[6,28]。你们知道为什么吗？我不知道有人想打印什么样的数字。

  • 这个线程连接代码是什么意思？

    在这段代码中，两个连接和断开是什么意思？导致停止，直到终止？

  • 解释下这段代码的意思！

    问题内容： 问题答案： 作用 在你的Chrome浏览器的控制台中输入这段代码，你会发现不同HTML层都被使用不同的颜色添加了一个高亮的边框。是不是非常酷？但是，简单来说，这段代码只是首先获取了所有的页面元素，然后使用一个不同的颜色为它们添加了一个1px的边框。 解析 => 调用引用数组的forEach方法 => => => 对二进数1小数点右移24位 => 获得了一个位于之间的随机整数，也就是随机

  • Java垃圾回收日志中的“ GC--”是什么意思？

    问题内容： 我们打开了详细的GC日志记录来跟踪已知的内存泄漏，并在日志中获得以下条目： 我理解其中的第一个和第三个，但是“ GC–”是什么意思？ 问题答案： 我在gc输出中得到了以下几行： 我读了Yishai的回答，这很有意义，但是当JVM在GC日志中打印“-”时，我想在Java GC源代码中亲自查看它，以及为什么。 据我所知，Young Gen的“ Parallel Scavenge”是一个停滞

  • Bang IE7-这是什么意思？

    问题内容： 这个头衔看起来并不那么疯狂。我承诺！！ 在研究另一个问题时，我在Stack Overflow的样式表中注意到以下内容： 这是一种奇怪的条件样式吗？这是一个错误吗？假设这不是一个错误，那么它适用于所有IE版本吗？有没有一种方法可以指定给定规则仅适用于大于（例如7）的IE版本？ 我以前从未遇到过-我一直在使用条件注释来表示IE特定的样式（以及其价值，我宁愿将所有IE特定样式完全分开）。 问

  • Java“Program to an interface”。这是什么意思？

    问题内容： 我一直遇到这个名词： 编程到接口。 这到底是什么意思？现实生活中的设计方案将受到高度赞赏。 问题答案： 简而言之，而不是像这样写类 我依靠这个特定的班级来做我的工作 你写的方式说 我依赖于任何类，做这个东西做我的工作。 第一个示例表示一个类，该类依赖于特定的具体实现来执行其工作。从本质上讲，这不是很灵活。 第二个示例表示写入接口的类。它不在乎您使用什么具体对象，而只是在意它实现某些行为

相关问答

在git push-u源代码master中-u标志是什么意思？javascript - 有没有前辈帮我讲下这段代码什么意思？这行代码是什么意思？如何创建此类的对象？分级依赖树，(*)是什么意思？{param:.+}`中的“:.+”是什么意思（java）？

相关文章

Java中的“ >>>”是什么意思？请问AOP的原理是什么？请问MyBatis中的动态SQL是什么意思？Linux内核代码中的“ EXPORT_SYMBOL”是什么意思？Java中的“ ReentrantLock”是什么意思？

相关阅读

什么是Java IO流什么是Java集合Spring AOP代理ChatGPT为什么这么火？Java 什么是多线程

相关工具

Apache日志分析程序IIS6.0 日志导出工具M-AopJBoss AOPjQuery AOP

相关文档

30 秒就能理解的 JavaScript 代码片段代码整洁的 JavaScriptLinux 就该这么学阿里巴巴 Java 代码开发规范指南Airbnb 的 Ruby 代码风格指南
快捷导航： 新手教程 算法原理 架构设计 Java进阶 数据库进阶 大厂专栏 面试经验 编程笔记 编程问答 所有专题 文档资料 工具软件 电子书籍 小牛导航
在线工具： 房贷计算器 个税计算器 Linux命令查询 Json格式化 正则表达式 颜色转换 AES加解密 SHA1加密 MD5加密 毒鸡汤 字数统计 随机密码生成 进制转换 Base64编解码 励志句子
Copyright © 2019-2024 小牛知识库@xnip.cn. All Rights Reserved.