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

Bertha 。 2021-09-30 01:04 342阅读 0赞

1、简介

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

2、项目搭建

这里是基于SpringBoot的，对于SpringBoot项目的搭建就不说了。在项目中添加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 之 理论篇][Spring AOP _]

[Spring AOP _]: https://segmentfault.com/a/1190000007469968/