IT俱乐部 Redis jwt+redis实现登录认证的示例代码

jwt+redis实现登录认证的示例代码

发布: 2024年 4月 11日 496阅读

项目环境：spring boot项目

pom.xml引入jwt和redis

1
com.auth0java-jwt4.3.0org.springframework.bootspring-boot-starter-data-redis

application.yml配置文件中，对redis进行配置

1
2
3
4
data:
  redis:
    port: 6379
    host: localhost

JwtUtil工具类

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
package com.utils;
 
import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
 
import java.util.Date;
import java.util.Map;
 
public class JwtUtil {
 
    /*生成jwt字符串时用到的秘钥*/
    private static final String KEY = "itheima";
 
    //接收业务数据,生成token并返回
    public static String genToken(Map claims) {
        return JWT.create()
                .withClaim("claims", claims)
                .withExpiresAt(new Date(System.currentTimeMillis() + 1000 * 60 * 60 * 24 )) //失效时间 单位毫秒 当前值为1天
                .sign(Algorithm.HMAC256(KEY));
    }
 
    //接收token,验证token,并返回业务数据
    public static Map parseToken(String token) {
        return JWT.require(Algorithm.HMAC256(KEY))
                .build()
                .verify(token)
                .getClaim("claims")
                .asMap();
    }
 
}

Md5Util工具类（因为登录时有对密码进行md5加密的逻辑） 

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
58
59
60
61
62
63
64
65
package com.utils;
 
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
 
public class Md5Util {
    /**
     * 默认的密码字符串组合，用来将字节转换成 16 进制表示的字符,apache校验下载的文件的正确性用的就是默认的这个组合
     */
    protected static char hexDigits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
 
    protected static MessageDigest messagedigest = null;
 
    static {
        try {
            messagedigest = MessageDigest.getInstance("MD5");
        } catch (NoSuchAlgorithmException nsaex) {
            System.err.println(Md5Util.class.getName() + "初始化失败，MessageDigest不支持MD5Util。");
            nsaex.printStackTrace();
        }
    }
 
    /**
     * 生成字符串的md5校验值
     *
     * @param s
     * @return
     */
    public static String getMD5String(String s) {
        return getMD5String(s.getBytes());
    }
 
    /**
     * 判断字符串的md5校验码是否与一个已知的md5码相匹配
     *
     * @param password  要校验的字符串
     * @param md5PwdStr 已知的md5校验码
     * @return
     */
    public static boolean checkPassword(String password, String md5PwdStr) {
        String s = getMD5String(password);
        return s.equals(md5PwdStr);
    }
 
 
    public static String getMD5String(byte[] bytes) {
        messagedigest.update(bytes);
        return bufferToHex(messagedigest.digest());
    }
 
    private static String bufferToHex(byte bytes[]) {
        return bufferToHex(bytes, 0, bytes.length);
    }
 
    private static String bufferToHex(byte bytes[], int m, int n) {
        StringBuffer stringbuffer = new StringBuffer(2 * n);
        int k = m + n;
        for (int l = m; l > 4];// 取字节中高 4 位的数字转换, >>>
        // 为逻辑右移，将符号位一起右移,此处未发现两种符号有何不同
        char c1 = hexDigits[bt & 0xf];// 取字节中低 4 位的数字转换
        stringbuffer.append(c0);
        stringbuffer.append(c1);
    }
 
}

登录的控制器

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
package com.controller;
 
import com.pojo.Result;
import com.pojo.User;
import com.service.UserService;
import com.utils.JwtUtil;
import com.utils.Md5Util;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
 
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
 
@RestController
@RequestMapping("/user")
@Validated
@CrossOrigin
public class UserController1 {
    @Autowired
    private UserService userService;
 
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
 
 
    @PostMapping("/login")
    public Result login(String username, String password) {
        //查询用户
        String md5Password = Md5Util.getMD5String(password);
        User user = userService.login(username, md5Password);
        if (user == null) {//用户名或密码错误
            return Result.error("用户名或密码错误");
        } else {
            //登录成功
            Map claims = new HashMap();
            claims.put("id", user.getId());
            claims.put("username", user.getUsername());
            String jwtToken = JwtUtil.genToken(claims);
 
            //往Redis中存储一个键值对
            ValueOperations operations = stringRedisTemplate.opsForValue();
            operations.set(jwtToken, jwtToken, 1, TimeUnit.DAYS);
 
            return Result.success(jwtToken);
        }
    }
 
}

在前端发起登录请求，用户名和密码验证通过后，生成jwt，把jwt字符长的值，存放在redis缓存中，然后把jwt字符串返回到前端。

前端拿到jwt字符串后存在一个变量中，在之后的每次请求中，都在请求头中携带上jwt，后端再根据jwt的内容进行验证，判断是否是已登录的正常请求，如果是已经登录后的请求，就放行，否则就返回401（未认证）。

后端是通过声明一个拦截器，对请求进行判断的，代码如下：

LoginInterceptor.java

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
58
59
60
61
62
63
64
65
66
67
68
package com.interceptor;
import com.utils.JwtUtil;
import com.utils.ThreadLocalUtil;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
 
import java.util.List;
import java.util.Map;
 
/**
 * @projectName: big-event
 * @package: com.interceptor
 * @className: LoginInterceptor
 * @author: liangmeng
 * @description: 登录拦截器
 * @date: 2024/1/14 17:20
 * @version: 1.0
 */
 
@Component
public class LoginInterceptor implements HandlerInterceptor {
 
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
 
