java利用切面（aspect）记录日志实现性能跟踪以及用户行为分析

已于 2022-06-13 17:17:05 修改
阅读量6.1k 收藏 49
点赞数 12
分类专栏： 运维监控
于 2022-06-09 16:38:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liaomingwu/article/details/125198728
版权

性能跟踪 日志埋点

记录日志的目的是多种多样的，这里主要以性能跟踪和用户行为分析为目的讨论如何记录日志。

1. 概述

一个有一定规模的应用系统，都会存在大量的功能，这些功能通过菜单，链接，按钮和页面进行展示，在系统建设初期，为了尽早将系统投入生产，对于系统性能优化方面可能考虑不够。当然，系统初期的用户量和数据量都相对较小，系统性能也不会是有明显的问题。但是，随着系统的持续运行，用户量和数据量的不断增加，性能性能的优化就变得越来越重要了。

一个请求的响应速度直接影响到用户的使用体验，只有用户系统的响应时间在正常的接受范围内时，用户才会感觉到系统是正常的，一旦超过这个时间，就会感觉系统很慢。但是系统慢，只是一个大概的描述，是个别的特定操作响应慢，还是所有的操作都慢，是个别用户觉得慢，还是所有用户都觉得慢，这就不容易描述清楚。所以，系统最好有自身处理时间的一个记录和统计，包括各种操作，各种条件下的操作，包括不同的用户，不同的时间，不同的输入条件等。

另一方面，系统在不断的增加功能和完善过程中，增加了各种各样的功能，这些功能有哪些使用得多，哪些使用得少，都是什么用户在使用，下一步的发展方向在什么地方。最好的方法就是系统能够提供针对性的统计，这是最直接的，也是最客观的，不受主观判断的影响。通过日志记录，可以分析出系统提供的功能中，哪些功能使用最频繁，哪些功能使用最少，这样有利于在后续的版本升级中，把重心放在用户关心的功能上。用户使用少的功能，可以进一步分析用户使用少的原因，比如是用户不了解，还是用户的确不需要等。

2. 主要代码

总体技术思路，采用切面方式拦截请求，记录每个请求的信息，包括请求用户，请求时间，请求参数以及执行结果等，有了这些请求数据，就可以进行统计分析，得出系统是否存在性能瓶颈。也可以统计出什么用户对什么功能的使用最频繁，什么功能几乎没有人使用。

2.1 注解代码

切面采用根据注解判断是否需要拦截方法的调用，所以首先需要创建一个自定义注解。

package com.ruoyi.common.annotation;


import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.enums.OperatorType;
import org.springframework.web.bind.annotation.ResponseBody;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

// 事件埋点
@Target({ElementType.PARAMETER, ElementType.METHOD})//作用在参数和方法上
@Retention(RetentionPolicy.RUNTIME)//运行时注解
@Documented//表明这个注解应该被 javadoc工具记录
// @ResponseBody//响应时转JSON格式
public @interface EventTrack {

    /**
     * 模块
     */
    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;

    /**
     * 业务描述
     * @return
     */
    String description() default "";

    /**
     * 是否打日志 默认打
     */
    boolean isLog() default true;

}

在需要记录日志的方法上，添加该注解，切面会根据该注解进行拦截并日志记录。 在注解中，可以添加相关的参数，这些参数可以记录到日志中，用于区分不同的方法。

2.2 日志类代码

package com.ruoyi.system.domain;

import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
import com.ruoyi.common.annotation.Excel;
import com.ruoyi.common.core.domain.BaseEntity;

/**
 * 事件跟踪对象 event_track_log
 * 
 * @author 
 * @date 2022-06-08
 */
public class EventTrackLog extends BaseEntity
{
    private static final long serialVersionUID = 1L;

    /** 跟踪编号 */
    private Long traceId;

    /** 应用名称 */
    @Excel(name = "应用名称")
    private String systemName;

    /** 模块名称 */
    @Excel(name = "模块名称")
    private String moduleTitle;

    /** 业务类型 */
    @Excel(name = "业务类型")
    private String businessType;

    /** 请求方式 */
    @Excel(name = "请求方式")
    private String requestMethod;

    /** 操作人员 */
    @Excel(name = "操作人员")
    private String userName;

    /** 部门名称 */
    @Excel(name = "部门名称")
    private String deptName;

    /** 用户类型 */
    @Excel(name = "用户类型")
    private String userType;

    /** 商户编号 */
    @Excel(name = "商户编号")
    private String merchantNo;

    /** 操作状态 */
    @Excel(name = "操作状态")
    private Long status;

    /** 错误消息 */
    @Excel(name = "错误消息")
    private String errorMsg;

    /** 开始时间 */
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    @Excel(name = "开始时间", width = 30, dateFormat = "yyyy-MM-dd HH:mm:ss")
    private Date startTime;

