Spring框架下的 “接口调用、MVC请求” 调用参数、返回值、耗时信息输出

主要拦截前端或后天的请求，打印请求方法参数、返回值、耗时、异常的日志。方便开发调试，能很快定位到问题出现在哪个方法中。

前端请求拦截，mvc的拦截器

 import java.util.Date;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.Set;

 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;

 import org.codehaus.jackson.map.ObjectMapper;
 import org.springframework.core.NamedThreadLocal;
 import org.springframework.web.servlet.HandlerInterceptor;
 import org.springframework.web.servlet.ModelAndView;

 import com.xxx.eduyun.sdk.log.ApplicationLogging;
 import com.xxx.flipclass.sdk.client.utils.TimeUtil;

 /**
  * <b>function:</b> spring mvc 请求拦截器
  * @author hoojo
  * @createDate 2016-11-24 下午3:19:27
  * @file MVCRequestInterceptor.java
  * @package com.xxx.eduyun.app.mvc.interceptor
  * @project eduyun-app-web
  * @blog http://blog.csdn.net/IBM_hoojo
  * @email hoojo_@126.com
  * @version 1.0
  */
 public class MVCRequestInterceptor extends ApplicationLogging implements HandlerInterceptor {

     private static final ObjectMapper mapper = new ObjectMapper();
     private NamedThreadLocal<Long>  startTimeThreadLocal = new NamedThreadLocal<Long>("StopWatch-startTimed");  

     @Override
     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

         info("##############################【一个MVC完整请求开始】##############################");

         info("*******************MVC业务处理开始**********************");
         try {
             long timed = System.currentTimeMillis();
             startTimeThreadLocal.set(timed);

             String requestURL = request.getRequestURI();
             info("当前请求的URL：【{}】", requestURL);
             info("执行目标方法: {}", handler);

             Map<String, ?> params = request.getParameterMap();
             if (!params.isEmpty()) {
                 info("当前请求参数打印：");
                 print(request.getParameterMap(), "参数");
             }
         } catch (Exception e) {
             error("MVC业务处理-拦截器异常：", e);
         }
         info("*******************MVC业务处理结束**********************");

         return true;
     }

     @Override
     public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

         info("*******************一个MVC 视图渲染开始**********************");

         try {
             info("执行业务逻辑代码耗时：【{}】", TimeUtil.formatTime(new Date().getTime() - startTimeThreadLocal.get()));
             String requestURL = request.getRequestURI();
             info("当前请求的URL：【{}】", requestURL);

             if (modelAndView != null) {
                 info("即将返回到MVC视图：{}", modelAndView.getViewName());

                 if (modelAndView.getView() != null) {
                     info("返回到MVC视图内容类型ContentType：{}", modelAndView.getView().getContentType());
                 }

                 if (!modelAndView.getModel().isEmpty()) {

                     info("返回到MVC视图{}数据打印如下：", modelAndView.getViewName());
                     print(modelAndView.getModel(), "返回数据");
                 }
             }
         } catch (Exception e) {
             error("MVC 视图渲染-拦截器异常：", e);
         }

         info("*******************一个MVC 视图渲染结束**********************");
     }

     @Override
     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

         try {
             String requestURL = request.getRequestURI();
             info("MVC返回请求完成URL：【{}】", requestURL);
             info("MVC返回请求完成耗时：【{}】", TimeUtil.formatTime(new Date().getTime() - startTimeThreadLocal.get()));
             if (ex != null) {
                 info("MVC返回请求发生异常：", ex.getMessage());
                 error("异常信息如下：", ex);
             }
         } catch (Exception e) {
             error("MVC完成返回-拦截器异常：", e);
         }

         info("##############################【一个MVC完整请求完成】##############################");
     }

     private void print(Map<String, ?> map, String prefix) {
         if (map != null) {
             Set<String> keys = map.keySet();
             Iterator<String> iter = keys.iterator();
             while (iter.hasNext()) {

                 String name = iter.next();
                 if (name.contains("org.springframework.validation.BindingResult")) {
                     continue;
                 }

                 String value = "";
                 try {
                     value = mapper.writeValueAsString(map.get(name));
                 } catch (Exception e) {
                     error("转换参数【{}】发生异常：", name, e);
                 }
                 info("{} \"{}\"： {}", prefix, name, value);
             }
         }
     }
 }

spring-mvc.xml增加配置内容

 <mvc:interceptors>
     <mvc:interceptor>
         <mvc:mapping path="/**"/>
         <mvc:exclude-mapping path="/exceltemplate/**" />
         <mvc:exclude-mapping path="/statics/**" />
         <mvc:exclude-mapping path="/global/**" />
         <mvc:exclude-mapping path="/denied/**" />
         <mvc:exclude-mapping path="/favicon.ico" />
         <mvc:exclude-mapping path="/index.jsp" />
         <bean class="com.xxx.eduyun.app.mvc.interceptor.MVCRequestInterceptor"/>
     </mvc:interceptor>
 </mvc:interceptors>