    //Controller方法处理之前执行
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //获取到请求头的jwt字符串
        String token = request.getHeader("Authorization");
        //验证token
        try {
            //获取redis的值
            ValueOperations operations = stringRedisTemplate.opsForValue();
            String redisToken = operations.get(token);
            if (redisToken == null) {
                //token失效 拦截请求
                throw new RuntimeException();
            } else {
                Map claims = JwtUtil.parseToken(token);
 
                //把业务数据存储到ThreadLocal中
                ThreadLocalUtil.set(claims);
 
                //放行请求
                return true;
            }
        } catch (Exception e) {
            //相应码401
            response.setStatus(401);
            //拦截请求
            return false;
        }
    }
 
    //该方法将在整个请求完成之后执行
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        //清空ThreadLocal中的信息 防止内存泄漏
        ThreadLocalUtil.remove();
    }
 
}

上面代码是自定义的登录拦截器，在请求到来后，控制器方法执行前，会进入到拦截器的preHandle方法中，在这个方法里面，或获取到请求头中的Authorization属性值，也就是jwt的值，然后再获取到redis中的值，redis中key和values是相同的，都是jwt字符串的内容，所以这里是用jwt的值作为key去获取value，如果value有值则说明该请求是可以放行的（已经登录过），否则拦截请求，返回响应码401。

afterCompletion方法是在整个请求完成之后执行，示例中是把ThreadLocal的值清空，这里根据需要，如果使用到了ThreadLocal，就把它清空，防止内存泄漏，如果没有使用到，则不需要处理。

拦截器定义好了之后，还需要把自定义的拦截器注册到全局拦截器中，使其生效。

WebConfig.java

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
package com.config;
 
import com.interceptor.CorsInterceptor;
import com.interceptor.LoginInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
 
 
 
@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Autowired
    private LoginInterceptor loginInterceptor;
 
    @Autowired
    private CorsInterceptor corsInterceptor;
 
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
 
        //把自定义的拦截器注册到全局拦截器中 排除登录和注册请求
        registry.addInterceptor(loginInterceptor).excludePathPatterns("/user/login","/user/register");
    }
}

同步把登录和注册接口的请求放行，不需要拦截。

修改密码的接口处理逻辑，当用户修改密码后，需要主动将jwt做失效操作，下面是控制器的代码：

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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
package com.controller;
 
import com.pojo.Result;
import com.pojo.User;
import com.service.UserService;
import com.utils.Md5Util;
import com.utils.ThreadLocalUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.util.StringUtils;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
 
import java.util.Map;
 
@RestController
@RequestMapping("/user")
@Validated
@CrossOrigin
public class UserController {
    @Autowired
    private UserService userService;
 
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
     
    //更新用户密码
    @PatchMapping("/updatePwd")
    public Result updatePwd(@RequestBody Map params, @RequestHeader("Authorization") String jwtToken) {
        String oldPwd = params.get("oldPwd");
        String newPwd = params.get("newPwd");
        String reNewPwd = params.get("reNewPwd");
        if (!StringUtils.hasLength(oldPwd) || !StringUtils.hasLength(newPwd) || !StringUtils.hasLength(reNewPwd)) {
            return Result.error("缺少必要的参数");
        }
 
        //判断原始密码是否正确
        //获取用户名
        Map claims = ThreadLocalUtil.get();
        String username = (String) claims.get("username");
        //根据用户名查询用户
        User user = userService.findByUserName(username);
        String currPwd = user.getPassword();
 
        String oldPwdMd5 = Md5Util.getMD5String(oldPwd);
        if (!oldPwdMd5.equals(currPwd)) {
            return Result.error("原始密码不正确");
        }
 
        //判断输入的两次密码是否一致
        if (!newPwd.equals(reNewPwd)) {
            return Result.error("两次密码不一致");
        }
 
        //更新密码
        //获取用户名
        String userId = (String) claims.get("id");
        String newPwdMd5 = Md5Util.getMD5String(newPwd);
 
        userService.updatePwd(userId, newPwdMd5);
 
        //密码更新完毕，删除redis中的缓存jwtToken值，让用户重新登陆
        ValueOperations operations = stringRedisTemplate.opsForValue();
        operations.getOperations().delete(jwtToken);
 
        return Result.success();
    }
 
 
}

在密码修改完毕后，根据请求头中的Authorization属性值来删除redis中存储的数据。这样原来的jwt就失效了，无法使用原来的jwt进行登录认证。

总结：因为http请求是无状态请求，使用jwt可以解决这一问题，登录成功后，在一段时间内就可以直接向后端发送请求，这样不需要重复进行登录操作。

因为jwt数据在后端没有进行存储，所以会出现一个问题，无法使其失效。这时候就引入了redis缓存，在redis缓存中将jwt的数据存下来，当用户修改密码、或退出登录后，将缓存的数据删除，然后在请求处理时（拦截器中）判断当前jwt是否有效，有效则正常处理请求，否则拦截请求，从而完成请求的权限控制。

一般项目还会使用sessionID作为请求控制的方式，其逻辑如下图所示：

到此这篇关于jwt+redis实现登录认证的示例代码的文章就介绍到这了,更多相关jwt redis登录认证内容请搜索IT俱乐部以前的文章或继续浏览下面的相关文章希望大家以后多多支持IT俱乐部！ 

本文收集自网络，不代表IT俱乐部立场，转载请注明出处。https://www.2it.club/database/redis/10578.html
109赞
标签:
上一篇
下一篇

相关推荐

联系我们

联系我们

在线咨询: QQ交谈

邮箱: 1120393934@qq.com

工作时间：周一至周五，9:00-17:30，节假日休息

关注微信
微信扫一扫关注我们

微信扫一扫关注我们

返回顶部