    /** 结束时间 */
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    @Excel(name = "结束时间", width = 30, dateFormat = "yyyy-MM-dd HH:mm:ss")
    private Date endTime;

    /** 方法名 */
    @Excel(name = "方法名")
    private String method;

    /** 描述信息 */
    @Excel(name = "描述信息")
    private String description;

    /** 客户端ip地址 */
    @Excel(name = "客户端ip地址")
    private String ipAddress;

    /** 户端主机名 */
    @Excel(name = "户端主机名")
    private String hostName;

    /** 请求参数 */
    @Excel(name = "请求参数")
    private String reqParams;

    /** 访问url */
    @Excel(name = "访问url")
    private String url;

    /** 异常信息 */
    @Excel(name = "异常信息")
    private String exceptMsg;

    /** 返回结果 */
    @Excel(name = "返回结果")
    private String result;

    /** 时间长度 */
    @Excel(name = "时间长度")
    private Long timeSpend;

    /** 调用次数 */
    @Excel(name = "调用次数")
    private Long number;

    /** 访问渠道 */
    @Excel(name = "访问渠道")
    private String channel;

    public void setTraceId(Long traceId) 
    {
        this.traceId = traceId;
    }

    public Long getTraceId() 
    {
        return traceId;
    }
    public void setSystemName(String systemName) 
    {
        this.systemName = systemName;
    }

    public String getSystemName() 
    {
        return systemName;
    }
    public void setModuleTitle(String moduleTitle) 
    {
        this.moduleTitle = moduleTitle;
    }

    public String getModuleTitle() 
    {
        return moduleTitle;
    }
    public void setBusinessType(String businessType) 
    {
        this.businessType = businessType;
    }

    public String getBusinessType() 
    {
        return businessType;
    }
    public void setRequestMethod(String requestMethod) 
    {
        this.requestMethod = requestMethod;
    }

    public String getRequestMethod() 
    {
        return requestMethod;
    }
    public void setUserName(String userName) 
    {
        this.userName = userName;
    }

    public String getUserName() 
    {
        return userName;
    }
    public void setDeptName(String deptName) 
    {
        this.deptName = deptName;
    }

    public String getDeptName() 
    {
        return deptName;
    }
    public void setUserType(String userType) 
    {
        this.userType = userType;
    }

    public String getUserType() 
    {
        return userType;
    }
    public void setMerchantNo(String merchantNo) 
    {
        this.merchantNo = merchantNo;
    }

    public String getMerchantNo() 
    {
        return merchantNo;
    }
    public void setStatus(Long status) 
    {
        this.status = status;
    }

    public Long getStatus() 
    {
        return status;
    }
    public void setErrorMsg(String errorMsg) 
    {
        this.errorMsg = errorMsg;
    }

    public String getErrorMsg() 
    {
        return errorMsg;
    }
    public void setStartTime(Date startTime) 
    {
        this.startTime = startTime;
    }

    public Date getStartTime() 
    {
        return startTime;
    }
    public void setEndTime(Date endTime) 
    {
        this.endTime = endTime;
    }

    public Date getEndTime() 
    {
        return endTime;
    }
    public void setMethod(String method) 
    {
        this.method = method;
    }

    public String getMethod() 
    {
        return method;
    }
    public void setDescription(String description) 
    {
        this.description = description;
    }

    public String getDescription() 
    {
        return description;
    }
    public void setIpAddress(String ipAddress) 
    {
        this.ipAddress = ipAddress;
    }

    public String getIpAddress() 
    {
        return ipAddress;
    }
    public void setHostName(String hostName) 
    {
        this.hostName = hostName;
    }

    public String getHostName() 
    {
        return hostName;
    }

    public String getReqParams() {
        return reqParams;
    }

    public void setReqParams(String reqParams) {
        this.reqParams = reqParams;
    }

    public void setUrl(String url)
    {
        this.url = url;
    }

    public String getUrl() 
    {
        return url;
    }
    public void setExceptMsg(String exceptMsg) 
    {
        this.exceptMsg = exceptMsg;
    }

    public String getExceptMsg() 
    {
        return exceptMsg;
    }
    public void setResult(String result) 
    {
        this.result = result;
    }

    public String getResult() 
    {
        return result;
    }
    public void setTimeSpend(Long timeSpend) 
    {
        this.timeSpend = timeSpend;
    }

    public Long getTimeSpend() 
    {
        return timeSpend;
    }
    public void setNumber(Long number) 
    {
        this.number = number;
    }

    public Long getNumber() 
    {
        return number;
    }
    public void setChannel(String channel) 
    {
        this.channel = channel;
    }

    public String getChannel() 
    {
        return channel;
    }