过滤静态资源，一些静态资源不需要拦截，在这里配置黑名单不让它进入拦截器。

下面是sdk接口拦截器，用到spirng的aop的MethodIntercept

 package com.xxx.flipclass.sdk.framework.aop;

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

 import org.aopalliance.intercept.MethodInterceptor;
 import org.aopalliance.intercept.MethodInvocation;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.codehaus.jackson.map.ObjectMapper;

 import com.xxx.flipclass.sdk.client.utils.ParameterNameUtils;
 import com.xxx.flipclass.sdk.client.utils.TimeUtil;

 /**
  * <b>function:</b> Spring 接口调用拦截器，主要拦截com.xxx.*.sdk.client对外接口
  * @author hoojo
  * @createDate 2016-11-24 下午5:39:57
  * @file ExecutionApiLogMethodInterceptor.java
  * @package com.xxx.eduyun.sdk.framework
  * @project eduyun-sdk-service
  * @blog http://blog.csdn.net/IBM_hoojo
  * @email hoojo_@126.com
  * @version 1.0
  */
 public class ExecutionApiLogMethodInterceptor implements MethodInterceptor {

     private Logger log = LogManager.getLogger(ExecutionApiLogMethodInterceptor.class);
     private static final ObjectMapper mapper = new ObjectMapper();

     @Override
     public Object invoke(MethodInvocation invocation) throws Throwable {

         info("************************************【接口调用拦截开始】*************************************");
         String targetName = invocation.getThis().getClass().getSimpleName();
         Method method = invocation.getMethod();
         String methodName = method.getName();

         info("系统开始执行方法：{}.{}", targetName, methodName);

         info("【{}.{}】方法参数打印如下：", targetName, methodName);
         Object[] args = invocation.getArguments();

         //printArgs(args, method, invocation.getThis().getClass());
         printArgs(args, method);

         try {
             long timed = System.currentTimeMillis();

             Object result = invocation.proceed();

             info("【{}.{}】方法执行完成，耗时：【{}】", targetName, methodName, TimeUtil.formatTime(new Date().getTime() - timed));
             info("【{}.{}】方法执行返回结果：{}", targetName, methodName, result);

             info("【{}.{}】方法返回数据打印如下：", targetName, methodName);
             printResult(result);
             info("************************************【接口调用拦截结束*】************************************");

             return result;
         } catch (Throwable throwable) {
             error("外部接口调用方法【{}.{}】异常：", targetName, methodName, throwable);

             info("************************************【接口异常拦截结束】*************************************");
             throw throwable;
         }
     }

     private void printArgs(Object[] args, Method method) {
         try {

             String[] argNames = null;
             try {
                 argNames = ParameterNameUtils.getMethodParamNames(method);
             } catch (Exception e) {
                 error("获取参数名称异常：", e);
             }

             if (args != null) {
                 for (int i = 0; i < args.length; i++) {
                     String argName = "";
                     if (argNames != null && argNames.length >= i) {
                         argName = argNames[i];
                     }

                     if (args[i] != null) {
                         String value = "";
                         try {
                             value = mapper.writeValueAsString(args[i]);
                         } catch (Exception e) {
                             error("转换参数 \"{}\" 发生异常：", argName, e);
                         }
                         info("【参数 \"{}\" 】：({})", argName, value);
                     } else {
                         info("参数 \"{}\"：NULL", argName);
                     }
                 }
             }
         } catch (Exception e) {
             error("【接口调用拦截器】打印方法执行参数异常：", e);
         }
     }

     private void printResult(Object result) {
         if (result != null) {
             try {
                 info("【返回数据】：({})", mapper.writeValueAsString(result));
             } catch (Exception e) {
                 error("返回数据打印异常：", e);
             }
         } else {
             info("【返回数据】：NULL");
         }
     }

     protected final void error(String msg, Object... objects) {
         log.error(msg, objects);
     }

     protected final void info(String msg, Object... objects) {
         log.info(msg, objects);
     }
 }

