基于SpringBoot和Redis实现Token权限认证 & 基于redis实现token验证用户是否登陆

最新推荐文章于 2024-07-26 12:28:02 发布

陈三千

最新推荐文章于 2024-07-26 12:28:02 发布

阅读量2.1k

点赞数 3

分类专栏： SpringBoot 解决方案文章标签： java redis

原文链接：https://blog.csdn.net/zxd1435513775/article/details/86555130

版权

解决方案同时被 2 个专栏收录

14 篇文章 1 订阅

订阅专栏

SpringBoot

2 篇文章 0 订阅

订阅专栏

1

一、引言

登陆权限控制是每个系统都应必备的功能，实现方法也有好多种。下面使用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、测试结果
在这里插入图片描述

五、小结

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

2

基于项目需求，我们要实现一个基于redis实现token登录验证，该如何实现呢？

后端实现：

1.引入redis相关的依赖

<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
 <groupId>org.springframework.session</groupId>
 <artifactId>spring-session-data-redis</artifactId>
 <version>2.0.5.RELEASE</version>
</dependency>

2.Controller层生成token信息并存入redis中

//若用户登录验证成功后将对应的登陆信息和登陆凭证一起存入redis中
//生成登陆凭证token UUID
String uuidToken= UUID.randomUUID().toString();
uuidToken=uuidToken.replace("-","");
 
//将token和用户登录态之间建立联系
redisTemplate.opsForValue().set(uuidToken,userModel);
redisTemplate.expire(uuidToken,1, TimeUnit.HOURS);
 
// 下发token
return CommonReturnType.create(uuidToken);

3.需要验证的登陆的地方调用即可

 String token = httpServletRequest.getParameterMap().get("token")[0];
 if (StringUtils.isEmpty(token)) {
 throw new BusinessException(EmBusinessError.USER_NOT_LOGIN, "用户还未登陆,不能下单");
 }
 //获取用户的登陆信息
 UserModel userModel= (UserModel) redisTemplate.opsForValue().get(token);
 if(userModel==null){
 throw new BusinessException(EmBusinessError.USER_NOT_LOGIN, "用户还未登陆,不能下单");
 }
 
 OrderModel orderModel = orderService.creatOrder(userModel.getId(), itemId, promoId, amount);
 return CommonReturnType.create(null);

前端实现

**1.从返回值中取出token并存入localstorage

if(data.status == "success") {
 alert("登陆成功");
 //取出token放入localstorage
 var token = data.data;
 window.localStorage["token"] = token;
 window.location.href = "listitem.html";
}

2.验证用户是否登陆

var token = window.localStorage["token"];
 if(token == null){
 alert("没有登录，不能下单");
 window.location.href="login.html" rel="external nofollow" ;
 return false;
 }

3.当然，需要把token传入后端再校验一次

url:"http://"+g_host+"/order/createorder?token="+token,

3

在userserviceimpl引用springboot自带的StringRedisTemplate

@Autowired
private StringRedisTemplate stringRedisTemplate;

在userserviceimpl中通过usermapper查询到用户名和密码等用户信息后

如果user != null ,把user实体类转换成json格式，redis是key/value格式，保证数据唯一性，所以key用uuid做key，user做value，确保唯一性

插入到redis后要在获取key的话要用到cookie了，把key存到cookie中，取的时候在cookie中取

//把user实体类转化成json格式
String userJoin = JSON.toJSONString(user);
    if (user != null) {
        //获取uuid
        String uuid = UUIDUtils.getUUID();
        //创建cookie
        Cookie cookie = new Cookie("userCookie", uuid);
        response.addCookie(cookie);
        //把用户信息存入redis  set（key，value，过期时长，过期格式） 设置三天过期
        stringRedisTemplate.opsForValue().set("user" + "/" + uuid, userJoin, 3, TimeUnit.DAYS);
 
        return Msg.ok("");
    } else {
 
        return Msg.failure("用户名或密码错误");
 
    }

然后在usercontroller获取的时候

@RequestMapping(value = "/toMainPage")
    public ModelAndView toMainPage(HttpServletRequest request, HttpServletResponse response) {
        ModelAndView mv;
        String struuid = null;
                //获取cookie里面的uuid
        Cookie[] cookies = request.getCookies();
        for (Cookie cookie : cookies) {
            if (cookie.getName().equalsIgnoreCase("userCookie")) {
                struuid = cookie.getValue();
            }
        }
 
        if (struuid == null) {
            System.out.println("验证不通过");
 
            System.out.println("UUID不存在");
 
        }
 
        String userJson;
        try {
                        //根据struuid，在redis中获取user信息    userJson = stringRedisTemplate.opsForValue().get("user" + "/" + struuid);
            JSONObject pa = JSONObject.parseObject(userJson);
            if ("管理员".equals(pa.getString("uRank")) && userJson != null) {
                mv = new ModelAndView("index");
                mv.addObject("user", pa.getString("uName"));
                mv.addObject("id", pa.getString("id"));
                mv.addObject("uPwd", pa.getString("uPwd"));
                 
 
            } else if ("普通用户".equals(pa.getString("uRank")) && userJson != null) {
                mv = new ModelAndView("pt_index");
                mv.addObject("user", pa.getString("uName"));
                mv.addObject("id", pa.getString("id"));
                mv.addObject("uPwd", pa.getString("uPwd"));
 
            } else {
                mv = new ModelAndView("redirect:login");
            }
 
        } catch (Exception e) {
            // TODO Auto-generated catch block
            mv = new ModelAndView("redirect:login");
        }
        return mv;
    }

转自该链接1
转自该链接2
转自该链接3

陈三千

关注

3
点赞
踩
17

收藏

觉得还不错? 一键收藏
0
评论
基于SpringBoot和Redis实现Token权限认证 & 基于redis实现token验证用户是否登陆

1一、引言登陆权限控制是每个系统都应必备的功能，实现方法也有好多种。下面使用Token认证来实现系统的权限访问。功能描述：用户登录成功后，后台返回一个token给调用者，同时自定义一个@AuthToken注解，被该注解标注的API请求都需要进行token效验，效验通过才可以正常访问，实现接口级的鉴权控制。同时token具有生命周期，在用户持续一段时间不进行操作的话，token则会过期，用户一直操作的话，则不会过期。二、环境SpringBoot、Redis（Docke中镜像）、MySQL（Doc
复制链接

扫一扫