springMvc拦截器实现操作日志的自动持久层

1.首先在spring的配置文件中配置拦截器

   <mvc:interceptor>
      <mvc:mapping path="/**" />
      <ref bean="logInterceptor"/>
   </mvc:interceptor>
</mvc:interceptors>

2.定义拦截器的实现类

<bean id="logInterceptor" class="com.cms.web.interceptor.LogInterceptor">
   <property name="userWebServiceClient" ref="userWebServiceClientImpl" />
   <property name="cmsLogWebServiceClient" ref="cmsLogWebserviceClient"></property>
   <property name="validator" ref="parameterValidatorAdaptor"></property>
</bean>
3.拦截器的实现
package com.web.web.interceptor;

import com.alibaba.fastjson.JSON;
import com.pinganfu.cmsproxy.common.facade.bean.CMSLog;
import com.pinganfu.cmsproxy.common.facade.validator.Valid;
import com.pinganfu.cmsweb.biz.util.UserLoginHolder;
import com.pinganfu.cmsweb.common.constant.CMSConstant;
import com.pinganfu.cmsweb.common.constant.CMSWebLogType;
import com.pinganfu.cmsweb.common.integration.ws.CMSLogWebServiceClient;
import com.pinganfu.cmsweb.common.integration.ws.UserWebServiceClient;
import com.pinganfu.cmsweb.common.log.LoggerAdapterFactory;
import com.pinganfu.cmsweb.common.util.RequestContext;
import com.pinganfu.cmsweb.web.config.LogOperationProperties;
import com.pinganfu.cmsweb.web.log.Log;
import com.pinganfu.cmsweb.web.validator.ParameterValidator;
import com.pinganfu.common.context.ApplicationContextConfig;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.apache.commons.lang.StringUtils;
import org.codehaus.jackson.map.ObjectMapper;
import org.slf4j.Logger;
import org.springframework.aop.AfterReturningAdvice;
import org.springframework.core.MethodParameter;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.OutputStream;
import java.lang.reflect.Method;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

public class LogInterceptor implements HandlerInterceptor,AfterReturningAdvice {

   private UserWebServiceClient userWebServiceClient;
   
   private CMSLogWebServiceClient cmsLogWebServiceClient;
   
   private static final Logger logger = LoggerAdapterFactory.getLogger(CMSWebLogType.WEB);

    private ParameterValidator validator;
   /**
    * 
    */
   public LogInterceptor() {
      // TODO Auto-generated constructor stub
   }

   /*
    * (non-Javadoc)
    * 
    * @see
    * org.springframework.web.servlet.HandlerInterceptor#preHandle(javax.servlet
    * .http.HttpServletRequest, javax.servlet.http.HttpServletResponse,
    * java.lang.Object)
    */
   public boolean preHandle(HttpServletRequest request,
         HttpServletResponse response, Object handler) throws Exception {
      logger.info("" + request.getRequestURI());
      if(!HandlerMethod.class.isAssignableFrom(handler.getClass())){
         return true;
      }
        HandlerMethod handlerMethod = (HandlerMethod) handler;
        MethodParameter[] params= handlerMethod.getMethodParameters();
        boolean result=true;
        for(MethodParameter param:params){
            Valid valid=  param.getParameterAnnotation(Valid.class);
         RequestParam requestParam = param.getParameterAnnotation(RequestParam.class);
         if(requestParam!=null){
            if(requestParam.required()){
               String paramValue = request.getParameter(requestParam.value());
               if(param.getParameterType()==String.class&& StringUtils.isEmpty(paramValue)){
                  OutputStream os = response.getOutputStream();
                  os.write("validate failed".getBytes("UTF-8"));
                  os.flush();
                  os.close();
                  return false;
               }
            }
         }
            if(valid!=null){
                result = validator.validate(valid,request.getParameter(valid.name()));
                if(!result){
               OutputStream os = response.getOutputStream();
                    os.write("validate failed".getBytes("UTF-8"));
                    os.flush();
                    os.close();
                    return false;
                }
            }
        }
      String userId = (String) request.getSession().getAttribute("userId");
      if(userId!=null){
         UserLoginHolder.handleCurrentUser(userId);
      }
      return result;
   }

   /*
    * (non-Javadoc)
    * 
    * @see
    * org.springframework.web.servlet.HandlerInterceptor#postHandle(javax.servlet
    * .http.HttpServletRequest, javax.servlet.http.HttpServletResponse,
    * java.lang.Object, org.springframework.web.servlet.ModelAndView)
    */
   public void postHandle(HttpServletRequest request,
         HttpServletResponse response, Object handler,
         ModelAndView modelAndView) throws Exception {
      request.setAttribute("version", CMSConstant.CURRENT_CMS_VERSION);
   }

