使用spring aop 记录接口日志

spring配置文件中增加启用aop的配置

 <!-- 增加aop 自动代理配置 -->
 <aop:aspectj-autoproxy />

切面类配置

 package com.zchx.acvices;

 import java.text.SimpleDateFormat;

 import org.aspectj.lang.JoinPoint;
 import org.aspectj.lang.ProceedingJoinPoint;
 import org.aspectj.lang.annotation.After;
 import org.aspectj.lang.annotation.AfterReturning;
 import org.aspectj.lang.annotation.AfterThrowing;
 import org.aspectj.lang.annotation.Around;
 import org.aspectj.lang.annotation.Aspect;
 import org.aspectj.lang.annotation.Before;
 import org.aspectj.lang.annotation.Pointcut;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Component;

 /**
  * 切面日志记录
  *
  * @version V1.0
  * @author songxiaotong
  * @date 2018年2月6日 下午2:39:03
  * @Description
  */
 // 声明这是一个组件
 @Component
 // 声明这是一个切面Bean
 @Aspect
 public class Advices {

     /**
      * 日志记录工具
      */
     private static final Logger LOGGER = LoggerFactory.getLogger(Advices.class);

     /**
      * 默认构造函数
      */
     public Advices() {
         LOGGER.debug("初始化日志切面");
     }

     /**
      * 配置切入点,该方法无方法体,主要为方便同类中其他方法使用此处配置的切入点
      * <p>
      * 扫描com.sixeco下面的所有类
      *
      * @see [类、类#方法、类#成员]
      */
     @Pointcut("execution(* com.zhichenhaixin..*.*(..)) or execution(* com.zchx..*.*(..))")
     public void aspect() {
     }

     /**
      * 配置前置通知,使用在方法aspect()上注册的切入点
      * <p>
      * 同时接受JoinPoint切入点对象,可以没有该参数
      *
      * @param joinPoint 切入点
      * @see [类、类#方法、类#成员]
      */
     @Before("aspect()")
     public void before(JoinPoint joinPoint) {
         // LOGGER.debug("before {}", joinPoint.getSignature().toString());
     }

     /**
      * 配置后置通知,使用在方法aspect()上注册的切入点
      * <p>
      * </p>
      *
      * @param joinPoint 切入点
      * @see [类、类#方法、类#成员]
      */
     @After("aspect()")
     public void after(JoinPoint joinPoint) {
         // LOGGER.debug("after {}", joinPoint.getSignature().toString());
     }

     /**
      * 配置环绕通知,使用在方法aspect()上注册的切入点
      * <p>
      * 记录方法开始到结束的耗时
      *
      * @param joinPoint 切入点
      * @return Object 处理结果
      * @throws Throwable 异常
      * @see [类、类#方法、类#成员]
      */
     @Around("aspect()")
     public Object around(JoinPoint joinPoint) throws Throwable {
         long start = System.currentTimeMillis();
         Object object = null;
         try {
             ProceedingJoinPoint tempJoinPoint = (ProceedingJoinPoint) joinPoint;
             object = tempJoinPoint.proceed();
             long end = System.currentTimeMillis();
             // LOGGER.debug("around {} Use time : {} ms!",
             // joinPoint.getSignature().toString(), end - start);
             LOGGER.debug("计时时间：{}  耗时：{}毫秒  URI: {}  最大内存: {}m  已分配内存: {}m  已分配内存中的剩余空间: {}m  最大可用内存: {}m",
                     new SimpleDateFormat("hh:mm:ss.SSS").format(start), end - start,
                     joinPoint.getSignature().toString(), Runtime.getRuntime().maxMemory() / 1024 / 1024,
                     Runtime.getRuntime().totalMemory() / 1024 / 1024, Runtime.getRuntime().freeMemory() / 1024 / 1024,
                     (Runtime.getRuntime().maxMemory() - Runtime.getRuntime().totalMemory()
                             + Runtime.getRuntime().freeMemory()) / 1024 / 1024);
         } catch (Throwable e) {
             long end = System.currentTimeMillis();
             // LOGGER.debug("around {} Use time : {} ms with exception",
             // joinPoint.getSignature().toString(), end - start);

             LOGGER.debug("计时时间：{}  耗时：{}毫秒  URI: {}  最大内存: {}m  已分配内存: {}m  已分配内存中的剩余空间: {}m  最大可用内存: {}m",
                     new SimpleDateFormat("hh:mm:ss.SSS").format(start), end - start,
                     joinPoint.getSignature().toString(), Runtime.getRuntime().maxMemory() / 1024 / 1024,
                     Runtime.getRuntime().totalMemory() / 1024 / 1024, Runtime.getRuntime().freeMemory() / 1024 / 1024,
                     (Runtime.getRuntime().maxMemory() - Runtime.getRuntime().totalMemory()
                             + Runtime.getRuntime().freeMemory()) / 1024 / 1024);

             StackTraceElement[] s = e.getStackTrace();

             if (s.length >= 1) {
                 StackTraceElement parentStack = s[0];
                 LOGGER.error("发生异常 : 类名 >> {}, 函数名 >> {},问题产生行 >> {},类型 >> {}",
                         new Object[] { parentStack.getClassName(), parentStack.getMethodName(),
                                 parentStack.getLineNumber(), e.getClass().getName() });
             }
             throw e;
         }
         return object;
     }

     /**
      * <配置后置返回通知,使用在方法aspect()上注册的切入点
      * <p>
      *
      * @param joinPoint 切入点
      * @see [类、类#方法、类#成员]
      */
     @AfterReturning("aspect()")
     public void afterReturn(JoinPoint joinPoint) {
         // LOGGER.debug("afterReturn {}", joinPoint.getSignature().toString());
     }

     /**
      * 配置抛出异常后通知,使用在方法aspect()上注册的切入点
      *
      * @param joinPoint 切入点
      * @param ex 异常
      * @see [类、类#方法、类#成员]
      */
     @AfterThrowing(pointcut = "aspect()", throwing = "ex")
     public void afterThrow(JoinPoint joinPoint, Exception ex) {
         // LOGGER.debug("afterThrow {}", joinPoint.getSignature().toString());
     }
 }