基于SpringAOP思想的拦截器，摒弃了InterceptorAdapter

每次当涉及到权限验证的时候，大家最先想到的就是基于SpringMVC的InterceptorAdapter拦截器来进行基础的权限验证，但是这个拦截器有这样一个问题，就是默认会拦截所有的请求，那么这个时候我们就可以基于AOP的思想，那些地方需要被拦截，只要关注这些地方就行了。下面直接上代码

基础技术 SpringBoot+JWT
pom文件如下：

<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt</artifactId>
<version>0.9.0</version>
</dependency>
<!-- SpringBoot 拦截器 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>1.9.5</version>
</dependency>

下面开始代码
1.AnnotationUtils工具类

import cn.hutool.log.Log;
import cn.hutool.log.LogFactory;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;

/**
* 获取注解工具类
*
* @author wuhx 2020-05-15 09:23
*/
public class AnnotationUtils {
private static final Log log = LogFactory.get();

/**
* 获取方法上的注解
*
* @param method     执行方法
* @param annotation 注解的class
* @return 返回注解实现对象, 如果没有, 则返回null
*/
public static <T extends Annotation> T getAnnotation(Method method, Class<T> annotation) {
if (method != null) {
try {
return method.getAnnotation(annotation);
} catch (Exception e) {
log.error(("获取方法上注解异常"), e);
return null;
}
}

return null;
}

/**
* 获取类上的注解
*
* @param aClass     执行方法
* @param annotation 注解的class
* @return 返回注解实现对象, 如果没有, 则返回null
*/
@SuppressWarnings("unchecked")
public static <A extends Annotation> A getClassAnnotation(Class aClass, Class<A> annotation) {
if (aClass != null) {
try {
return (A) aClass.getAnnotation(annotation);
} catch (Exception e) {
log.error(("获取类上注解异常"), e);
return null;
}
}

return null;
}

/**
* 获取属性上的注解
*
* @author wuhx 2020-05-15 09:25
*/
public static <T extends Annotation> T getFieldAnnotation(Class aClass, Class<T> annotation, String name) {
try {
return aClass.getDeclaredField(name).getAnnotation(annotation);
} catch (NoSuchFieldException e) {
return null;
}
}

}

2.AspectUtils工具类

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.reflect.MethodSignature;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;

/**
* @author wuhx 22020-05-15 09:23
*/
public class AspectUtils {

/**
* 获取织入点所在的方法
*
* @param point 织入点
* @return 方法
*/
public static Method getMethod(ProceedingJoinPoint point) {
Signature signature = point.getSignature();
MethodSignature methodSignature = (MethodSignature) signature;
return methodSignature.getMethod();
}

/**
* 获取织入点所在的类
*
* @param point 织入点
* @return 类
*/
public static Class getClass(ProceedingJoinPoint point) {
return getMethod(point).getDeclaringClass();
}

/**
* 获取执行织入点上的注解
*
* @param point      执行织入点
* @param annotation 注解的class
* @return 返回注解实现对象, 如果没有, 则返回null
*/
public static <T extends Annotation> T getAnnotation(ProceedingJoinPoint point, Class<T> annotation) {
return AnnotationUtils.getAnnotation(getMethod(point), annotation);
}

/**
* 获取执行方法的类上的注解,如果方法上拥有相同注解,则以方法上的为准,
*
* @param point      执行织入点
* @param annotation 注解的class
* @return 返回注解实现对象, 优先返回方法上的,  如果没有, 返回类上的 ,如果没有 则返回null
*/
public static <T extends Annotation> T getClassAnnotation(ProceedingJoinPoint point, Class<T> annotation) {
Method method = getMethod(point);
Class aClass = method.getDeclaringClass();

T t = AnnotationUtils.getAnnotation(method, annotation);
// 如果方法上没有相同注解,则返回类上的注解
if (t == null) {
return AnnotationUtils.getClassAnnotation(aClass, annotation);
}
return t;
}
}

3.自定义注解

/**
* @author wuhx  2020-05-12 14:12:19
*/
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface TokenApp {
// 是否校验token 默认true 进行token校验
boolean value() default true;
}

4.定义拦截

/**
* @author wuhx  2020-05-12 15:04:42
*/
@Aspect
@Order
@ControllerAdvice
public class TokenAppAspect {

private final Audience audience;
private final HttpServletRequest request;
public TokenAppAspect(Audience audience,HttpServletRequest request) {
this.audience = audience;
this.request = request;
}

@Pointcut("@annotation(zhiyan.applets.base.annotation.TokenApp) || @within(zhiyan.applets.base.annotation.TokenApp)")
public void pointcut(){}

@Around("pointcut()")
public Object filter(ProceedingJoinPoint point) throws Throwable{
return check(point, AspectUtils.getClassAnnotation(point, TokenApp.class));
}

private Object check(ProceedingJoinPoint point, TokenApp tokenApp) throws Throwable{
if (tokenApp != null && tokenApp.value()){
String token = request.getHeader("token");
//token为空
if (StrUtil.isEmpty(token) || "null".equals(token)){
return HttpResult.error("token为空");
}
if (JwtTokenUtil.isExpiration(token,audience.getBase64Secret())){
return HttpResult.error("token过期");
}
}
return point.proceed();
}

}

下面，来看我们的Controller
只要在方法上加上@TokenAPP注解，那么这个方法就会进行校验。如果整个controller里面的方法都需要进行token校验，那么只要在类上 加上@TokenAPP注解即可。