cn.watsontech.webhelper.common.aop.AccessLogAspect Maven / Gradle / Ivy

Go to download
package cn.watsontech.webhelper.common.aop;

import cn.watsontech.webhelper.common.aop.annotation.Access;
import cn.watsontech.webhelper.common.aop.annotation.AccessParam;
import cn.watsontech.webhelper.common.aop.entity.AccessLog;
import cn.watsontech.webhelper.common.security.LoginUser;
import cn.watsontech.webhelper.common.security.authentication.AccountService;
import cn.watsontech.webhelper.common.util.RequestUtils;
import cn.watsontech.webhelper.utils.StringUtils;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.EmbeddedValueResolverAware;
import org.springframework.core.NamedThreadLocal;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.lang.Nullable;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringValueResolver;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * 系统日志切点类
 *
 * Created by Watson on 2020/02/09.
 */
@Aspect
@Component
public class AccessLogAspect implements EmbeddedValueResolverAware {
    protected static final Log log = LogFactory.getLog(AccessLogAspect.class);

    /**
     * 本地线程日志
     */
    private static final ThreadLocal logThreadLocal = new NamedThreadLocal("AccessLogAspectThreadLocal");

    /**
     * 线程池任务执行程序
     */
    @Autowired
    private ThreadPoolTaskExecutor threadPoolTaskExecutor;

    /**
     * 日志储存service
     */
    @Autowired
    private LogService logService;

    @Nullable
    private StringValueResolver embeddedValueResolver;

    /**
     * Controller层切点 注解拦截
     */
    @Pointcut("@annotation(cn.watsontech.webhelper.common.aop.annotation.Access)")
    public void accessLogPointCut() {
        log.info("+++++++++++++Controller层切点 注解拦截+++++++++++++");
    }

    /**
     * 环绕通知 用于拦截Controller层记录用户的操作的开始时间
     *
     * @param joinPoint 切点
     */
    @Around("accessLogPointCut()")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        Object result = null;
        logThreadLocal.set(System.currentTimeMillis());
        result = joinPoint.proceed();

        LoginUser user = getCurrentLoginUser();
        if (user==null) {
            org.aspectj.lang.Signature signature = joinPoint.getSignature();
            //检查是否是登陆接口
            if (signature.getDeclaringType()==AccountService.class) {
                if (signature.getName().startsWith("loginBy")) {
                    if (result instanceof LoginUser) {
                        user = (LoginUser) result;
                    }
                }
            }
        }

        saveLog(joinPoint, null, user);
        return result;
    }

    private void saveLog(JoinPoint joinPoint, Throwable exception, LoginUser user) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        Access access = AnnotationUtils.findAnnotation(method, Access.class);
        AccessLog testLog = wrapAccessLog(method, joinPoint.getArgs(), access, exception, user);

        // 1.直接执行保存操作
        // this.logService.createSystemLog(log);

        // 2.优化:异步保存日志
        // new SaveLogThread(log, logService).start();

        // 3.再优化:通过线程池来执行日志保存
        threadPoolTaskExecutor.execute(new SaveLogThread(testLog, isAccessShouldSave(access)));
    }

    // 读取session中的用户
    private LoginUser getCurrentLoginUser() {
        LoginUser user = null;
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        if (authentication!=null) {
            Object principal = authentication.getPrincipal();
            if (principal!=null) {
                if (principal instanceof LoginUser) {
                    user = (LoginUser) principal;
                }
            }
        }

        return user;
    }

    private AccessLog wrapAccessLog(Method signatureMethod, Object[] methodArgs, Access accessAnnotation, Throwable exception, LoginUser user) {
        HttpServletRequest request = RequestUtils.getHttpServletRequest();
        String remoteAddr = RequestUtils.getIpAddress(request);// 请求的IP
        String requestBrowser = RequestUtils.getBrowser(request);// 请求的浏览器类型
        String requestUri = request.getRequestURI();// 请求的Uri
        String method = request.getMethod(); // 请求的方法类型(post/get)

        AccessParamValue accessParamValue = null;
        String levelType = accessAnnotation.level();
        String tag = accessAnnotation.tag();
        String exMessage = null;
        if (exception!=null) {
            levelType = "error";
            exMessage = exception.getMessage();
            if (exMessage==null) {
                exMessage = exception.toString();
            }
        }

        if (levelType!=null&&embeddedValueResolver!=null) {
            levelType = embeddedValueResolver.resolveStringValue(levelType);
        }

        try {
            accessParamValue = getControllerMethodDescription(signatureMethod, methodArgs, accessAnnotation);
        } catch (Exception e) {
            e.printStackTrace();
            accessParamValue = new AccessParamValue("未知",null, null);
        }

        AccessLog testLog = new AccessLog();
        testLog.setLevel(levelType);
        testLog.setTag(tag);
        testLog.setIp(remoteAddr);
        testLog.setUrl(requestUri);
        testLog.setBrowser(requestBrowser);
        testLog.setMethod(method);
        testLog.setException(exMessage);
        if (accessParamValue!=null) {
            testLog.setTitle(accessParamValue.getDescription());
            testLog.setGroupId(accessParamValue.getGroupId());
            testLog.setGroupField(accessParamValue.getGroupField());
        }
        testLog.setVersion(1);
        testLog.setParams(getParameters(signatureMethod, methodArgs));
        if (user!=null) {
            testLog.setCreatedBy(user.getId());
            testLog.setCreatedByName(user.getFullName());
        }
        testLog.setCreatedTime(new Date());
        if (logThreadLocal.get()!=null) {
            testLog.setTotalTimes(System.currentTimeMillis()-logThreadLocal.get());
        }
        return testLog;
    }

    /**
     * 根据方法和传入的参数获取请求参数
     */
    private String getParameters(Method method, Object[] args) {
        List