springboot 整合aop

一. 加依赖 

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.13</version>
        </dependency>

二.代码

package com.meipingmi.yunyikuoperation.common.interceptor;

import java.lang.reflect.AnnotatedType;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.TypeVariable;
import java.util.concurrent.TimeUnit;

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

import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.context.support.WebApplicationContextUtils;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

import com.meipingmi.yunyikuoperation.common.contants.RedisConstants;
import com.meipingmi.yunyikuoperation.common.exception.LoginException;
import com.meipingmi.yunyikuoperation.common.util.JsonUtils;
import com.meipingmi.yunyikuoperation.common.util.MyThreadLocal;
import com.meipingmi.yunyikuoperation.modules.rbac.entity.Admin;

import lombok.extern.slf4j.Slf4j;

@Slf4j
@Aspect
@Component
public class AdminInterceptor implements HandlerInterceptor {

    @Pointcut("execution(* com.zuo.modules.business.dao..*(..))")
    public void execute() {
    }

    @Before("execute()")
    public void before(JoinPoint joinPoint) {
    }

    @AfterReturning(pointcut = "execute()", returning = "rst")
    public void afterReturning(JoinPoint joinPoint, Object rst) {
        System.out.println(">>>>>>>>>>>>>>>处理前的rst=" + rst);
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        Object[] args = joinPoint.getArgs();
        System.out.println(">>>>>>>args = " + args.toString());
        for(int i = 0;i< args.length;i++){
            System.out.println(">>>>>arg[i]=" + args[i]);
        }

        Class<?> returnType = null;
        Class<?> returnType1 = method.getReturnType();
        if(returnType1.getTypeName().equals("java.Lang.List")){
            returnType = getActualTypeArgument(returnType);
        }else{
            returnType = returnType1;
        }

     /*   if(returnType.getAnnotation(OOO.class)){
            //需要去找字段处理
            Field[] declaredFields = returnType.getDeclaredFields();
            for(int i = 0;i< declaredFields.length;i++){
                Field declaredField = declaredFields[i];
                if(declaredField.getAnnotation(AAA.class) != null){
                    //需要处理的字段
                    // todo
                }

            }
        }*/
        System.out.println(">>>>>>>>>>>>>>>处理后的rst=" + rst);
    }

    /*
     * 获取泛型类Class对象，不是泛型类则返回null
     */
    public Class<?> getActualTypeArgument(Class<?> clazz) {
        Class<?> entitiClass = null;
        Type genericSuperclass = clazz.getGenericSuperclass();
        if (genericSuperclass instanceof ParameterizedType) {
            Type[] actualTypeArguments = ((ParameterizedType) genericSuperclass)
                    .getActualTypeArguments();
            if (actualTypeArguments != null && actualTypeArguments.length > 0) {
                entitiClass = (Class<?>) actualTypeArguments[0];
            }
        }

        return entitiClass;
    }


}