springAOP实现操作日志记录，并记录请求参数与编辑前后字段的具体改变

本文为博主原创，未经允许不得转载：

　　在项目开发已经完成多半的情况下,需要开发进行操作日志功能的开发,由于操作的重要性,需要记录下操作前的参数和请求时的参数,

在网上找了很多,没找到可行的方法.由于操作日志用注解方式的AOP记录操作日志比较便捷,所以想到了在注解中定义操作前查询数据

详情的bean,查询方法及参数,参数类型,在aop进行方法执行前,对指定的bean,方法,参数进行调用,获得修改前的参数,并进行保存.

此处需要注意:

1.在前面中调用指定bean的方法时,不可用反射进行调用,反射不能加载spring容器,无法获取指定的spring bean,下面方法中封装的获取spring bean的

　　工具类也需要配置为bean,而且被spring加载,才可以;

2.@Aspect注解的类一定要配置成bean，而且被spring加载，才可以，即同时配置@Component和@Aspect,或在spring的配置文件进行bean的配置

3.如果配置了bean，要检索component-scan扫描范围是否包括Aspect类；

一.定义切面执行的注解(该注解可根据自己实现的内容进行自定义)

 1 import java.lang.annotation.Documented;
 2 import java.lang.annotation.Retention;
 3 import java.lang.annotation.Target;
 4
 5 import java.lang.annotation.ElementType;
 6 import java.lang.annotation.RetentionPolicy;
 7
 8 @Target({ElementType.PARAMETER, ElementType.METHOD})
 9 @Retention(RetentionPolicy.RUNTIME)
10 @Documented
11 public @interface SystemControllerLog {
12
13          /**查询模块*/
14          String module()  default "";
15
16          /**查询模块名称*/
17         String methods()  default "";
18
19         /**查询的bean名称*/
20         String serviceClass() default "";
21
22         /**查询单个详情的bean的方法*/
23         String queryMethod() default "";
24
25         /**查询详情的参数类型*/
26         String parameterType() default "";
27
28         /**从页面参数中解析出要查询的id，
29          * 如域名修改中要从参数中获取customerDomainId的值进行查询
30          */
31         String parameterKey() default "";
32
33         /**是否为批量类型操作*/
34         boolean paramIsArray() default false;
35
36     }

