spring3 使用loki日志 spring操作日志

转载

数据探索先锋 2024-03-18 07:51:54

文章标签 spring3 使用loki日志 java spring aop IP 文章分类 架构后端开发

一、添加Maven依赖

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

二、创建操作日志注解类OperLog.java

package com.hyd.zcar.cms.common.utils.annotation;

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.METHOD) //注解放置的目标位置,METHOD是可注解在方法级别上
@Retention(RetentionPolicy.RUNTIME) //注解在哪个阶段执行
@Documented
public @interface OperLog {

    String operModul() default ""; // 操作模块

    String operType() default "";  // 操作类型

    String operDesc() default "";  // 操作说明

}

三、创建切面类记录操作日志

import com.qinglian.cloud.pass.api.annotation.OperLog;
import com.qinglian.cloud.pass.api.utils.CommUtils;
import com.qinglian.cloud.pass.api.utils.JsonUtil;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;


/**
 * 切面处理类，操作日志异常日志记录处理
 */
@Aspect
@Component
public class OperLogAspect {

    /**
     * 设置操作日志切入点 记录操作日志 在注解的位置切入代码
     */
    @Pointcut("@annotation(com.qinglian.cloud.pass.api.annotation.OperLog)")
    public void operLogPoinCut() {

    }

    /**
     * 设置操作异常切入点记录异常日志 扫描所有controller包下操作
     */
    @Pointcut("execution(* com.qinglian.cloud.pass.api.controller..*.*(..))")
    public void operExceptionLogPoinCut() {

    }

    /**
     * 正常返回通知，拦截用户操作日志，连接点正常执行完成后执行， 如果连接点抛出异常，则不会执行
     * @param joinPoint 切入点
     * @param keys      返回结果
     */
    @AfterReturning(value = "operLogPoinCut()", returning = "keys")
    public void saveOperLog(JoinPoint joinPoint, Object keys) {
        // 获取RequestAttributes
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
        // 从获取RequestAttributes中获取HttpServletRequest的信息
        HttpServletRequest request = (HttpServletRequest) requestAttributes
                .resolveReference(RequestAttributes.REFERENCE_REQUEST);
        try {

            //  从切面织入点处通过反射机制获取植入点处的方法
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            //  获取切入点所在的方法
            Method method = signature.getMethod();
            //  获取操作
            OperLog opLog = method.getAnnotation(OperLog.class);
            //  获取对应的方法说明参数
            if (opLog != null) {
                //获取 具体模块说明
                String operModul = opLog.operModul();
                //获取 具体类型说明
                String operType = opLog.operType();
                //获取 具体的方法说明
                String operDesc = opLog.operDesc();

                System.out.println("操作模块:" + operModul + "----操作类型:" + operType + "----" + operDesc);
            }

            //  获取请求的类名
            String className = joinPoint.getTarget().getClass().getName();
            //  获取请求的方法名
            String methodName = method.getName();
            //  拼接类名和方法名
            methodName = className + "." + methodName;

            //  请求的参数
            Map<String, String> rtnMap = converMap(request.getParameterMap());
            //  将参数所在的数组转换成json字符串
            String params = JsonUtil.beanToString(rtnMap);
            System.out.println("请求IP:" + CommUtils.getIpAddress(request) + ",----请求方法:" + methodName + ",----请求参数:" + params + ",----返回结果：" + keys.toString() + ",----请求URI：" + request.getRequestURI());

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 异常返回通知，用于拦截异常日志信息 连接点抛出异常后执行
     * @param joinPoint 切入点
     * @param e         异常信息
     */
    @AfterThrowing(pointcut = "operExceptionLogPoinCut()", throwing = "e")
    public void saveExceptionLog(JoinPoint joinPoint, Throwable e) {
        // 获取RequestAttributes
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
        // 从获取RequestAttributes中获取HttpServletRequest的信息
        HttpServletRequest request = (HttpServletRequest) requestAttributes
                .resolveReference(RequestAttributes.REFERENCE_REQUEST);
        try {
            //  从切面织入点处通过反射机制获取织入点处的方法
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            //  获取切入点所在的方法
            Method method = signature.getMethod();

            //  获取请求的类名
            String className = joinPoint.getTarget().getClass().getName();
            //  获取请求的方法名
            String methodName = method.getName();
            //  拼接类名和方法名
            methodName = className + "." + methodName;
            //  请求的参数
            Map<String, String> rtnMap = converMap(request.getParameterMap());
            //  将参数所在的数组转换成json字符串
            String params = JsonUtil.beanToString(rtnMap);

            System.out.println("请求的IP:" + CommUtils.getIpAddress(request) + "----请求方法:" + methodName + "----请求参数:" + params + "----异常名称：" + e.getClass().getName() + "----请求URI：" + request.getRequestURI());
            System.out.println("异常信息----------\n" + stackTraceToString(e.getClass().getName(), e.getMessage(), e.getStackTrace()));

        } catch (Exception e2) {
            e2.printStackTrace();
        }
    }

    /**
     * 转换request 请求参数
     * @param paramMap request获取的参数数组
     */
    public Map<String, String> converMap(Map<String, String[]> paramMap) {
        Map<String, String> rtnMap = new HashMap<String, String>();
        for (String key : paramMap.keySet()) {
            rtnMap.put(key, paramMap.get(key)[0]);
        }
        return rtnMap;
    }

    /**
     * 转换异常信息为字符串
     * @param exceptionName    异常名称
     * @param exceptionMessage 异常信息
     * @param elements         堆栈信息
     */
    public String stackTraceToString(String exceptionName, String exceptionMessage, StackTraceElement[] elements) {
        StringBuffer strbuff = new StringBuffer();
        for (StackTraceElement stet : elements) {
            strbuff.append(stet + "\n");
        }
        String message = exceptionName + ":" + exceptionMessage + "\n\t" + strbuff.toString();
        return message;
    }
}

import javax.servlet.http.HttpServletRequest;

/**
 * 通用的一些工具类
 * 1：获取Ip地址
 */
public class CommUtils {
    /**
     * 获取用户真实IP地址，不使用request.getRemoteAddr();的原因是有可能用户使用了代理软件方式避免真实IP地址,
     * 如果通过了多级反向代理的话，X-Forwarded-For的值并不止一个，而是一串IP值，取X-Forwarded-For中第一个非unknown的有效IP字符串
     * @param request
     * @return
     */
    public static String getIpAddress(HttpServletRequest request) {
         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("WL-Proxy-Client-IP");
         }
         if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
             ip = request.getHeader("HTTP_CLIENT_IP");
         }
         if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
             ip = request.getHeader("HTTP_X_FORWARDED_FOR");
         }
         if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
             ip = request.getRemoteAddr();
         }
         return ip;
     }
}

四、在Controller层方法添加@OperLog注解

spring3 使用loki日志 spring操作日志_aop