    @Override
    public String toString() {
        return new ToStringBuilder(this,ToStringStyle.MULTI_LINE_STYLE)
            .append("traceId", getTraceId())
            .append("systemName", getSystemName())
            .append("moduleTitle", getModuleTitle())
            .append("businessType", getBusinessType())
            .append("requestMethod", getRequestMethod())
            .append("userName", getUserName())
            .append("deptName", getDeptName())
            .append("userType", getUserType())
            .append("merchantNo", getMerchantNo())
            .append("status", getStatus())
            .append("errorMsg", getErrorMsg())
            .append("startTime", getStartTime())
            .append("endTime", getEndTime())
            .append("method", getMethod())
            .append("description", getDescription())
            .append("ipAddress", getIpAddress())
            .append("hostName", getHostName())
            .append("reqParams", getReqParams())
            .append("url", getUrl())
            .append("exceptMsg", getExceptMsg())
            .append("result", getResult())
            .append("timeSpend", getTimeSpend())
            .append("number", getNumber())
            .append("channel", getChannel())
            .toString();
    }
}

事件日志信息记录类，与对应的数据库表脚本一一对应。事件日志记录的信息，可以根据业务需要进行扩展，比如有的业务场景中需要用户编号，客户编号或者用户手机号等进行关联标识。

