SpringAop记录操作日志 @AfterRunning: 返回通知, 在方法返回结果之后执行

所需jar包

 <!-- aspectj -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.1</version>
        </dependency>
 <!-- servlet接口 -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
            <scope>provided</scope>
        </dependency>
 <!-- JSON工具类 -->
       <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.9.8</version>
        </dependency>
     
       
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.8</version>
        </dependency>

      <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.9.7</version>
        </dependency>

1.创建日志注解类

import com.datalook.util.logAspectUtil.AspectBusinessType;
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;

/***
 * @title  记录日志注解类
 * @data 2019/12/16
 */
@Target({ElementType.PARAMETER, ElementType.METHOD})//用于标识方法
@Retention(RetentionPolicy.RUNTIME)//表示运行时保留
@Documented
public @interface OperationLog {
    /**
     * @param
     * @return
     * @title 自定义注解 操作模块
     * @date 2019/12/16
     */
    String title() default "";
    
    /**
     * 操作功能
     */
    public AspectBusinessType businessType() default AspectBusinessType.OTHER;

    /**
     * 是否保存请求的参数
     */
    public boolean isSaveRequestData() default true;
}

2.创建实体类，实现操作日志记录处理    @AfterRunning: 返回通知, 在方法返回结果之后执行

import java.lang.reflect.Method;
import java.util.Date;
import java.util.Map;
import com.datalook.action.base.BaseAction;
import com.datalook.annotation.OperationLog;
import com.datalook.model.log.LogSysOper;
import com.datalook.service.LogSysOperService;
import com.datalook.util.logAspectUtil.Json;
import com.datalook.util.logAspectUtil.RequestIp;
import com.datalook.util.vo.SysUserVO;
import org.apache.commons.lang.StringEscapeUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.struts2.ServletActionContext;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
/***
 * @title  操作日志记录处理
 * @data 2019/12/13
 */
@Component
@Aspect
public class LogAspect {
    private static Logger logger = LoggerFactory.getLogger(LogAspect.class);
    public Map<String, Object> session;//session对象
    @Resource
    private LogSysOperService logSysOperService;
    
    // 配置织入点  注解拦截
    @Pointcut("@annotation(com.datalook.annotation.OperationLog)")
    public void logPointCut() {
    }
    /**
     * 处理完请求后执行
     * @param joinPoint 切点
     */
    @AfterReturning(pointcut = "logPointCut()", returning = "jsonResult")
    public void AfterReturning(JoinPoint joinPoint, Object jsonResult) {
        handleLog(joinPoint, null, jsonResult);
    }
   
    /**
     * 拦截异常操作
     * @param joinPoint 切点
     * @param e 异常
     */
    @AfterThrowing(value = "logPointCut()", throwing = "e")
    public void doAfterThrowing(JoinPoint joinPoint, Exception e)
    {
        handleLog(joinPoint, e, null);
    }