二.切面执行的方法

  import java.lang.reflect.Method;
  import java.text.SimpleDateFormat;
  import java.util.Date;

  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpSession;

  import org.apache.commons.lang3.StringUtils;
  import org.aspectj.lang.ProceedingJoinPoint;
  import org.aspectj.lang.Signature;
  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.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.stereotype.Component;
  import org.springframework.util.ReflectionUtils;
  import org.springframework.web.context.request.RequestContextHolder;
  import org.springframework.web.context.request.ServletRequestAttributes;

  import com.alibaba.fastjson.JSON;
  import com.alibaba.fastjson.JSONArray;
  import com.alibaba.fastjson.JSONObject;
  import com.suning.fucdn.common.RequestResult;
  import com.suning.fucdn.common.enums.FucdnStrConstant;
  import com.suning.fucdn.entity.log.SystemControllerLogInfo;
  import com.suning.fucdn.impl.service.log.LogServiceImpl;
  import com.suning.fucdn.vo.AdminUserVO;

  /**
   *
   * 〈一句话功能简述:操作日志切面记录操作〉<br>
   * 〈功能详细描述〉
   *
   * @author xiang
   * @see [相关类/方法]（可选）
   * @since [产品/模块版本] （可选）
   */
  @Component
  @Aspect
  public class ControllerLogAopAspect {

      private static final Logger LOGGER = LoggerFactory.getLogger(ControllerLogAopAspect.class);

      //注入service,用来将日志信息保存在数据库
      @Autowired
      private LogServiceImpl logservice;

       //配置接入点,如果不知道怎么配置,可以百度一下规则
　　　　　　//指定controller的类进行切面　　@Pointcut("execution(* com.controller..CustomerController.*(..))||execution(* com.controller.ManageController.*(..))")  
       @Pointcut("execution(* com.controller..*.*(..))")
       private void controllerAspect(){
           System.out.println("point cut start");
       }//定义一个切入点

       @SuppressWarnings({ "rawtypes", "unused" })
       @Around("controllerAspect()")
       public Object around(ProceedingJoinPoint pjp) throws Throwable {
           //常见日志实体对象
           SystemControllerLogInfo log = new SystemControllerLogInfo();
           //获取登录用户账户
           HttpServletRequest httpRequest = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();

           //方法通知前获取时间,为什么要记录这个时间呢？当然是用来计算模块执行时间的
           //获取系统时间
           String time = new SimpleDateFormat(FucdnStrConstant.YEAR_MONTH_DAY_HOUR_MINUTE_SECOND.getConstant()).format(new Date());
           log.setStartTime(time);

           //获取系统ip,这里用的是我自己的工具类,可自行网上查询获取ip方法
           //String ip = GetLocalIp.localIp();
           //log.setIP(ip);

          // 拦截的实体类，就是当前正在执行的controller
          Object target = pjp.getTarget();
          // 拦截的方法名称。当前正在执行的方法
          String methodName = pjp.getSignature().getName();
          // 拦截的方法参数
          Object[] args = pjp.getArgs();
          //String params = Arrays.toString(pjp.getArgs());
          JSONArray operateParamArray = new JSONArray();
          for (int i = 0; i < args.length; i++) {
              Object paramsObj = args[i];
              //通过该方法可查询对应的object属于什么类型：String type = paramsObj.getClass().getName();
          if(paramsObj instanceof String || paramsObj instanceof JSONObject){
              String str = (String) paramsObj;
              //将其转为jsonobject
              JSONObject dataJson = JSONObject.parseObject(str);
              if(dataJson == null || dataJson.isEmpty() || "null".equals(dataJson)){
                  break;
              }else{
                  operateParamArray.add(dataJson);
              }
          }else if(paramsObj instanceof Map){
              //get请求，以map类型传参
              //1.将object的map类型转为jsonobject类型
              Map<String, Object> map = (Map<String, Object>) paramsObj;
              JSONObject json =new JSONObject(map);
              operateParamArray.add(json);
          }
          }
          //设置请求参数
          log.setOperateParams(operateParamArray.toJSONString());
          // 拦截的放参数类型
          Signature sig = pjp.getSignature();
          MethodSignature msig = null;
          if (!(sig instanceof MethodSignature)) {
              throw new IllegalArgumentException("该注解只能用于方法");
          }
          msig = (MethodSignature) sig;

          Class[] parameterTypes = msig.getMethod().getParameterTypes();
          Object object = null;
          // 获得被拦截的方法
          Method method = null;
          try {
              method = target.getClass().getMethod(methodName, parameterTypes);
          } catch (NoSuchMethodException e1) {
              LOGGER.error("ControllerLogAopAspect around error",e1);
          } catch (SecurityException e1) {
              LOGGER.error("ControllerLogAopAspect around error",e1);
          }
          if (null != method) {
              // 判断是否包含自定义的注解，说明一下这里的SystemLog就是我自己自定义的注解
              if (method.isAnnotationPresent(SystemControllerLog.class)) {

                  //此处需要对用户进行区分：1为admin user 2为customer user
                  // get session
                  HttpSession httpSession = httpRequest.getSession(true);
                  // 从session获取登录用户
                  AdminUserVO adminUserVO = (AdminUserVO) httpSession
                          .getAttribute(FucdnStrConstant.SESSION_KEY_ADMIN.getConstant());
                  long adminUserId = adminUserVO.getAdminUserId();
                  log.setUserId(String.valueOf(adminUserId));

                  SystemControllerLog systemlog = method.getAnnotation(SystemControllerLog.class);

                  log.setModule(systemlog.module());
                  log.setMethod(systemlog.methods());
                  //请求查询操作前数据的spring bean
                  String serviceClass = systemlog.serviceClass();
                  //请求查询数据的方法
                  String queryMethod = systemlog.queryMethod();
                  //判断是否需要进行操作前的对象参数查询
                  if(StringUtils.isNotBlank(systemlog.parameterKey())
                      &&StringUtils.isNotBlank(systemlog.parameterType())
                      &&StringUtils.isNotBlank(systemlog.queryMethod())
                      &&StringUtils.isNotBlank(systemlog.serviceClass())){
                      boolean isArrayResult = systemlog.paramIsArray();
                       //参数类型
                      String paramType = systemlog.parameterType();
                      String key = systemlog.parameterKey();

                      if(isArrayResult){//批量操作
                          //JSONArray jsonarray = (JSONArray) object.get(key);
                          //从请求的参数中解析出查询key对应的value值
                          String value = "";
                          JSONArray beforeParamArray = new JSONArray();
                          for (int i = 0; i < operateParamArray.size(); i++) {
                              JSONObject params =  operateParamArray.getJSONObject(i);
                              JSONArray paramArray = (JSONArray) params.get(key);
                              if (paramArray != null) {
                                  for (int j = 0; j < paramArray.size(); j++) {
                                      String paramId =  paramArray.getString(j);
                                      //在此处判断spring bean查询的方法参数类型
                                      Object data = getOperateBeforeData(paramType, serviceClass, queryMethod, paramId);
                                      JSONObject json = (JSONObject) JSON.toJSON(data);
                                      beforeParamArray.add(json);
                                  }
                              }
                          }
                          log.setBeforeParams(beforeParamArray.toJSONString());

                      }else{//单量操作

                          //从请求的参数中解析出查询key对应的value值
                          String value = "";
                          for (int i = 0; i < operateParamArray.size(); i++) {
                              JSONObject params =  operateParamArray.getJSONObject(i);
                              value = params.getString(key);
                              if(StringUtils.isNotBlank(value)){
                                  break;
                              }
                          }
                          //在此处获取操作前的spring bean的查询方法
                          Object data = getOperateBeforeData(paramType, serviceClass, queryMethod, value);
                          JSONObject beforeParam = (JSONObject) JSON.toJSON(data);
                          log.setBeforeParams(beforeParam.toJSONString());
                      }
                  }

                  try {
                      //执行页面请求模块方法，并返回
                      object = pjp.proceed();
                      //获取系统时间
                      String endTime = new SimpleDateFormat(FucdnStrConstant.YEAR_MONTH_DAY_HOUR_MINUTE_SECOND.getConstant()).format(new Date());
                      log.setEndTime(endTime);
                      //将object 转化为controller封装返回的实体类：RequestResult
                      RequestResult requestResult = (RequestResult) object;
                      if(requestResult.isResult()){
                          //操作流程成功
                          if(StringUtils.isNotBlank(requestResult.getErrMsg())){
                              log.setResultMsg(requestResult.getErrMsg());
                          }else if(requestResult.getData() instanceof String){
                              log.setResultMsg((String) requestResult.getData());
                          }else{
                              log.setResultMsg("执行成功");
                          }
                      }else{
                          log.setResultMsg("失败");
                      }
                      //保存进数据库
                      logservice.saveLog(log);
                  } catch (Throwable e) {
                      String endTime = new SimpleDateFormat(FucdnStrConstant.YEAR_MONTH_DAY_HOUR_MINUTE_SECOND.getConstant()).format(new Date());
                      log.setEndTime(endTime);

                      log.setResultMsg(e.getMessage());
                      logservice.saveLog(log);
                  }
              } else {
                  //没有包含注解
                  object = pjp.proceed();
              }
          } else {
              //不需要拦截直接执行
              object = pjp.proceed();
          }
          return object;
       }

       /**
        *
        * 功能描述: <br>
        * 〈功能详细描述〉
        *
        * @param paramType:参数类型
        * @param serviceClass：bean名称
        * @param queryMethod：查询method
        * @param value：查询id的value
        * @return
        * @see [相关类/方法](可选)
        * @since [产品/模块版本](可选)
        */
       public Object getOperateBeforeData(String paramType,String serviceClass,String queryMethod,String value){
          Object obj = new Object();
           //在此处解析请求的参数类型，根据id查询数据，id类型有四种：int，Integer,long,Long
           if(paramType.equals("int")){
               int id = Integer.parseInt(value);
               Method  mh = ReflectionUtils.findMethod(SpringContextUtil.getBean(serviceClass).getClass(), queryMethod,Long.class );
              //用spring bean获取操作前的参数,此处需要注意：传入的id类型与bean里面的参数类型需要保持一致
              obj = ReflectionUtils.invokeMethod(mh,  SpringContextUtil.getBean(serviceClass),id);

           }else if(paramType.equals("Integer")){
               Integer id = Integer.valueOf(value);
               Method  mh = ReflectionUtils.findMethod(SpringContextUtil.getBean(serviceClass).getClass(), queryMethod,Long.class );
              //用spring bean获取操作前的参数,此处需要注意：传入的id类型与bean里面的参数类型需要保持一致
              obj = ReflectionUtils.invokeMethod(mh,  SpringContextUtil.getBean(serviceClass),id);

           }else if(paramType.equals("long")){
               long id = Long.parseLong(value);
               Method  mh = ReflectionUtils.findMethod(SpringContextUtil.getBean(serviceClass).getClass(), queryMethod,Long.class );
              //用spring bean获取操作前的参数,此处需要注意：传入的id类型与bean里面的参数类型需要保持一致
              obj = ReflectionUtils.invokeMethod(mh,  SpringContextUtil.getBean(serviceClass),id);

           }else if(paramType.equals("Long")){
               Long id = Long.valueOf(value);
               Method  mh = ReflectionUtils.findMethod(SpringContextUtil.getBean(serviceClass).getClass(), queryMethod,Long.class );
              //用spring bean获取操作前的参数,此处需要注意：传入的id类型与bean里面的参数类型需要保持一致
              obj = ReflectionUtils.invokeMethod(mh,  SpringContextUtil.getBean(serviceClass),id);
           }
           return obj;
       }
  }

