基于SpringBoot和Redis实现Token权限认证

一时失言乱红尘 2022-03-25 08:24 394阅读 0赞

## 一、引言 ##

登陆权限控制是每个系统都应必备的功能，实现方法也有好多种。下面使用Token认证来实现系统的权限访问。

功能描述：  
用户登录成功后，后台返回一个token给调用者，同时自定义一个@AuthToken注解，被该注解标注的API请求都需要进行token效验，效验通过才可以正常访问，实现接口级的鉴权控制。同时token具有生命周期，在用户持续一段时间不进行操作的话，token则会过期，用户一直操作的话，则不会过期。

## 二、环境 ##

SpringBoot
    Redis（Docke中镜像）
    MySQL（Docker中镜像）

## 三、流程分析 ##

###### 1、流程分析 ######

（1）、客户端登录，输入用户名和密码，后台进行验证，如果验证失败则返回登录失败的提示。如果验证成功，则生成 token 然后将 username 和 token 双向绑定 （可以根据 username 取出 token 也可以根据 token 取出username）存入redis，同时使用 token+username 作为key把当前时间戳也存入redis。并且给它们都设置过期时间。

（2）、每次请求接口都会走拦截器，如果该接口标注了@AuthToken注解，则要检查客户端传过来的Authorization字段，获取 token。由于 token 与 username 双向绑定，可以通过获取的 token 来尝试从 redis 中获取 username，如果可以获取则说明 token 正确，反之，说明错误，返回鉴权失败。

（3）、token可以根据用户使用的情况来动态的调整自己过期时间。在生成 token 的同时也往 redis 里面存入了创建 token 时的时间戳，每次请求被拦截器拦截 token 验证成功之后，将当前时间与存在 redis 里面的 token 生成时刻的时间戳进行比较，当当前时间的距离创建时间快要到达设置的redis过期时间的话，就重新设置token过期时间，将过期时间延长。如果用户在设置的 redis 过期时间的时间长度内没有进行任何操作（没有发请求），则token会在redis中过期。

## 四、具体代码实现 ##

###### 1、自定义注解 ######

