基于SpringBoot2 - AOP - 实现鉴权 [管理员 | 前端 | 匿名用户]

设计RESTFUL API的接口权限鉴别问题，能处理的方式有很多种，你可以直接在controller中鉴权，在调用service以及其它代码，也可以使用interceptor配置哪部分用户能访问哪部分接口，也可以使用shiro以及Spring Security等框架来实现权限，最后还可以采用AOP的方式来实现。

以下描述可能不准，但通俗易懂

• AOP全称 Aspect Oriented Program,意思是面向切面变成。我来小小地解释一下：

  我们把一个对象考虑成一个棒棒馍，把馍馍切一刀，那么被切的这个地方我们叫切入点(馍馍上每一个可以被切的地方都叫做连接点)，这个刀面就叫做切面，切面嵌入了馍馍里面。馍馍里面有只蛆要从馍馍的一端到另一端，就要经过刀面，蛆在到达刀面时，想办法爬上刀，在通过刀(咬个洞钻过去)。

  对象中的代码执行分先后，对象执行过程中里面有方法执行，某一句代码执行等，他们都分顺序执行。这个时候如果有个方法要执行了，我们在这儿切一刀，那这块对象就被切烂了。

  可能描述的有问题，简而言之，我们在要插入其它代码的地方用注解标记一下，那么就可以通过AOP的一系列机制在此处插入一段代码了。详细看看代码就明白了。

那么问题来了！为什么要选择AOP呢？？

为什么不选择直接在controller中鉴权？

这一次项目接口爆发面积广，影响作用大，如果在每个controller中写大量类似的鉴权代码将会付出很大的代价，同样采用BaseController的方式把这部分代码抽出以降低复杂度仍然是一件比较麻烦的事情，因此该方案直接跳过。

为什么不选择interceptor呢？

这是之前做一个小练手项目时使用SpringBoot配置的拦截器：

interceptor写起来不算复杂，但是接口过多的时候，要添加好多没有权限的内容放行，这个配置类就会显得非常复杂。相对于AOP来说，AOP实现更加方便快捷。所以当跟AOP对比时我选择了AOP。

为什么不选择shiro和security？

框架一般为重型应用或者较为复杂的认证和权限场景提供解决方案，我的系统中只有管理员,前端,匿名三类角色，使用框架费时费力，相对比于框架，自己实现一个权限控制流程就更加简单了。

综合以上，AOP实现权限是一种更加便捷的方案。

以下就是使用AOP来实现权限的具体内容

功能介绍

前端请求后台时，需要判断是管理员还是普通用户还是匿名用户，后台是restful api，controller本身不作权限验证。在每一个controller方法前面添加一个注解，通过AOP来判断用户header中带过来的token字段是否存在，以及token在redis的session缓存中userId到底是管理员还是普通用户，来鉴别权利。

• 鉴权通过，则执行controller对应的方法并返回
• 鉴权失败，返回permission denied错误

东西介绍

• 首先利用注解在controller上注解一下，表示我将在此处插入一段权限鉴别代码，这段代码判断如果请求者没有权限，就不会执行被标记的这个方法直接返回给用户权限错误了。如图：

• 然后你得知道，这个注解是怎么实现的，里面有两个参数，一个表示是否开启鉴权，一个表示要执行controller中的方法你需要什么权限。

• 当然注解本身只能起标记的作用，不能有业务实现。业务实现需要由切面类来实现：

代码浮现：

权限枚举类

package xyz.ruankun.machinemother.util.constant;public enum  AuthAopConstant {    /**     * 管理员 普通用户 匿名者     */    ADMIN,    USER,    ANON}

用于在controller上标记的注解

其中pass字段说明该注解是否生效，role字段表名要执行被切的那个controller中的方法需要什么权限。

package xyz.ruankun.machinemother.annotation;import xyz.ruankun.machinemother.util.constant.AuthAopConstant;import java.lang.annotation.ElementType;import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;import java.lang.annotation.Target;@Target(value = ElementType.METHOD)@Retention(value = RetentionPolicy.RUNTIME)public @interface Authentication {    /**     *  true为启用验证     *  false为跳过验证     * @return     */    boolean pass() default true;    AuthAopConstant role() default AuthAopConstant.ANON;}

切面类

该类就是一个切面，里面定义了一个切入点，就是插入的这个面该从哪里开始执行，以及执行的逻辑等。权限代码看@Around标记的那个方法就行了

