• SpringBoot+Redis 防止用户重复登录

    目录



    🍖 前言

    🍕 背景：

    这几天在做一个小项目，没有数据权限、菜单权限，所以呢就决定不使用权限验证框架了。登录呢，就直接用redis存储登录的用户信息就行了。

    🍔 实现及存在问题：

    一开始的实现思路大概就是：调用登录接口，校验用户名和密码是否正确，如果正确的话，直接生成一个随机字符串作为token，返回会给前端，同时用这个token作为redis中的key，value则存储的是当前登录的用户信息。然后在拦截器中，直接根据请求头中携带的token去redis找这个key，存在则放行，不存在则提示用户未登录。


    存在问题：我以为这样是没有问题的，结果后面去redis一看，十几个key，点开一看全是同一个用户的，我直接好家伙🤣。

    🍟 解决思路：

    一个用户同时不能有多个token，它们是一对一的关系。目前想到了三种解决方式。其中方式一完全不推荐，方式二、三自己看更喜欢哪一个。

    🌭 方式一：（弃用，完全不推荐）

    以用户名作为redis的key，用户信息作为value（用户信息里面有token），在登录的时候，用户名密码验证通过，不用做其他处理，直接存就行。然后在拦截器中，需要遍历全部的redis中全部的用户名key，拿到它们的token去和请求头里的token进行匹配，能匹配到说明用户登录还没过期，则放行；没有匹配到说明token（登录）失效了，需要重新登录，则提示用户未登录。

    🍿 方式二：（推荐使用）

    用户名和token分别为key：用户名key的value是用户信息（用户信息里面有token）；token key的value是用户名。

    登录时用户名密码验证通过后，先根据要登录的用户名去redis查找这个key是否存在，存在说明已经登录了，在已登录的信息里面找到token，把旧的用户名和token都给删除掉，然后再保存新的登录信息到redis中（随机生成一个新的token，设置到用户信息中，然后redis分别以用户名和新token作为key，存储登录信息）。


    拦截器中：

    	请求头的token在redis中存在
		获取对应的用户名，判断这个用户名是否存在，存在则放行；不存在则提示用户未登录，同时把redis中的这个token给删掉。
		
	请求头的token在redis中不存在
		提示用户未登录。

    • 1
    • 2
    • 3
    • 4
    • 5

    🥣 方式三：（2022.11.18更新，推荐使用）

    以token为key，其中token组成为：用户名加密字符串 + 随机32为字符串。这个方法是最简单的，不需要在拦截器做额外处理。

    登录时用户名密码验证通过后，将用户名进行加密（采用摘要算法进行加密，我这里选择的是MD5加密），加密后通过redisUtil模糊匹配该加密字符串的所有key，获取到这些key后，将它们都删除掉，然后生成一个新的token，新token的组成就是前面加密字符串+随机32位字符串。就这简单三个步骤，就可以实现防重复登录，拦截器中，就正常判断请求头携带的token在redis中是否存在就行，不用说还要在拦截器中进行什么额外处理，是不是非常简单ヾ(•ω•`)o

    如果是有多个终端的，那也没问题啊，一般多个终端，生成的token都会加个前缀吧，用这个前缀区分是哪个终端的登录。so，token的组成就变成了：终端前缀 + 用户名加密字符串 + 随机32为字符串。实现方式和前面的完全一样，就是多加了个前缀而已（＾∀＾●）ﾉｼ

    🍞 代码实现

    🌭 方式一：

    主要的逻辑在拦截器里：

    /**
 * 登录拦截器
 */
public class LoginInterceptor implements HandlerInterceptor {

    private boolean result(HttpServletResponse response) throws IOException {
        ResultVo resultVo = new ResultVo();
        resultVo.setCode(1003);
        resultVo.setMessage("用户未登录，请进行登录");
        response.getWriter().write(JSONUtil.toJsonStr(resultVo));
        return false;
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)throws Exception {
        response.setHeader("Access-Control-Allow-Origin", (request).getHeader("Origin"));
        response.setHeader("Access-Control-Allow-Credentials", "true");
        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/json");
        // 获取请求头中的token
        String token = request.getHeader(BaseConstant.tokenHeader);
        RedisUtil redisUtil= SpringUtil.getBean(RedisUtil.class);
        SysUser sysUser = null;
        // 根据缓存前缀，获取所有以改前缀开头的键（缓存前缀是自定义的）
        Set set = redisUtil.allKey(BaseConstant.cachePrefix + "*");
        for (Object o : set) {
            Object o1 = redisUtil.get(o.toString());
            if (o1 instanceof SysUser){
                SysUser user = (SysUser) o1;
                // 用户信息中的token和请求头中的token进行匹配
                if (token.equals(user.getToken())){
                    sysUser = user;
                    break;
                }
            }
        }
        // sysUser为null，说明没匹配成功，提示未登录；否则说明两个token匹配成功，用户已登录，放行。
        if (Objects.isNull(sysUser)){
            return result(response);
        }
        // 获取当前用户的登录有效期，如果不是 -1，则每次请求时，刷新它的有效期
        long expire = redisUtil.getExpire(BaseConstant.cachePrefix + sysUser.getUserName());
        if (expire != -1){
            redisUtil.set(BaseConstant.cachePrefix+sysUser.getUserName(),sysUser,1800);
        }
        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 {
    }

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57

    RedisUtil 就不写全了，可以去网上找一大把，或者点我以前的文章都有的，在这里补充一个方法，就是获取某个文件夹下的所有的key，也就是拦截器里面用到的缓存前缀，这个可以自定义，我的缓存前缀格式是：**项目名称-token:login:** ，这里后面拼接的就是用户名了。比如：**项目名称-token:login:admin** 
    /**
 * redis工具类
 */
@Component
public class RedisUtil {

    @Resource
    private RedisTemplate redisTemplate;

	// ......省略其他方法
	
	/**
     * 获取某个文件夹下的所有的key
     * @param obj 文件夹名称（缓存前缀+*）
     */
    public <T> Set<T> allKey(Object obj){
        return redisTemplate.keys(obj);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    登录controller 
    @RestController
@RequestMapping("/sys/login")
public class SysLoginController {

	@PostMapping("/webLogin")
    public ResultVo webLogin(String userName, String password, HttpServletRequest request){
        try {
        	// 这里校验用户名和密码是否正确，用户名或者密码错误，都会直接抛出异常（ExceptionVo 是我自定义的一个异常）
            SysUser user = check(userName, password);
            // 随机生成一个32位的token字符串
            String token = IdUtil.generateToken(32);
            user.setToken(token);
            // 将用户登录信息保存到redis中
            redisUtil.set(BaseConstant.cachePrefix+userName,user,1800);
            return ResultUtil.success(token);
        } catch (ExceptionVo e) {
            return ResultUtil.error(e.getCode(),e.getMessage());
        }catch (Exception e) {
            e.printStackTrace();
            return ResultUtil.error(BaseConstant.UNKNOWN_EXCEPTION);
        }
    }
}


public class IdUtil {
    /**
     * 根据指定长度随机生成字符串
     */
    public static String generateToken(int length) {
        String str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        Random random = new Random();
        StringBuffer sb = new StringBuffer();
        for(int i = 0; i < length; ++i) {
            int number = random.nextInt(62);
            sb.append(str.charAt(number));
        }
        return sb.toString();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40

    🍿 方式二：

    拦截器：

    /**
 * 登录拦截器
 */
public class LoginInterceptor implements HandlerInterceptor {

    private boolean result(HttpServletResponse response) throws IOException {
        ResultVo resultVo = new ResultVo();
        resultVo.setCode(1003);
        resultVo.setMessage("用户未登录，请进行登录");
        response.getWriter().write(JSONUtil.toJsonStr(resultVo));
        return false;
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)throws Exception {
        response.setHeader("Access-Control-Allow-Origin", (request).getHeader("Origin"));
        response.setHeader("Access-Control-Allow-Credentials", "true");
        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/json");
        // 获取请求头中的token
        String token = request.getHeader(BaseConstant.tokenHeader);
        RedisUtil redisUtil= SpringUtil.getBean(RedisUtil.class);
        String userName = "";
        // 判断token在redis中是否存在，不存在提示未登录
        if (StrUtil.isEmpty(token) || Objects.isNull(redisUtil.get(BaseConstant.cachePrefix+token))){
            return result(response);
        }else if (Objects.nonNull(redisUtil.get(BaseConstant.cachePrefix+token))){
        	// token在redis中存在，获取它的value，也就是这个token对应的用户名
            userName = redisUtil.get(BaseConstant.cachePrefix + token).toString();
            // 判断 用户名在redis中是否存在，不存在提示未登录，并且把这个token从redis中删除
            if (Objects.isNull(redisUtil.get(BaseConstant.cachePrefix+userName))){
                redisUtil.del(BaseConstant.cachePrefix+token);
                return result(response);
            }
        }
        // 用户名在redis中存在，获取它的过期时间，不是 -1则刷新过期时间
        long expire = redisUtil.getExpire(BaseConstant.cachePrefix + userName);
        if (expire != -1){
            SysUser user = (SysUser) redisUtil.get(BaseConstant.cachePrefix+userName);
            // 用户名key 存储用户信息
            redisUtil.set(BaseConstant.cachePrefix+userName,user,1800);
            // token key 存储用户名，这里token key比用户名 key设置的有效期长一点
            redisUtil.set(BaseConstant.cachePrefix+token,userName,2100);
        }
        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 {
    }

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56

    登录controller

    @RestController
@RequestMapping("/sys/login")
public class SysLoginController {

	@PostMapping("/webLogin")
    public ResultVo webLogin(String userName, String password, HttpServletRequest request){
        try {
        	// 这里校验用户名和密码是否正确，用户名或者密码错误，都会直接抛出异常（ExceptionVo 是我自定义的一个异常）
            SysUser user = check(userName, password);
            // 判断当前用户名是否已登录，如果登录了则把旧的用户名和token删除
	        if (redisUtil.hasKey(BaseConstant.cachePrefix+userName)) {
	            SysUser u = (SysUser) redisUtil.get(BaseConstant.cachePrefix + userName);
	            redisUtil.del(BaseConstant.cachePrefix + u.getToken());
	            redisUtil.del(BaseConstant.cachePrefix + userName);
	        }
            // 随机生成一个32位的token字符串
            String token = IdUtil.generateToken(32);
            user.setToken(token);
            // 分别用用户名和token作为key，存储对应信息到redis中
            redisUtil.set(BaseConstant.cachePrefix+userName,user,1800);
            redisUtil.set(BaseConstant.cachePrefix+token,userName,2100);
            return ResultUtil.success(token);
        } catch (ExceptionVo e) {
            return ResultUtil.error(e.getCode(),e.getMessage());
        }catch (Exception e) {
            e.printStackTrace();
            return ResultUtil.error(BaseConstant.UNKNOWN_EXCEPTION);
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    🥣 方式三：

    拦截器：

    import cn.hutool.core.util.StrUtil;
import cn.hutool.extra.spring.SpringUtil;
import cn.hutool.json.JSONUtil;
import com.common.base.BaseConstant;
import com.common.util.RedisUtil;
import com.common.util.ResultUtil;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Objects;

/**
 * 登录拦截器
 */
public class LoginInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)throws Exception {
        response.setHeader("Access-Control-Allow-Origin", (request).getHeader("Origin"));
        response.setHeader("Access-Control-Allow-Credentials", "true");
        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/json");
        String token = request.getHeader(BaseConstant.tokenHeader);
        RedisUtil redisUtil= SpringUtil.getBean(RedisUtil.class);
        if (StrUtil.isEmpty(token) || Objects.isNull(redisUtil.get(BaseConstant.cachePrefix+token))){
            response.getWriter().write(JSONUtil.toJsonStr(ResultUtil.error(1003,"用户未登录，请进行登录")));
            return false;
        }
        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 {
    }

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42

    登录controller

    @RestController
@RequestMapping("/sys/login")
public class SysLoginController {

	@PostMapping("/webLogin")
    public ResultVo webLogin(String userName, String password, HttpServletRequest request){
        try {
        	// 这里校验用户名和密码是否正确，用户名或者密码错误，都会直接抛出异常（ExceptionVo 是我自定义的一个异常）
            SysUser user = check(userName, password);
            String str = DigestUtil.md5Hex(userName); // userName加密
	        //获取所有包含当前用户名加密后的字符串开头的key
	        Set<String> sets = redisUtil.allKey(BaseConstant.cachePrefix + str + "*");
	        for (String key : sets) {
	            redisUtil.del(key); // 将旧的key删除
	        }
            String token = str + IdUtil.generateToken(32); // token组成为：用户名加密字符串 + 随机32为字符串
            user.setToken(token);
            redisUtil.set(BaseConstant.cachePrefix+token,user,1800);
            return ResultUtil.success(token);
        } catch (ExceptionVo e) {
            return ResultUtil.error(e.getCode(),e.getMessage());
        }catch (Exception e) {
            e.printStackTrace();
            return ResultUtil.error(BaseConstant.UNKNOWN_EXCEPTION);
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27

    🧀 最后

    以上三种方法，自行选择，我自己后面选择的是第二、三种方式。说起第一种方式，我记得好像 shiro 里防止用户重复登录也是要自己处理的，然后我用的时候，大概也是在缓存中获取所有session，然后遍历匹配当前登录用户，如果能匹配到就删除上一次的登录信息。不过那个是在登录的时候处理的。

    像第一种方式，因为是以用户名为key存储的，不能直接用token取值，所以我只能想到遍历所有用户名key去匹配🤣不然的话难道要在请求头中设置除了携带token外，把用户名也带上吗？这不太合理吧？😂因为每次请求都要遍历redis中的所有用户名，感觉不太行，所以我采取的是第二、三种方式。

  • 相关阅读:
    启动spark-shell时报错java.lang.NumberFormatException: For input string: “0x100“
    Patroin源码修改八：初始化Opengauss
    allatori8.0文档翻译-第七步：多个jar文件不混淆加水印
    【脑机接口开源数据处理包】brainflowBrainFlow是一个库，旨在获取，解析和分析脑电图，肌电图，心电图和其他类型的数据从生物传感器。
    模拟京东快递单号查询 练习
    ARM64下构建 UEFI 模块
    离线数仓（6）：数仓理论之维度模型分类
    今天又做了三个梦，其中一个梦梦里的我还有意识会思考？
    js:运用JavaScript写一个倒计时模版
    select多路IO复用
  • 原文地址：https://blog.csdn.net/weixin_43165220/article/details/126619266