   /*
    * (non-Javadoc)
    * 
    * @see
    * org.springframework.web.servlet.HandlerInterceptor#afterCompletion(javax
    * .servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse,
    * java.lang.Object, java.lang.Exception)
    */
   @SuppressWarnings("rawtypes")
   public void afterCompletion(HttpServletRequest request,
         HttpServletResponse response, Object handler, Exception ex)
         throws Exception {
      try{
      if (handler instanceof HandlerMethod) {
         HandlerMethod methodHandler = (HandlerMethod) handler;
         Log log = methodHandler.getMethod().getAnnotation(Log.class);
         if (log != null) {
            Map parameters = request.getParameterMap();
            CMSLog cmsLog = new CMSLog();
            ObjectMapper mapper = new ObjectMapper();
            if (parameters != null) {
               Map<String,String> requestInfo = new HashMap<String,String>();
               requestInfo.put("requestInfo", RequestContext.getTraceInfo());
               String requestParameters = mapper.writeValueAsString(requestInfo);
               cmsLog.setRequestParameters(requestParameters);
            }
            cmsLog.setCdate(new Date());
            cmsLog.setModuleName(log.operationModule().moduleName);
            cmsLog.setOperation(LogOperationProperties.getOperationName(log.operationModule().moduleCode, log.operation()));
            cmsLog.setRequestUri(request.getRequestURI());
            logger.info("operationModule:" + cmsLog.getModuleName() + ",operation content:" + cmsLog.getOperation() + ",request uri:" + cmsLog.getRequestUri());
            logger.info("request parameters:" + (parameters == null ? "null" : mapper.writeValueAsString(parameters)));
            Object userId = request.getSession().getAttribute("userId");
            if(userId!=null){
               String phoneNum = userWebServiceClient.queryPhoneNumByUserId(userId.toString());
               cmsLog.setUserId(userId.toString());
               cmsLog.setPhoneNum(phoneNum);
               cmsLog.setUserName(userId.toString());
            }
            try{
               cmsLogWebServiceClient.createLog(cmsLog);
               logger.info("cmslog create a new log ======"+mapper.writeValueAsString(cmsLog));
            }catch(Exception e){//即使记录日志出现异常不能影响正常业务
               logger.info("fail to save operation log ", e);
            }
         }
      }
      }finally{
         UserLoginHolder.clean();
      }
   }

   public void setUserWebServiceClient(
         UserWebServiceClient userWebServiceClient) {
      this.userWebServiceClient = userWebServiceClient;
   }

   public void setCmsLogWebServiceClient(
         CMSLogWebServiceClient cmsLogWebServiceClient) {
      this.cmsLogWebServiceClient = cmsLogWebServiceClient;
   }

    public void setValidator(ParameterValidator validator) {
        this.validator = validator;
    }


   @Override
   public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
         logger.info("invoke [{}] method [{}] args[{}]", target.getClass(), method.getName(), formatArgs(args));
         logger.info("method:"+method);
   }
   
   private String formatArgs(Object[] args){
      StringBuffer argsStr = new StringBuffer();
      for(Object arg:args){
         if(arg!=null){
            if(HttpServletRequest.class.isAssignableFrom(arg.getClass())||HttpServletResponse.class.isAssignableFrom(arg.getClass())){
               continue;
            }else{
               argsStr.append(JSON.toJSONString(arg)).append(",");
            }
         }else{
            argsStr.append("null,");
         }
      }
      if(argsStr.length()>0){
         argsStr.setLength(argsStr.length()-1);
      }
      return argsStr.toString();
   }
}

4.日志的注解类
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})
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface Log {

   
   public String operation() default LogOperation.ADD;
   
    public LogOperation operationModule() default LogOperation.FILE;
   
   public String ext() default "";
   
}
5.定义操作方式的枚举类
public enum LogOperation {

    FILE("FILE","文件系统"),
    ADMIN("ADMIN","后台管理"),
    MCM("MCM","消息中心");


    public static final  String ADD="ADD";

    public static final  String GET="GET";

    public static final  String MODIFY="MODIFY";

    public static final  String ADD_DIR="ADD_DIR";

    public static final  String REMOVE="REMOVE";

    public static final String REMOVE_DIR="REMOVE_DIR";



    public  String moduleName;

    public String moduleCode;


    LogOperation(String moduleCode,String moduleName){
        this.moduleCode = moduleCode;
        this.moduleName=moduleName;
    }

}
6.在controller中添加日志的注解
@RequestMapping(value = "/createDirectory", method = RequestMethod.POST)
@Log(operation=LogOperation.ADD_DIR,operationModule=LogOperation.FILE)
public @ResponseBody AjaxResponse createDirectory(@RequestParam("filePath") String filePath,HttpServletRequest req)
        throws IOException {
    AjaxResponse ajaxResponse = new AjaxResponse();
    logger.info("controller->createDirectory:" + Utils.getUserId(req) + ",filePath:" + filePath);
    boolean res = Utils.ifNotExistCreate(filePath);
    ajaxResponse.setRetCode(AjaxResponse.SUCCESS);
    ajaxResponse.setRetData(res);
    return ajaxResponse;
}
ublic static boolean ifNotExistCreate(String path){
   File file = new File(path);
   boolean res = file.exists();
   if(!res){
      if( !file.mkdirs()){
               logger.debug("mkdir {} error", file.getName());
               return false;
           }
   }
       return true;