    public  void  handleLog(final JoinPoint joinPoint, final Exception e, Object jsonResult ){
        try {
          //获得注解
            OperationLog controllerLog=getAnnotationLog(joinPoint);
            logger.info("操作日志记录,获取注解:"+controllerLog);
            if (controllerLog == null) {
                return;
            }
            //数据库日志
            LogSysOper operLog = new LogSysOper();
            //操作状态（0正常 1异常）
            operLog.setStatus(1);
            HttpServletRequest request = ServletActionContext.getRequest();
            HttpSession session = request.getSession();
            //IP地址
            String operIp = RequestIp.getRemoteHost(request);
            operLog.setOperIp(operIp);
            //请求地址
            operLog.setOperUrl(request.getRequestURI());
            // 返回参数
            String rsp="";
            BaseAction baseAction= new BaseAction();
            String rspJson =baseAction.getrRpJson(rsp);
            rspJson =  StringEscapeUtils.unescapeJavaScript(rspJson).replaceAll(",",",\r\n");
            operLog.setJsonResult(rspJson);
            //操作人
            SysUserVO sysUser = (SysUserVO) session.getAttribute("sysUser");
            if (sysUser != null){
                operLog.setUserCode(sysUser.getUsercode());
            }
            //操作状态
            if (e != null) {
                operLog.setStatus(-1);
            }
            // 设置方法名称

            String className = joinPoint.getTarget().getClass().getName();//类名
            String methodName = joinPoint.getSignature().getName();//方法名
            operLog.setMethod(className + "." + methodName + "()");
            logger.info("操作日志记录，获取方法名称:"+operLog.getMethod());
            // 设置请求方式
            operLog.setRequestMethod(request.getMethod());
            getControllerMethodDescription(controllerLog, operLog);
            operLog.setOperTime(new Date());
            logger.info("操作日志记录:"+operLog.toString());
            logSysOperService.saveLog(operLog);
        } catch (Exception e1) {
            // 记录本地异常日志
            logger.error("异常信息:{}", e1.getMessage());
            e1.printStackTrace();

        }

    }   /**
     * 获取注解中对方法的描述信息 用于Controller层注解
     *
     * @param log 日志
     * @param operLog 操作日志
     * @throws Exception
     */
    public void getControllerMethodDescription(OperationLog log, LogSysOper operLog) throws Exception {
        // 业务类型
        operLog.setBusinessType(log.businessType().ordinal());
        // 设置标题
        operLog.setTitle(log.title());
        // 是否需要保存request，参数和值
        if (log.isSaveRequestData()) {
            // 获取参数的信息，传入到数据库中。
            setRequestValue(operLog);
        }
    }

    /**
     * 获取请求的参数，放到log中
     *
     * @param operLog 操作日志
     * @throws Exception 异常
     */
    public void setRequestValue(LogSysOper operLog) throws Exception {
        Map<String, String[]> map = ServletActionContext.getRequest().getParameterMap();
        String params = Json.marshal(map);
        operLog.setOperParam(StringUtils.substring(params, 0, 2000));
    }
    /**
     * 是否存在注解，如果存在就获取
     */
    public OperationLog getAnnotationLog(JoinPoint joinPoint) throws Exception{
        Signature signature= joinPoint.getSignature();
        MethodSignature methodSignature= (MethodSignature) signature;
        Method method= methodSignature.getMethod();
        if (method != null){
            return method.getAnnotation(OperationLog.class);
        }
         return null;
    }

3.工具类

import java.io.IOException;
import com.fasterxml.jackson.core.JsonGenerationException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.ObjectWriter;
/***
 * @title
 * @data 2019/12/16
 */
public class Json {
    /**
     * 通用消息对象，基于Map实现的可嵌套数据结构。 支持JSON数据结构。
     *
     * @author ruoyi
     */
    private static final ObjectMapper objectMapper = new ObjectMapper();
    private static final ObjectWriter objectWriter = objectMapper.writerWithDefaultPrettyPrinter();

    public static String marshal(Object value) throws Exception {
        try {
            return objectWriter.writeValueAsString(value);
        } catch (JsonGenerationException e) {
            throw new Exception(e);
        } catch (JsonMappingException e) {
            throw new Exception(e);
        } catch (IOException e) {
            throw new Exception(e);
        }
    }

import javax.servlet.http.HttpServletRequest;
/***
 * @title 获取目标主机的ip
 * @data 2019/12/16
 */
public class RequestIp {
    public static String getRemoteHost(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.getRemoteAddr();
        }
        return "0:0:0:0:0:0:0:1".equals(ip) ? "127.0.0.1" : ip;
    }
}

4.在业务方法上配置以下注解

5.struts.xml配置防止注入失败

<!--作用是确保Spring的自动装配策略总是被考虑的,使自动注入总是有效-->
	<constant name="struts.objectFactory.spring.autoWire.alwaysRespect" value="true" />

6.spring （appli

	<context:annotation-config />

	<!-- 开启对 @Aspect 的支持-->
	<aop:aspectj-autoproxy />

	<!-- 扫描包下所有的类，让标注Spring 注解的类生效 -->
	<context:component-scan base-package="com.*" />
	<aop:aspectj-autoproxy proxy-target-class="true"/>

cationContext.xml）配置