CREATE TABLE `event_track_log` (
  `trace_id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '跟踪编号',
  `system_name` varchar(32) DEFAULT NULL COMMENT '应用名称',
  `module_title` varchar(32) DEFAULT NULL COMMENT '模块名称',
  `business_type` varchar(20) DEFAULT NULL COMMENT '业务类型',
  `request_method` varchar(10) DEFAULT NULL COMMENT '请求方式',
  `user_name` varchar(64) DEFAULT NULL COMMENT '操作人员',
  `dept_name` varchar(64) DEFAULT NULL COMMENT '部门名称',
  `user_type` varchar(20) DEFAULT NULL COMMENT '用户类型',
  `merchant_no` varchar(255) DEFAULT NULL COMMENT '商户编号',
  `status` int(11) DEFAULT NULL COMMENT '操作状态',
  `error_msg` varchar(255) DEFAULT NULL COMMENT '错误消息',
  `start_time` datetime DEFAULT NULL COMMENT '开始时间',
  `end_time` datetime DEFAULT NULL COMMENT '结束时间',
  `method` varchar(64) DEFAULT NULL COMMENT '方法名',
  `description` varchar(255) DEFAULT NULL COMMENT '描述信息',
  `ip_address` varchar(32)  DEFAULT NULL COMMENT '客户端ip地址',
  `host_name` varchar(32)  DEFAULT NULL COMMENT '户端主机名',
  `req_params` varchar(255)  DEFAULT NULL COMMENT '请求参数',
  `url` varchar(255) DEFAULT NULL COMMENT '访问url',
  `except_msg` varchar(255) DEFAULT NULL COMMENT '异常信息',
  `result` varchar(255) DEFAULT NULL COMMENT '返回结果',
  `time_spend` bigint(20) DEFAULT NULL COMMENT '时间长度',
  `number` int(11) DEFAULT NULL COMMENT '调用次数',
  `channel` varchar(20) DEFAULT NULL COMMENT '访问渠道',
  `create_by` varchar(32) DEFAULT NULL COMMENT '创建者',
  `create_time` datetime DEFAULT NULL COMMENT '创建时间',
  PRIMARY KEY (`trace_id`)
) ENGINE=InnoDB AUTO_INCREMENT=481 DEFAULT CHARSET=utf8 COMMENT='事件跟踪';

2.3 切面类代码

package com.ruoyi.framework.aspectj;

import com.alibaba.fastjson.JSON;
import com.ruoyi.common.annotation.EventTrack;
import com.ruoyi.common.config.RuoYiConfig;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.ServletUtils;
import com.ruoyi.common.utils.ShiroUtils;
import com.ruoyi.system.domain.EventTrackLog;
import com.ruoyi.system.service.IEventTrackLogService;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.lang.reflect.Method;
import java.net.InetAddress;
import java.util.Arrays;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicLong;

/**
 * author:
 * 埋点切面
 */
@Aspect
@Component
public class EventTrackAspect {

    //日志工厂获取日志对象
    static Logger logger = LoggerFactory.getLogger(EventTrackAspect.class);

    /** 排除敏感属性字段 */
    public static final String[] EXCLUDE_PROPERTIES = { "password", "oldPassword", "newPassword", "confirmPassword" };

    @Autowired
    private IEventTrackLogService eventTrackLogService;

    //startTime存放开始时间
    private ThreadLocal<Map<String, Long >> startTime = new ThreadLocal<>();

    //eventTrackLog日志访问对象
    private ThreadLocal<EventTrackLog> eventTrackLog = new ThreadLocal<>();

    //Controller层切点
    @Pointcut("@annotation(com.ruoyi.common.annotation.EventTrack)")
    public void controllerAspectse() {
    }

    //前置通知  用于拦截Controller层记录用户的操作
    @Before("controllerAspectse()")
    public void before(JoinPoint pjp) {
        //方法调用之前初始化
        EventTrackLog eventTrackLog = this.eventTrackLog.get();
        eventTrackLog = new EventTrackLog();

        Map<String, Long> map = new HashMap<>();
        map.put("startTime",System.currentTimeMillis());
        this.startTime.set(map);

        logger.info("==============前置通知开始:记录用户的操作==============");
        String currentTime = DateUtils.getTime();

        logger.info("请求开始时间:" + currentTime);
        eventTrackLog.setStartTime(new Date());
        String resultString = "";

        // 是否打日志 默认打
        boolean isLog = true;
        try {
            MethodSignature signature = (MethodSignature) pjp.getSignature();
            EventTrack eventTrack = signature.getMethod().getAnnotation(EventTrack.class);
            //是否开启日志打印
            isLog = eventTrack.isLog();
            if(isLog){
                //开始打印日志
                HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
                HttpSession session = request.getSession();
                String api = pjp.getTarget().getClass().getName() + "." + pjp.getSignature().getName();
                logger.info("请求API：" + api);
                eventTrackLog.setMethod(api);

                String methodDescription = getControllerMethodDescription(pjp);
                logger.info("方法描述：" + methodDescription);
                eventTrackLog.setDescription(methodDescription);

                String ipAddress = InetAddress.getLocalHost().toString().substring(InetAddress.getLocalHost().toString().lastIndexOf("/") + 1);
                logger.info("请求ip："+ ipAddress);
                eventTrackLog.setIpAddress(ipAddress);

                String hostName = InetAddress.getLocalHost().getHostName();
                logger.info("机器名：" + hostName);
                eventTrackLog.setHostName(hostName);

                Enumeration<?> enu = request.getParameterNames();
                String params = "{";
                while (enu.hasMoreElements()) {
                    String paraName = (String) enu.nextElement();
                    List<String> list = Arrays.asList(EXCLUDE_PROPERTIES);
                    if(list.contains(paraName)) {
                        continue;
                    }

                    params += "\"" + paraName + "\":\"" + request.getParameter(paraName) + "\",";
                }
                String methodParams = params + "}";
                String substring = methodParams.substring(0, methodParams.length() - 2);
                substring = substring + "}";
                logger.info("方法参数：" + substring);
                eventTrackLog.setReqParams(substring);

                StringBuffer url = request.getRequestURL();
                logger.info("URL：" + url);
                eventTrackLog.setUrl(String.valueOf(url));
            }
        } catch (Exception e) {
            StackTraceElement stackTraceElement2 = e.getStackTrace()[2];
            String reason = "异常：【"+
                    "类名："+stackTraceElement2.getClassName()+";"+
                    "文件："+stackTraceElement2.getFileName()+";"+"行："+
                    stackTraceElement2.getLineNumber()+";"+"方法："
                    +stackTraceElement2.getMethodName() + "】";
            //记录本地异常日志
            logger.error("==============前置通知异常:记录访问异常信息==============");
            String message = e.getMessage() + "|" + reason;
            logger.error("异常信息：",message);
            eventTrackLog.setErrorMsg(message);
            eventTrackLog.setResult("请求发生异常，异常信息：" + message);
        }finally {
            this.eventTrackLog.set(eventTrackLog);
        }
    }

    @Around("controllerAspectse()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {

        // 获取方法签名
        MethodSignature signature = (MethodSignature) pjp.getSignature();
        EventTrack eventTrack = signature.getMethod().getAnnotation(EventTrack.class);
        //是否开启日志打印
        Boolean isLog = eventTrack.isLog();

        EventTrackLog eventTrackLog = new EventTrackLog();

        Long startTime = System.currentTimeMillis();

        eventTrackLog.setStartTime(new Date());

        try {

            //开始打印日志
            HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
            HttpSession session = request.getSession();
            String api = pjp.getTarget().getClass().getName() + "." + pjp.getSignature().getName();
            logger.info("请求API：" + api);
            eventTrackLog.setMethod(api);

            String methodDescription = getControllerMethodDescription(pjp);
            logger.info("方法描述：" + methodDescription);
            eventTrackLog.setDescription(methodDescription);

            String ipAddress = InetAddress.getLocalHost().toString().substring(InetAddress.getLocalHost().toString().lastIndexOf("/") + 1);
            logger.info("请求ip："+ ipAddress);
            eventTrackLog.setIpAddress(ipAddress);

            String hostName = InetAddress.getLocalHost().getHostName();
            logger.info("机器名：" + hostName);
            eventTrackLog.setHostName(hostName);

            Enumeration<?> enu = request.getParameterNames();
            String params = "{";
            while (enu.hasMoreElements()) {
                String paraName = (String) enu.nextElement();

                List<String> list = Arrays.asList(EXCLUDE_PROPERTIES);
                if(list.contains(paraName)) {
                    continue;
                }

                params += "\"" + paraName + "\":\"" + request.getParameter(paraName) + "\",";
            }
            String methodParams = params + "}";
            String substring = methodParams.substring(0, methodParams.length() - 2);
            substring = substring + "}";
            logger.info("方法参数：" + substring);
            eventTrackLog.setReqParams(substring);

            StringBuffer url = request.getRequestURL();
            logger.info("URL：" + url);
            eventTrackLog.setUrl(String.valueOf(url));

        }catch (Exception e) {

        }

        Object proceed = pjp.proceed();
        String result = JSON.toJSONString(proceed);
        logger.info("==============环切方法执行完成==============");
        logger.info("请求结果：" + result);

        try {

            Long endTime = System.currentTimeMillis();

            Long timeSpan = endTime - startTime;
            logger.info("timeSpan = " + timeSpan);

            eventTrackLog.setTimeSpend(timeSpan);

            eventTrackLog.setEndTime(new Date());

            // 获取当前的用户
            SysUser currentUser = ShiroUtils.getSysUser();

            if(currentUser != null)
            {
                eventTrackLog.setUserName(currentUser.getLoginName());
                eventTrackLog.setDeptName(currentUser.getDept().getDeptName());
            }

            // eventTrackLog.setSystemName("平台管理系统");
            eventTrackLog.setSystemName(RuoYiConfig.getName());
            // eventTrackLog.setModuleTitle("后台管理");



            eventTrackLog.setStatus(0l);
            eventTrackLog.setNumber(1L);

            eventTrackLog.setModuleTitle(eventTrack.title());
            eventTrackLog.setBusinessType(eventTrack.businessType().toString());

            if(ServletUtils.checkAgentIsMobile(ServletUtils.getRequest().getHeader("User-Agent")))
            {
                eventTrackLog.setChannel("Mobile");
            }
            else {
                eventTrackLog.setChannel("PC");
            }

            eventTrackLog.setCreateBy("around");
            eventTrackLog.setCreateTime(new Date());


        } catch (Exception e) {


        } finally {

            // 添加日志信息入库
            eventTrackLogService.insertEventTrackLog(eventTrackLog);
        }



        return proceed;
    }

    /**
     * 拦截异常操作
     *
     * @param joinPoint 切点
     * @param ex 异常
     */
    @AfterThrowing(value = "@annotation(eventTrack)", throwing = "ex")
    public void doAfterThrowing(JoinPoint joinPoint, EventTrack eventTrack, Exception ex)
    {
        logger.info("==============异常方法执行==============");
        EventTrackLog eventTrackLog = this.eventTrackLog.get();

        try {
            //获取方法名
            String methodName = joinPoint.getSignature().getName();

            Long end = System.currentTimeMillis();
            Long total =  end - startTime.get().get("startTime");
            logger.info("执行总耗时为：" +total);

            eventTrackLog = this.eventTrackLog.get();
            eventTrackLog.setTimeSpend(total);
            String endTime = DateUtils.getTime();
            logger.info("请求结束时间:" + endTime);
            eventTrackLog.setEndTime(new Date());

            // 获取当前的用户
            SysUser currentUser = ShiroUtils.getSysUser();

            if(currentUser != null)
            {
                eventTrackLog.setUserName(currentUser.getLoginName());
                eventTrackLog.setDeptName(currentUser.getDept().getDeptName());
            }

            // eventTrackLog.setSystemName("平台管理系统");
            eventTrackLog.setSystemName(RuoYiConfig.getName());

            // eventTrackLog.setModuleTitle("后台管理");

            eventTrackLog.setStatus(2l);
            eventTrackLog.setNumber(1L);

            eventTrackLog.setExceptMsg(ex.getMessage());

            eventTrackLog.setModuleTitle(eventTrack.title());
            eventTrackLog.setBusinessType(eventTrack.businessType().toString());

            if(ServletUtils.checkAgentIsMobile(ServletUtils.getRequest().getHeader("User-Agent")))
            {
                eventTrackLog.setChannel("Mobile");
            }
            else {
                eventTrackLog.setChannel("PC");
            }

            eventTrackLog.setCreateBy("except");
            eventTrackLog.setCreateTime(new Date());

        } catch (Exception e) {
            StackTraceElement stackTraceElement2 = e.getStackTrace()[2];
            String reason = "异常：【"+
                    "类名："+stackTraceElement2.getClassName()+";"+
                    "文件："+stackTraceElement2.getFileName()+";"+"行："+
                    stackTraceElement2.getLineNumber()+";"+"方法："
                    +stackTraceElement2.getMethodName() + "】";
            //记录本地异常日志
            logger.error("==============通知异常:记录访问异常信息==============");
            String message = e.getMessage() + "|" + reason;
            logger.error("异常信息：",message);
            eventTrackLog.setExceptMsg(message);
            eventTrackLog.setResult("请求发生异常！！！");
        } finally {
            // 添加日志信息入库
            eventTrackLogService.insertEventTrackLog(eventTrackLog);

            // 处理使用结束，清理变量
            this.eventTrackLog.remove();
        }

    }


    /**
     *
     * @param jp
     */

    @AfterReturning(pointcut = "@annotation(eventTrack)", returning = "jsonResult")
    public void afterMethod(JoinPoint jp, EventTrack eventTrack, Object jsonResult) {
        logger.info("==============方法执行完成==============");
        EventTrackLog eventTrackLog = this.eventTrackLog.get();
        try {
            //获取方法名
            String methodName = jp.getSignature().getName();

            Long end = System.currentTimeMillis();
            Long total =  end - startTime.get().get("startTime");
            logger.info("执行总耗时为：" +total);

            eventTrackLog = this.eventTrackLog.get();
            eventTrackLog.setTimeSpend(total);
            String endTime = DateUtils.getTime();
            logger.info("请求结束时间:" + endTime);
            eventTrackLog.setEndTime(new Date());

            // 获取当前的用户
            SysUser currentUser = ShiroUtils.getSysUser();

            if(currentUser != null)
            {
                eventTrackLog.setUserName(currentUser.getLoginName());
                eventTrackLog.setDeptName(currentUser.getDept().getDeptName());
            }

            // eventTrackLog.setSystemName("平台管理系统");
            eventTrackLog.setSystemName(RuoYiConfig.getName());
            // eventTrackLog.setModuleTitle("后台管理");

            eventTrackLog.setStatus(0l);
            eventTrackLog.setNumber(1L);

            eventTrackLog.setModuleTitle(eventTrack.title());
            eventTrackLog.setBusinessType(eventTrack.businessType().toString());

            if(ServletUtils.checkAgentIsMobile(ServletUtils.getRequest().getHeader("User-Agent")))
            {
                eventTrackLog.setChannel("Mobile");
            }
            else {
                eventTrackLog.setChannel("PC");
            }

            eventTrackLog.setCreateBy("return");
            eventTrackLog.setCreateTime(new Date());

        } catch (Exception e) {
            StackTraceElement stackTraceElement2 = e.getStackTrace()[2];
            String reason = "异常：【"+
                    "类名："+stackTraceElement2.getClassName()+";"+
                    "文件："+stackTraceElement2.getFileName()+";"+"行："+
                    stackTraceElement2.getLineNumber()+";"+"方法："
                    +stackTraceElement2.getMethodName() + "】";
            //记录本地异常日志
            logger.error("==============通知异常:记录访问异常信息==============");
            String message = e.getMessage() + "|" + reason;
            logger.error("异常信息：",message);
            eventTrackLog.setExceptMsg(message);
            eventTrackLog.setResult("请求发生异常！！！");

        } finally {
            // this.eventTrackLog.set(eventTrackLog);
            // 添加日志信息入库
            eventTrackLogService.insertEventTrackLog(eventTrackLog);

            // 处理使用结束，清理变量
            this.eventTrackLog.remove();
        }
    }

    /**
     * 获取注解中对方法的描述信息 用于Controller层注解
     */
    public static String getControllerMethodDescription(JoinPoint joinPoint) throws Exception {
        String targetName = joinPoint.getTarget().getClass().getName();
        String methodName = joinPoint.getSignature().getName();//目标方法名
        Object[] arguments = joinPoint.getArgs();
        Class targetClass = Class.forName(targetName);
        Method[] methods = targetClass.getMethods();
        String description = "";
        for (Method method:methods) {
            if (method.getName().equals(methodName)){
                Class[] clazzs = method.getParameterTypes();
                if (clazzs.length==arguments.length){
                    description = method.getAnnotation(EventTrack.class).description();
                    break;
                }
            }
        }
        return description;
    }

}

在切面类中，定义了前置通知和后置通知，前置通知记录方法调用的开始时间，后置通知包括正常返回和抛出异常两种情况，后置通知记录方法的结束时间，通过两个时间，就可以计算出方法的执行时间。另外一种方法是采用环切通知，执行前记录一次时间，执行后记录一次时间，因为在同一个方法内，不需要定义线程本地变量了。 

根据需要，两种方式选择一种就可以了。

2.4 添加切面注解

@RequiresPermissions("system:user:list")
@PostMapping("/list")
@EventTrack(title = "用户管理", businessType = BusinessType.QUERY, description="查询用户")
@ResponseBody
public TableDataInfo list(SysUser user)
{
    startPage();
    List<SysUser> list = userService.selectUserList(user);
    return getDataTable(list);
}

在方法上添加注释：

 @EventTrack(title = "用户管理", businessType = BusinessType.QUERY, description="查询用户")

相关参数根据场景进行设置。

2.5 日志信息

 通过日志信息，可以看出每个操作所花费的时间，单位是毫秒。通过日志时间，也可以看出是什么时间进行的操作，通过操作人员，可以知道是谁操作的。还可以关联其它的业务信息，比如用户类型，用户所属机构等。

程序猿20
关注
  • 12
    点赞
  • 踩
  • 49
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
springboot配置aop切面日志打印过程解析
08-25
主要介绍了springboot配置aop切面日志打印过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java项目增加统一切面日志输出，对于项目调试问题排查还是很有必要的
qq_40393739的博客
04-11 755
java项目增加统一切面日志输出，对于项目调试问题排查还是很有必要的。
Java利用Aop切面记录操作日志（注解方式）
最新发布
m0_73774439的博客
05-20 1316
⾯向切⾯编程，它是⼀种思想，它是对某⼀类事情的 集中处理。⽽ AOP 是⼀种思想，⽽ Spring AOP 是⼀个框架，提供了⼀种对 AOP 思想的实现，它们的关系和 IoC 与 DI 类似。@Mapping/*** 操作具体某个功能的描述* @return*//*** 操作类型* @return*/@Aspect@Component@Autowired@Autowired@Autowired@Autowired// 获取request对象。
spring AOP切面及日志记录实现
q495673918的博客
02-22 3210
1.什么是AOP切面 AOP（Aspect Oriented Programming），面向切面思想，是Spring的三大核心思想之一。 在项目中经常会有些系统性的需求，例如权限校验，日志记录，统计等，这时我们就可以通过AOP切面去实现。 有多少业务代码就需要写多少重复校验和日志记录，这显然是不合理的，我们可以把这些重复操作抽离出来，写成公共的方法。 这样，代码冗余解决了，但是每个地方都要手动去调用还是很麻烦，有没有更好的方式呢？这就要用到我们的AOP（面向切面编程），AOP将权限校验，
JAVA- AOP 面向切面编程 Aspect切面工具类 记录特定方法执行时的入参、执行时间、返参等内容
君琴 的博客
03-05 3591
面向切面编程 使用AOP对指定函数进行切面。能够记录特定方法执行时的入参、执行时间、返参结果等内容；例如：请求URL、请求IP、请求类名、请求方法名、请求参数等、返回值、请求耗时、浏览器类型、操作系统、header等。解决同类中调用切面无记录解决事务失效问题。
Java AOP开发模式@Aspect注解说明
【设计改变世界】github地址：https://github.com/guochunyang2004
05-26 7306
2 注解说明 2.1 @Aspect 作用是把当前类标识为一个切面供容器读取 2.2 @Before 标识一个前置增强方法，相当于BeforeAdvice的功能，相似功能的还有 2.3 @AfterReturning 后置增强，相当于AfterReturningAdvice，方法正常退出时执行 2.4 @AfterThrowing 异常抛出增强，相当于ThrowsAdvice 2.5 @After final增强，不管是抛出异常或者正常退出都会执行 2.6 @Around 环绕增强，相当
【java】Aspect切面示例
王佑辉的博客
06-11 2934
1.注解 package com.test.annotation; import java.lang.annotation.*; @Documented @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @interface UpdateStudentAnnotation { String value() default ""; } 2.切面 package com.test; import com.
使用AOP切面实现日志记录功能
心态的博客
10-26 3458
说到AOP大家都可以想到他是面向切面的编程，它通过将横切关注点（例如日志记录、事务管理、权限控制等）从主要业务逻辑中分离出来，以模块化的方式进行管理。在AOP中，通过定义切面（Aspect）来捕获和处理横切关注点，然后将其应用于特定的目标对象或方法。官方的解释有点抽象，我们举个例子说明：假设我们需要在多个方法中添加日志记录功能。传统的方式是在每个方法中都添加日志代码，但这样会导致代码重复，并且当我们需要修改日志记录逻辑时，需要逐个修改所有方法。
Aspect基础使用方法
LitterLy的博客
03-29 2258
所谓切面编程，就算将一个完整的流程切分成若干个，然后主流程只关心调用的方法，而不关心具体的实现逻辑，而子流程在完成业务逻辑后会把通知主流程方法继续向下执行或者通知失败；说白了就是方法的拦截操作，可以在方法执行前后进行一定的处理，然后根据需求判断是否是真正进入执行该方法或是直接跳过该方法抛出异常之类的，可以类比成OkHttp的拦截器 Aspect是一个实现切面编程的框架，本篇介绍一下Aspect的...
Java AOP实践指南：切面编程详解
xuewenyu_的博客
11-06 4070
通过本文的讲解，我们深入了解了切面编程的核心概念、动态代理的实现原理，并通过一个实际的例子展示了使用Java AOP的完整过程。AOP可以帮助我们将横切关注点（例如日志记录、事务管理等）从核心业务逻辑中解耦出来，提高代码的可维护性和重用性。同时，AOP也是实现设计模式和架构思想的重要手段之一，我们在开发中可以灵活运用AOP来优化代码结构并提高系统的整体性能。
Java实现AOP面向切面编程的实例教程共4页.pdf.z
10-30
在Java中，AOP通常通过Spring框架来实现，Spring提供了强大的AOP支持，允许开发者定义“切面”，这些切面可以封装横切关注点，如日志、事务管理、性能监控等。现在，我们将深入探讨Java中AOP的实现及其应用场景。 ...
日志记录（使用切面方式记录）
12-22
spring日志记录（使用切面方式记录） 1. 创建pojo类 @Data @Table(name = "tb_operate_record") public class OperateRecord { @Id private String id; //记录请求时间 @Column(name = "record_time") private Date recordTime; //操作者 private String username; //请求IP @Column(name = "request_ip") priv
springboot-aop-aspect:Springboot使用Aspect实现一个切面，以记录日志为例
05-15
在Spring Boot应用中，AOP（面向切面编程）是一种强大的设计模式，它允许程序员定义“切面”，这些切面可以包含业务逻辑的各个方面，如日志、事务管理、性能监控等。本项目以记录日志为例，展示了如何在Spring Boot...
Java 和 Kotlin的注解以及切面实现方式
08-21
- **Spring AOP**：通过定义切面（Aspect），声明通知（Advice），以及指定切入点（Pointcut）来实现AOP。例如： ```java @Aspect public class LoggingAspect { @Before("execution(* com.example.service.*.*...
利用spring AOP记录用户操作日志的方法示例
08-30
3. 使用切面类： Spring AOP 中的切面类是实现日志记录的核心。在本文中，我们使用了 `MyInterceptor` 切面类来实现日志记录的功能。 4. 使用 Pointcut 表达式： 在 Spring AOP 中，Pointcut 表达式用于指定需要记录...
应用市场中Java拦截器和切面的使用实例详解
08-28
Java拦截器和面向切面编程（AOP）是两种在应用程序中实现横切关注点的常见方式，尤其在处理如日志记录、权限验证、事务管理等通用任务时。在应用市场环境中，这两种技术同样发挥着重要作用。接下来，我们将深入探讨...
Java切面的实现方式
weixin_49151141的博客
04-04 4987
是指在软件开发中，将某些横跨多个组件的功能，如日志记录、性能监控、权限控制等，抽象出来形成一个独立的模块，称之为切面。切面可以被应用到多个模块中，提供相同的功能。基于继承的切面实现 这种实现方式需要通过继承的方式实现，具体操作为：首先定义一个抽象类，实现该类时可以重写一些方法，从而达到切面的目的。以上是三种实现切面的方式，分别基于继承、代理和注解。其中，基于注解的方式是。的实现方式，而基于继承和代理的方式可以使用。中实现切面的技术有多种，下面分别介绍。
Java @Aspect 切面
kuroshiro的博客
09-04 3737
java 切面
Aop面向切面实现开发日志收集打印一文轻松搞定,内附详细图文示例+源码自取
暗武逢天的博客
11-24 1313
AOP（Aspect-Oriented Programming，面向切面编程）是一种编程范式，可以在不改变原有代码的情况下，通过在程序的各个关键点上增加切面（Aspect）的方式，实现对代码的增强和横切关注点的分离，从而提高代码的可重用性、可维护性和可扩展性。
通java写一个切面 主要用于存日志
03-07
可以使用 AspectJ 框架来实现切面，具体步骤如下： 1. 引入 AspectJ 的依赖包，例如 aspectjrt.jar 和 aspectjweaver.jar。 2. 编写切面类，实现切面逻辑。例如，可以在方法执行前后记录日志。 3. 使用 AspectJ 注解来标识切面类和切点。例如，可以使用 @Aspect 和 @Pointcut 注解。 4. 在需要应用切面的类或方法上添加 AspectJ 注解。例如，可以使用 @Before 和 @After 注解。 下面是一个简单的示例代码： ``` import org.aspectj.lang.annotation.*; import org.springframework.stereotype.Component; @Aspect @Component public class LogAspect { @Pointcut("execution(* com.example.service.*.*(..))") public void servicePointcut() {} @Before("servicePointcut()") public void beforeService() { System.out.println("调用服务方法前记录日志"); } @After("servicePointcut()") public void afterService() { System.out.println("调用服务方法后记录日志"); } } ``` 在上面的代码中，我们定义了一个切面类 LogAspect，使用 @Aspect 和 @Component 注解标识该类为切面，并定义了一个切点 servicePointcut，表示匹配 com.example.service 包下的所有方法。在 beforeService 和 afterService 方法中，我们分别在方法执行前后记录日志。最后，在需要应用切面的类或方法上添加 AspectJ 注解即可。 注意：以上代码仅为示例，实际应用中需要根据具体需求进行修改。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值