日志实现

package com.xxx.common.aop;
 
import java.lang.annotation.*;
// TYPE表示可以放在类上面，METHOD表示可以放在方法上面 @Target({ElementType.TYPE, ElementType.METHOD})  
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface LogAnnotation {
    String module() default "";
 
    String operator() default "";
}
 

package com.xxx.common.aop;
 
import com.gexin.fastjson.JSON;
import com.xxx.model.utils.HttpContextUtils;
import com.xxx.model.utils.IpUtils;
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.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
 
import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
 
@Aspect // 切面 定义了通知和切点的关系
@Component
@Slf4j
public class LogAspect {
 
    // 表示切点加在哪里
    @Pointcut("@annotation(com.xxx.common.aop.LogAnnotation)")
    public void pt() {
    }
 
    @Around("pt()")
    public Object log(ProceedingJoinPoint joinPoint) throws Throwable {
 
        long beginTime = System.currentTimeMillis();
 
        Object returnValue = joinPoint.proceed();
 
        long time = System.currentTimeMillis() - beginTime;
 
        // 保存日志
        recordLog(joinPoint, time);
 
        return returnValue;
    }
 
    private void recordLog(ProceedingJoinPoint joinPoint, long time) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        LogAnnotation logAnnotation = method.getAnnotation(LogAnnotation.class);
        log.info("========log start=========");
        log.info("module:{}", logAnnotation.module());
        log.info("operation:{}", logAnnotation.operator());
 
        // 请求的方法名
        String className = joinPoint.getTarget().getClass().getName();
        String methodName = signature.getName();
        log.info("request method:{}", className + "." + methodName + "()");
 
        // 请求的参数
        Object[] args = joinPoint.getArgs();
        String params = JSON.toJSONString(args[0]);
        log.info("params:{}", params);
 
        // 获取request 设置ip地址
        HttpServletRequest request = HttpContextUtils.getHttpServletRequest();
        log.info("ip:{}", IpUtils.getIpAddr(request));
 
        log.info("execute time : {} ms", time);
        log.info("==========log end==========");
    }
}
 

// 在接口方法上增加此注解
@LogAnnotation(module = "模块名称", operator="操作参数")

package com.xxx.model.utils;
 
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
 
import javax.servlet.http.HttpServletRequest;
 
public class HttpContextUtils {
 
    public static HttpServletRequest getHttpServletRequest() {
        return Objects.requireNonNull(((ServletRequestAttributes) RequestContextHolder.getRequestAttributes())).getRequest();
    }
}
 

package com.xxx.model.utils;
 
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import javax.servlet.http.HttpServletRequest;
 
@Slf4j
public class IpUtils {
    private static final Logger logger = LoggerFactory.getLogger(IpUtils.class);
 
    /**
     * 获取IP地址
     * 使用Nginx等反向代理软件， 则不能通过request.getRemoteAddr()获取IP地址
     * 如果使用了多级反向代理的话，X-Forwarded-For的值并不止一个，而是一串IP地址，X-Forwarded-For中第一个非unknown的有效IP字符串，则为真实IP地址
     */
    public static String getIpAddr(HttpServletRequest request) {
        String ip = null;
        try {
            ip = request.getHeader("x-forwarded-for");
            if (StringUtils.isEmpty(ip) || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getHeader("Proxy-Client-IP");
            }
            if (StringUtils.isEmpty(ip) || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getHeader("WL-Proxy-Client-IP");
            }
            if (StringUtils.isEmpty(ip) || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getHeader("HTTP_CLIENT_IP");
            }
            if (StringUtils.isEmpty(ip) || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getHeader("HTTP_X_FORWARDED_FOR");
            }
            if (StringUtils.isEmpty(ip) || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getRemoteAddr();
            }
        } catch (Exception e) {
            logger.error("IPUtils ERROR ", e);
        }
        // 使用代理，则获取第一个IP地址
        if (StringUtils.isNotEmpty(ip) && ip.length() > 15) {
            if (ip.indexOf(",") > 0) {
                ip = ip.substring(0, ip.indexOf(","));
            }
        }
        return ip;
    }
}