SpringBoot整合AOP + 自定义注解实现简单的权限验证

1、简介

主要通过自定义注解，使用SpringAOP的环绕通知拦截请求，判断该方法是否有自定义注解，然后判断该用户是否有该权限，这里做的比较简单。

2、项目搭建

这里是基于SpringBoot的，对于SpringBoot项目的搭建就不说了。在项目中添加AOP的依赖：

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

3、自定义注解

package com.jianghu.aop.permission;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 自定义注解：在方法上添加该注释，说明该方法需要管理员权限才能访问
 * @Author: dj
 * @Date: 2019/7/20 19:05
 * @Version 1.0
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Permission {
    String authorities() default "ADMIN";
}

在方法上添加该注解，说明该方法需要该权限才能访问。

解析返回注解的值：

package com.jianghu.aop.permission;

import java.lang.reflect.Method;

/**
 * 解析类：通过AOP获取方法上的注解，判断是否有Permission注解，返回注解的值
 * @Author: dj
 * @Date: 2019/7/20 19:08
 * @Version 1.0
 */
public class AnnotationParse {

    /**
     * 解析权限注解
     * @param method
     * @return 返回注解的权限值
     */
    public static String privilegeParse(Method method) {
        //获取该方法
        if (method.isAnnotationPresent(Permission.class)) {
            Permission annotation = method.getAnnotation(Permission.class);
            return annotation.authorities();
        }
        return null;
    }

}

通过AOP的通知获取方法上的注解，判断是否有注解，返回注解的值。

4、SpringAOP通知：

package com.jianghu.aop.permission;

import org.apache.commons.lang3.StringUtils;
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 javax.annotation.Resource;
import javax.security.auth.login.LoginException;
import java.lang.reflect.Method;

/**
 * @Author: dj
 * @Date: 2019/7/20 19:25
 * @Version 1.0
 */
@Aspect
@Component
public class ControllerAspect {

    private static final Logger logger = LoggerFactory.getLogger(ControllerAspect.class);

    @Resource
    private UserService userService;

    /**
     * 定义切点
     */
    @Pointcut("execution(public * com.jianghu.aop.permission.*.*(..))")
    public void privilege() {}

    @Around("privilege()")
    public Object isAccessMethod(ProceedingJoinPoint proceedingJoinPoint)
        throws Throwable{
        //获取访问目标方法
        MethodSignature methodSignature = (MethodSignature) proceedingJoinPoint.getSignature();
        Method method = methodSignature.getMethod();
        //得到方法的访问权限
        String methodAccess = AnnotationParse.privilegeParse(method);
        //如果该方法上没有权限注解，直接调用目标方法
        if(StringUtils.isBlank(methodAccess )){
            return proceedingJoinPoint.proceed();
        }else {
            //获取当前用户的权限
            User currentUser = userService.getCurrentUser();
            logger.info("访问用户，{}",currentUser.toString());
            if(currentUser == null){
                throw new LoginException("未登录！");
            }
            if(methodAccess.equals(currentUser.getRole().toString())){
                return proceedingJoinPoint.proceed();
            }else {
                throw new Exception("权限不够！");
            }
        }
    }

}

5、使用

只需要在需要验证权限的方法上添加自定义注解即可。

 

可能你还在AOP太多的概念搞得晕头转向，下面这篇文章会消除你的疑惑，快点

彻底征服 Spring AOP 之 理论篇