上面使用到了方法参数获取的工具类，代码如下：

 package com.xxx.flipclass.sdk.client.utils;

 import java.io.InputStream;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.util.Arrays;

 import org.springframework.asm.ClassReader;
 import org.springframework.asm.ClassVisitor;
 import org.springframework.asm.ClassWriter;
 import org.springframework.asm.Label;
 import org.springframework.asm.MethodVisitor;
 import org.springframework.asm.Opcodes;
 import org.springframework.asm.Type;

 /**
  * <b>function:</b> 获取方法参加名称
  * @createDate 2016-11-25 下午3:40:33
  * @file ParameterNameUtils.java
  * @package com.xxx.flipclass.sdk.client.utils
  * @project flipclass-sdk-client
  * @version 1.0
  */
 public abstract class ParameterNameUtils {

     /**
      * 获取指定类指定方法的参数名
      *
      * @param clazz 要获取参数名的方法所属的类
      * @param method 要获取参数名的方法
      * @return 按参数顺序排列的参数名列表，如果没有参数，则返回null
      */
     public static String[] getMethodParamNames(Class<?> clazz, final Method method) throws Exception {

         try {

             final String[] paramNames = new String[method.getParameterTypes().length];
             String className = clazz.getName();

             int lastDotIndex = className.lastIndexOf(".");
             className = className.substring(lastDotIndex + 1) + ".class";
             InputStream is = clazz.getResourceAsStream(className);

             final ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
             ClassReader cr = new ClassReader(is);

             cr.accept(new ClassVisitor(Opcodes.ASM4, cw) {
                 @Override
                 public MethodVisitor visitMethod(final int access, final String name, final String desc, final String signature, final String[] exceptions) {
                     final Type[] args = Type.getArgumentTypes(desc);
                     // 方法名相同并且参数个数相同
                     if (!name.equals(method.getName()) || !sameType(args, method.getParameterTypes())) {
                         return super.visitMethod(access, name, desc, signature, exceptions);
                     }
                     MethodVisitor v = cv.visitMethod(access, name, desc, signature, exceptions);
                     return new MethodVisitor(Opcodes.ASM4, v) {
                         @Override
                         public void visitLocalVariable(String name, String desc, String signature, Label start, Label end, int index) {
                             int i = index - 1;
                             // 如果是静态方法，则第一就是参数
                             // 如果不是静态方法，则第一个是"this"，然后才是方法的参数
                             if (Modifier.isStatic(method.getModifiers())) {
                                 i = index;
                             }
                             if (i >= 0 && i < paramNames.length) {
                                 paramNames[i] = name;
                             }
                             super.visitLocalVariable(name, desc, signature, start, end, index);
                         }

                     };
                 }
             }, 0);
             return paramNames;
         } catch (Exception e) {
             throw e;
         }
     }

     /**
      * 比较参数类型是否一致
      * @param types asm的类型({@link Type})
      * @param clazzes java 类型({@link Class})
      * @return
      */
     private static boolean sameType(Type[] types, Class<?>[] clazzes) {
         // 个数不同
         if (types.length != clazzes.length) {
             return false;
         }

         for (int i = 0; i < types.length; i++) {
             if (!Type.getType(clazzes[i]).equals(types[i])) {
                 return false;
             }
         }
         return true;
     }

     /**
      * 获取方法的参数名
      * @param Method
      * @return argsNames[]
      */
     public static String[] getMethodParamNames(final Method method) throws Exception {

         return getMethodParamNames(method.getDeclaringClass(), method);
     }

     public static void main(String[] args) throws Exception {
         Class<ParameterNameUtils> clazz = ParameterNameUtils.class;

         Method method = clazz.getDeclaredMethod("getMethodParamNames", Method.class);
         String[] parameterNames = ParameterNameUtils.getMethodParamNames(method);
         System.out.println(Arrays.toString(parameterNames));

         method = clazz.getDeclaredMethod("sameType", Type[].class, Class[].class);
         parameterNames = ParameterNameUtils.getMethodParamNames(method);
         System.out.println(Arrays.toString(parameterNames));
     }
 }

最后需要添加配置，拦截哪些接口或是实现类，具体看个人业务

 <?xml version="1.0" encoding="UTF-8"?>
 <beans xmlns="http://www.springframework.org/schema/beans"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns:aop="http://www.springframework.org/schema/aop"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
                         http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
                         http://www.springframework.org/schema/aop
                          http://www.springframework.org/schema/aop/spring-aop-3.2.xsd">

     <bean id="externalApiMethodInterceptor" class="com.xxx.flipclass.sdk.framework.aop.ExecutionApiLogMethodInterceptor" />

     <aop:config proxy-target-class="true">
         <aop:pointcut id="externalApiMethodPointcut" expression="!execution(* com.xxx.flipclass.sdk.client.interfaces..*.loginInfoService.*(..)) and (execution(* com.xxx.*.sdk.client.interfaces..*.*Client*.*(..)) || execution(* com.xxx.*.sdk.client.interfaces..*.*Service*.*(..)))" />
         <aop:advisor advice-ref="externalApiMethodInterceptor" pointcut-ref="externalApiMethodPointcut" />
     </aop:config>
 </beans>