@Target({ ElementType.METHOD, ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface AuthToken { 
    
    }

###### 2、登陆控制器 ######

@RestController
    public class welcome { 
    
        Logger logger = LoggerFactory.getLogger(welcome.class);
    
        @Autowired
        Md5TokenGenerator tokenGenerator;
    
        @Autowired
        UserMapper userMapper;
    
        @GetMapping("/welcome")
        public String welcome(){ 
    
            return "welcome token authentication";
        }
    
        @RequestMapping(value = "/login", method = RequestMethod.GET)
        public ResponseTemplate login(String username, String password) { 
    
            logger.info("username:"+username+" password:"+password);
            User user = userMapper.getUser(username,password);
            logger.info("user:"+user);
    
            JSONObject result = new JSONObject();
            if (user != null) { 
    
                Jedis jedis = new Jedis("192.168.1.106", 6379);
                String token = tokenGenerator.generate(username, password);
                jedis.set(username, token);
                //设置key生存时间，当key过期时，它会被自动删除，时间是秒
                jedis.expire(username, ConstantKit.TOKEN_EXPIRE_TIME);
                jedis.set(token, username);
                jedis.expire(token, ConstantKit.TOKEN_EXPIRE_TIME);
                Long currentTime = System.currentTimeMillis();
                jedis.set(token + username, currentTime.toString());
    
                //用完关闭
                jedis.close();
    
                result.put("status", "登录成功");
                result.put("token", token);
            } else { 
                result.put("status", "登录失败");
            }
    
            return ResponseTemplate.builder()
                    .code(200)
                    .message("登录成功")
                    .data(result)
                    .build();
    
        }
    
    	//测试权限访问
        @RequestMapping(value = "test", method = RequestMethod.GET)
        @AuthToken
        public ResponseTemplate test() { 
    
            logger.info("已进入test路径");
    
            return ResponseTemplate.builder()
                    .code(200)
                    .message("Success")
                    .data("test url")
                    .build();
        }
    
    }

###### 3、拦截器 ######

@Slf4j
    public class AuthorizationInterceptor implements HandlerInterceptor { 
    
        //存放鉴权信息的Header名称，默认是Authorization
        private String httpHeaderName = "Authorization";
    
        //鉴权失败后返回的错误信息，默认为401 unauthorized
        private String unauthorizedErrorMessage = "401 unauthorized";
    
        //鉴权失败后返回的HTTP错误码，默认为401
        private int unauthorizedErrorCode = HttpServletResponse.SC_UNAUTHORIZED;
    
    	//存放登录用户模型Key的Request Key
        public static final String REQUEST_CURRENT_KEY = "REQUEST_CURRENT_KEY";
    
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { 
            if (!(handler instanceof HandlerMethod)) { 
                return true;
            }
            HandlerMethod handlerMethod = (HandlerMethod) handler;
            Method method = handlerMethod.getMethod();
    
            // 如果打上了AuthToken注解则需要验证token
            if (method.getAnnotation(AuthToken.class) != null || handlerMethod.getBeanType().getAnnotation(AuthToken.class) != null) { 
    
                String token = request.getParameter(httpHeaderName);
                log.info("Get token from request is {} ", token);
                String username = "";
                Jedis jedis = new Jedis("192.168.1.106", 6379);
                if (token != null && token.length() != 0) { 
                    username = jedis.get(token);
                    log.info("Get username from Redis is {}", username);
                }
                if (username != null && !username.trim().equals("")) { 
                    Long tokeBirthTime = Long.valueOf(jedis.get(token + username));
                    log.info("token Birth time is: {}", tokeBirthTime);
                    Long diff = System.currentTimeMillis() - tokeBirthTime;
                    log.info("token is exist : {} ms", diff);
                    if (diff > ConstantKit.TOKEN_RESET_TIME) { 
                        jedis.expire(username, ConstantKit.TOKEN_EXPIRE_TIME);
                        jedis.expire(token, ConstantKit.TOKEN_EXPIRE_TIME);
                        log.info("Reset expire time success!");
                        Long newBirthTime = System.currentTimeMillis();
                        jedis.set(token + username, newBirthTime.toString());
                    }
    
                    //用完关闭
                    jedis.close();
                    request.setAttribute(REQUEST_CURRENT_KEY, username);
                    return true;
                } else { 
                    JSONObject jsonObject = new JSONObject();
    
                    PrintWriter out = null;
                    try { 
                        response.setStatus(unauthorizedErrorCode);
                        response.setContentType(MediaType.APPLICATION_JSON_VALUE);
    
                        jsonObject.put("code", ((HttpServletResponse) response).getStatus());
                        jsonObject.put("message", HttpStatus.UNAUTHORIZED);
                        out = response.getWriter();
                        out.println(jsonObject);
    
                        return false;
                    } catch (Exception e) { 
                        e.printStackTrace();
                    } finally { 
                        if (null != out) { 
                            out.flush();
                            out.close();
                        }
                    }
    
                }
    
            }
    
            request.setAttribute(REQUEST_CURRENT_KEY, null);
    
            return true;
        }
    
        @Override
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception { 
    
        }
    
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception { 
    
        }
    }

###### 4、测试结果 ######

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 1]

## 五、小结 ##

登陆权限控制，实际上利用的就是拦截器的拦截功能。因为每一次请求都要通过拦截器，只有拦截器验证通过了，才能访问想要的请求路径，所以在拦截器中做校验Token校验。想要代码，可以去GitHub上查看。

[https://github.com/Hofanking/token-authentication.git][https_github.com_Hofanking_token-authentication.git]

拦截器介绍，可以参考：

[https://blog.csdn.net/zxd1435513775/article/details/80556034][https_blog.csdn.net_zxd1435513775_article_details_80556034]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70]: /images/20220325/6330a2e19d0a46fdabe3501ba34a4ab6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 1]: /images/20220325/94e8bf3c9b9145f5a91ad968836c2c85.png
[https_github.com_Hofanking_token-authentication.git]: https://github.com/Hofanking/token-authentication.git
[https_blog.csdn.net_zxd1435513775_article_details_80556034]: https://blog.csdn.net/zxd1435513775/article/details/80556034