package xyz.ruankun.machinemother.aop;import org.aspectj.lang.JoinPoint;import org.aspectj.lang.ProceedingJoinPoint;import org.aspectj.lang.annotation.AfterReturning;import org.aspectj.lang.annotation.Around;import org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.annotation.Pointcut;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Component;import org.springframework.web.context.request.RequestContextHolder;import org.springframework.web.context.request.ServletRequestAttributes;import xyz.ruankun.machinemother.annotation.Authentication;import xyz.ruankun.machinemother.repository.AdminRepository;import xyz.ruankun.machinemother.repository.UserRepository;import xyz.ruankun.machinemother.service.AdminService;import xyz.ruankun.machinemother.service.UserInfoService;import xyz.ruankun.machinemother.util.Constant;import xyz.ruankun.machinemother.util.constant.AuthAopConstant;import xyz.ruankun.machinemother.vo.ResponseEntity;import javax.servlet.http.HttpServletRequest;/** * 使用aop完成API请求时的认证和权限 * made by Jason. Completed by mrruan */@Aspect@Componentpublic class AuthenticationAspect {    public final static Logger logger = LoggerFactory.getLogger(AuthenticationAspect.class);    @Autowired    private UserInfoService userInfoService;    @Autowired    private AdminService adminService;    //去数据库查询权限    @Autowired    AdminRepository adminRepository;    @Autowired    UserRepository userRepository;    @Pointcut(value = "@annotation(xyz.ruankun.machinemother.annotation.Authentication)")    public void pointcut() {}    /**     * 与被注释方法正确返回之后执行     * @param joinPoint 方法执行前的参数     * @param result 方法返回值 后续观察，是否保存     */    @AfterReturning(returning = "result", value = "@annotation(xyz.ruankun.machinemother.annotation.Authentication)")    public void after(JoinPoint joinPoint, Object result) {        logger.info("refreshing token");        Object[] args = joinPoint.getArgs();        for (Object arg : args) {            if (arg instanceof HttpServletRequest) {                HttpServletRequest request = (HttpServletRequest) arg;                String token = request.getParameter("token");                if (token != null) {                    //通过token获取id值更新token有效期                    int userId = Integer.valueOf(userInfoService.readDataFromRedis(token));                    String sessionKey = userInfoService.readDataFromRedis("session_key" + userId);                    if (null == sessionKey){                        //管理员是没有sessionkey的哟                        adminService.updateSession(String.valueOf(userId),token,15);                    }else                        userInfoService.updateSession(userId,sessionKey, token,15);                    logger.info("refreshed token");                }else{                    logger.info("not refreshed token");                }            }        }    }    @Around("pointcut() && @annotation(authentication)")    public  Object interceptor(ProceedingJoinPoint proceedingJoinPoint, Authentication authentication){        boolean pass = authentication.pass();        //要验证权限        AuthAopConstant role = authentication.role();        if(pass && role != AuthAopConstant.ANON){            //通过拿到的role,我们可以知道能处理这个请求的角色是什么            //如果是匿名者，直接放行，如果是用户，就需要用户的权限才行，管理员则需要管理员的角色才行            //规定一致，token放在header中            HttpServletRequest request = ((ServletRequestAttributes)RequestContextHolder                    .getRequestAttributes()).getRequest();            String token = request.getHeader("token");            AuthAopConstant realRole = authenticate(token);            if (realRole == role) {                //权限正确，去访问吧                try {                    return proceedingJoinPoint.proceed();                } catch (Throwable throwable) {                    throwable.printStackTrace();                    ResponseEntity responseEntity = new ResponseEntity();                    responseEntity.success(Constant.AOP_SERVER_ERROR, "", null);                    return responseEntity;                }            }else{                //权限错误，返回错误                ResponseEntity responseEntity = new ResponseEntity();                responseEntity.success(Constant.AUTH_ERROR, "permission denied,forbidden access", null);                return responseEntity;            }        }else{            //不验证权限            try {                return proceedingJoinPoint.proceed();            } catch (Throwable throwable) {                throwable.printStackTrace();                ResponseEntity responseEntity = new ResponseEntity();                responseEntity.success(Constant.AOP_SERVER_ERROR, "", null);                return responseEntity;            }        }    }    /**     * 这个方法用于判断该token所属的到底是谁(管理员？ 用户？ 匿名？)     * @param token     * @return     */    private AuthAopConstant authenticate(String token){        String userId = null;        try {            userId = userInfoService.readDataFromRedis(token);        } catch (Exception e) {            e.printStackTrace();            //读取userId错误(最大的可能是请求的header中没有token)，直接返回匿名错误            return  AuthAopConstant.ANON;        }        if(userId == null){            //匿名的或者说用户过期的，没有找到session            return AuthAopConstant.ANON;        }else{            Integer id;            try {                id = Integer.parseInt(userId);                logger.info("userId:" + id);            } catch (Exception e) {                e.printStackTrace();                //都抛出了异常了，这个userId是假的，直接匿名者                return AuthAopConstant.ANON;            }            if(adminRepository.findById(id).isPresent()){                //是管理员                return AuthAopConstant.ADMIN;            }else{                if (userRepository.findById(id).isPresent()){                    //是用户                    return AuthAopConstant.USER;                }else{                    //没有发现它是用户，假的                   return AuthAopConstant.ANON;                }            }        }    }}

controller长什么样

拦截了一下登录方法，用来测试的，起作用了。注意一下，我的逻辑中是把token放在header中了的。

/**     * 只有管理员能干     * @param img 图片文件     * @return 返回上传成功     */    @PutMapping("/template")    @Authentication(role = AuthAopConstant.ADMIN)    public ResponseEntity putOneTemplate(@RequestParam MultipartFile img){        ResponseEntity responseEntity = new ResponseEntity();        boolean rs = qrCodeService.putTemplate(img);        if (rs)            responseEntity.success(null);        else            responseEntity.serverError();        return  responseEntity;    }