三.获取spring bean的工具类

 import org.springframework.beans.BeansException;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.ApplicationContextAware;
 import org.springframework.stereotype.Component;

 /**
  * 获取spring容器，以访问容器中定义的其他bean
  *  xiang
  *  MOSTsView 3.0 2009-11-16
  */
 @Component
 public class SpringContextUtil implements ApplicationContextAware{

     private static ApplicationContext   applicationContext;

     /**
      * 实现ApplicationContextAware接口的回调方法，设置上下文环境
      */
     public void setApplicationContext(ApplicationContext applicationContext){
         SpringContextUtil.applicationContext = applicationContext;
     }

     public static ApplicationContext getApplicationContext(){
         return applicationContext;
     }

     /**
      * 获取对象
      * @return  Object 一个以所给名字注册的bean的实例 (service注解方式，自动生成以首字母小写的类名为bean name)
      */
     public static Object getBean(String name) throws BeansException{
         return applicationContext.getBean(name);
     }
 }

四.操作日志对应的实体类

 1 public class SystemControllerLogInfo{
 2
 3     private long id;
 4
 5     /**用户id*/
 6     private String userId;
 7
 8     /**用户类型*/
 9     private int userType;
10
11     /**操作模块*/
12     private String module;
13
14     /**操作类型*/
15     private String method;
16
17     /**操作前参数*/
18     private String beforeParams;
19
20     /**操作时请求参数*/
21     private String operateParams;
22
23     /**开始时间*/
24     private String startTime;
25
26     /**结束时间*/
27     private String endTime;
28
29     /**操作状态描述*/
30     private int resultStatus;
31
32     /**操作结果描述*/
33     private String resultMsg;

五.进行注解切面调用

 1 @ResponseBody
 2     @RequestMapping(value = "/delete", method = { RequestMethod.POST })
 3     @SystemControllerLog(module="域名管理",methods="域名删除",serviceClass="domainConfService",queryMethod="queryDomain",parameterType="Long",parameterKey="customerDomainId")
 4     public RequestResult delete(@RequestBody String param) {
 5         // 定义请求数据
 6         RequestResult result = new RequestResult();
 7         // 接收数据
 8         CustomerDomain customerDomain = JSONObject.parseObject(param, CustomerDomain.class);
 9         // 更新客户域名
10         try {
11             String data = domainConfService.deleteDomain(customerDomain.getId());
12             // 设置true
13             if (StringUtils.isBlank(data)) {
14                 result.setData("删除成功");
15             } else {
16                 result.setData(data);
17             }
18             result.setResult(true);
19         } catch (Exception e) {
20             // 记录错误信息，并返回
21             LOGGER.error("delete failed", e);
22             result.setErrMsg(e.getMessage());
23         }
24         // 返回
25         return result;
26     }

六.数据实例

补充：get请求参数类型解析和记录

  JSONArray operateParamArray = new JSONArray();
         for (int i = 0; i < args.length; i++) {
             Object paramsObj = args[i];
             //通过该方法可查询对应的object属于什么类型：String type = paramsObj.getClass().getName();
             if(paramsObj instanceof String || paramsObj instanceof JSONObject){
                 String str = (String) paramsObj;
                 //将其转为jsonobject
                 JSONObject dataJson = JSONObject.parseObject(str);
                 if(dataJson == null || dataJson.isEmpty() || "null".equals(dataJson)){
                     break;
                 }else{
                     operateParamArray.add(dataJson);
                 }
             }else if(paramsObj instanceof Map){
                 //get请求，以map类型传参
                 //1.将object的map类型转为jsonobject类型
                 Map<String, Object> map = (Map<String, Object>) paramsObj;
                 JSONObject json =new JSONObject(map);
                 operateParamArray.add(json);
             }
         }

get请求的controller示例：

@ResponseBody
    @RequestMapping(value = "/add", method = { RequestMethod.GET })
    @SystemControllerLog(module="域名管理",methods="域名新增")
    public RequestResult addDomain(@RequestParam Map<String, String> paramMap) {