spring boot 添加aop功能

spring aop 具体的定义自己百度，这里只简单说下spring boot 添加aop功能

aop一般会用来和memcached一起做缓存，方法执行时间统计，还有日志的跟踪等等。

首先引入aop的起始依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
 
 
1
2
3
4
 
 
1
2
3
4

然后配置文件把aop打开即可

spring:
    aop:
        auto: true
 
 
1
2
3
 
 
1
2
3

上面是.yml的配置方法，如果是用的properties

spring.aop.auto= true
 
 
1
 
 
1

这样就可以了，剩下的就和spring中的一样了

package com.example.controller;

import org.aspectj.lang.ProceedingJoinPoint;
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.stereotype.Component;
import org.springframework.util.StopWatch;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.reflect.Method;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Set;

/**
 * Created by mazhenhua on 2017/1/4.
 */

@Aspect
@Component
public class AopControll {
    private static final Logger logger = LoggerFactory.getLogger(AopControll.class);

    /**
     * 定义拦截规则：拦截com.example.controller包下面的所有类中，有@RequestMapping注解的方法。
     */
    @Pointcut("execution(* com.example.controller..*(..)) && @annotation(org.springframework.web.bind.annotation.RequestMapping)")
    public void controllerMethodPointcut(){}


    /**
     * 环绕通知
     * @param pjp
     * @return
     */
    @Around("controllerMethodPointcut()") //指定拦截器规则;
    public Object Interceptor(ProceedingJoinPoint pjp){
        StopWatch clock = new StopWatch();  // 计时器统计执行时间
        clock.start();
        MethodSignature signature = (MethodSignature) pjp.getSignature();
        Method method = signature.getMethod(); //获取被拦截的方法
        String methodName = method.getName(); //获取被拦截的方法名

        Set<Object> allParams = new LinkedHashSet<>(); //保存所有请求参数，用于输出到日志中

        logger.info("请求开始，方法：{}", methodName);

        Object result = null;

        Object[] args = pjp.getArgs();
        for(Object arg : args){
            if (arg instanceof Map<?, ?>) {
                //提取方法中的MAP参数，用于记录进日志中
                @SuppressWarnings("unchecked")
                Map<String, Object> map = (Map<String, Object>) arg;

                allParams.add(map);
            }else if(arg instanceof HttpServletRequest){
                HttpServletRequest request = (HttpServletRequest) arg;
                //获取query string 或 posted form data参数
                Map<String, String[]> paramMap = request.getParameterMap();
                if(paramMap!=null && paramMap.size()>0){
                    allParams.add(paramMap);
                }
            }else if(arg instanceof HttpServletResponse){
                //do nothing...
            }else{
                //allParams.add(arg);
            }
        }

        try {
            if(result == null){
                // 执行切面方法
                result = pjp.proceed(); // 被拦截住的那个方法
            }
        } catch (Throwable e) {
            logger.info("exception: ", e);
        }

        clock.stop(); //计时结束
        logger.info("{}请求结束，耗时：{}ms", methodName, clock.getTotalTimeMillis());

        return result;
    }


}