java-jwt

最新推荐文章于 2024-05-06 17:43:05 发布
最新推荐文章于 2024-05-06 17:43:05 发布
阅读量974 收藏 4
点赞数 1
分类专栏： 分布式 文章标签： java http 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29799655/article/details/123979354
版权

目录

一. JWT 基础解释

  1. 先了解几个问题
  1. JSON数据使用base64url编码,只对JSON数据是先扁平化处理再用64个可读无冲突字符来表达,没有加密效果
  2. SHA256的摘要只是为JSON数据生成一个“指纹”,防止被篡改,属于完整性范畴,也无任何加密效果
  3. 摘要不等于签名,签名是用私钥加密摘要,默认情况下Token本身并没有任何加密机制,它依赖于HTTPS的通道保密能力,Token增加加密机制需要自行处理
  1. 在介绍JWT之前,我们可以先说一下实现用户验证发展的几个步骤
  1. 请求接口时使用http协议,http协议本身是一种无状态的协议,用户登录后,下次再次访问接口,无法判断用户身份,
  2. 进而提出了Cookie 与Session, cookie是存储在客户端的,如果被截获,可能会出现跨站请求伪造的攻击,session是存在服务端的,但是现在都基于微服务,需要考虑多服务节点情况下session同步问题
  3. 后续提出了基于token进行用户身份校验
  1. 简单说一下token进行用户身份验证的流程：
  1. 客户端使用用户名和密码请求登录, 服务端收到请求，验证用户名和密码
  2. 验证成功后,服务端会签发一个token,并将token返回给客户端
  3. 客户端收到token后,缓存token,后续向服务端发送请求时在header中携带服务端签发的token
  4. 服务端收到请求,先对客户端请求中携带的token进行验证
  5. 优点: cookie是无法跨域的,而token由于没有用到cookie(前提是将token放到请求头中)所以跨域后不会存在信息丢失问题,token机制在服务端不需要存储session信息,因为token自身包含了所有登录用户的信息,因此也就不需要session同步,更适用CDN：可以通过内容分发网络请求服务端的所有资料,更适用于移动端:因为移动端不支持cookie, 既然不使用cookie也就无需考虑CSRF
  1. JWT官网链接
  2. 什么是JWT: JWT是JSON Web Token的简称,就是上述流程当中token的一种具体实现方式,通俗地说,JWT的本质就是一个保存了用户信息的Json字符串,然后进行编码后得到一个JWT token,并且这个JWT token带有签名信息,接收后可以校验是否被篡改,所以可以用于在各方之间安全地将信息作为Json对象传输
  3. JWT用户认证执行流程
  1. 前端将用户信息发送给后端(建议通过SSL加密的传输(HTTPS)，从而避免敏感信息被嗅探)
  2. 后端核对用户名和密码成功后,将包含用户信息的数据作为JWT的Payload,将其与JWT Header分别进行Base64编码拼接后签名,形成一个JWT Token,例如lll.zzz.xxx的字符串
  3. 后端将Token字符串作为登录成功的结果返回给前端,前端在后续请求接口时将Token放入HTTP请求头中的Authorization属性中(解决XSS和XSRF问题),用户退出登录时删除保存的JWT Token
  4. 后端接收到前端请求后先校验Token是否有效,比如检查签名是否正确,是否过期,token的接收方是否是自己等等
  1. 说一下JWT的优点
  1. 简洁：JWT Token数据量小，传输速度也很快
  2. JWT是跨语言的: 因为JWT Token是以JSON加密形式保存在客户端的，所以，原则上任何web形式都支持
  3. 不依赖于cookie和session, 不需要在服务端保存会话信息,特别适用于分布式微服务
  4. 既然不依赖于cookie和session,可以将token缓存到redis等,就不需要考虑session多服务节点的同步问题,及cookie无法跨域的问题,更适用与单点登录, 移动端

二. JWT Token 组成

  1. 前面说过JWT的本质就是一个保存了用户信息的Json字符串,编码后得到的一个JWTtoken,这个JWTtoken带有签名信息,接收后可以校验是否被篡改,那么这个Toke是怎么生成的,组成部分有哪些
  2. JWT由3部分组成：Header标头,Payload有效载荷和Signature签名, 在传输的时候,将这3部分分别进行Base64编码后连接形成最终传输的字符串
JWTString=Base64(Header).Base64(Payload).HMACSHA256(base64UrlEncode(header)+"."+base64UrlEncode(payload),secret)
  1. JWT Header标头,是用来描述JWT元数据的JSON对象,包含alg属性与typ属性,其中alg表示签名使用的算法,默认为HMAC SHA256(写为HS256), typ属性表示令牌的类型,在JWT令牌统一写为JWT,然后使用Base64URL算法将上述这个JSON对象转换为字符串保存,例如
{
  "alg": "HS256",
  "typ": "JWT"
}
  1. Payload有效载荷,是JWT的主体内容部分,也是一个JSON对象,包含需要传递的数据,在JWT中默认有一下七个字段供选择, 这七个预定义字段并不要求强制使用,并且除以上默认字段外,我们还可以自定义私有字段,例如将包含用户信息的数据放到payload中

注意点: 默认情况下JWT只是采用base64算法进行了一次编码,并未加密的,拿到JWT字符串后可以转换回原本的JSON数据,因此不要构建隐私信息字段,比如用户的密码不要保存到JWT中,以防止信息泄露,默认情况下JWT只适合在网络中传输一些非敏感信息

//1.Payload有效载荷默认提供的七个预定义字段,不要求强制使用
iss：发行人
exp：到期时间
sub：主题
aud：用户
nbf：在此之前不可用
iat：发布时间
jti：JWT ID用于标识该JWT

//2.除了预定义的七个字段以外,我们也可以自定义Payload有效载荷字段,例如将包含用户信息的数据放到payload中
{
  "sub": "1234567890",
  "name": "Helen",
  "admin": true
}
  1. Signature签名,用来校验数据是否被篡改的,将base64UrlEncode编码后的header和payload两个数据进行拼接后,通过指定的算法与密钥secret进行加密后的一串哈码,并且secret密钥保存在服务器中不对外公开,默认加密算法HMACSHA256(),Signature签名生成公式示例

根据JWT Token中是否存在Signature签名又将JWT分为两类: 不使用Signature签名的JWT称为nonsecure JWT未经过签名,不安全的JWT,其header部分也没有指定签名算法, 使用了Signature签名的通过签名保证jwt不能被他人随意篡改,我们又称为JWS

HMACSHA256(base64UrlEncode(header)+"."+base64UrlEncode(payload),secret)
  1. 在生成Signature签名时提到了一个secret或secretKey密钥,JWT的密钥或者密钥对,一般统一称为JSON Web Key,也就是JWK,根据对称加密与非对称加密,密钥的使用也有所不同
  1. 对称加密中: secretKey指加密密钥,用来生成签名与验签
  2. 非对称加密中: secretKey指私钥,只用来生成签名,但是不能用来验签(验签用的是公钥)
  3. 对称加密中使用同一个密钥进行加密与解密,因此这时候公钥不能泄漏,因此对称算法只适合服务端内部使用,不适合网络第三方,非对称加密通常服务端有私钥和公钥,使用私钥加密,使用公钥可以解密,相对来说更安全
  1. JWT中签名算法有三种：
  1. HMAC【哈希消息验证码(对称)】：HS256/HS384/HS512
  2. RSASSA【RSA签名算法(非对称)】（RS256/RS384/RS512）
  3. ECDSA【椭圆曲线数据签名算法(非对称)】（ES256/ES384/ES512）
  1. 完整的执行逻辑
  1. 接收到JWT Token数据后,获取header和payload通过base64解码获取到原数据,在header的alg属性中拿到签名的算法,在payload中获取有效数据
  2. signature是对header和payload数据的加密无法解码出原文,用来校验整个token数据是否被篡改
  3. 服务端在header中获取到加密算法后,利用该算法加上secret密钥对header,payload两个数据再次进行加密,拿到加密结果后与客户端发送过来的signature进行比对判断是否一致,
  4. 注意secret密钥只保存在服务端,而且对于不同的加密算法其含义有所不同,对于MD5类型的摘要加密算法来说secret密钥代表的是盐值

三. Java 与 JWT

官网推荐了6个Java使用JWT的开源库,其中比较推荐使用的是java-jwt和jjwt-root

1. java-jwt

  1. 依赖
<dependency>
    <groupId>com.auth0</groupId>
    <artifactId>java-jwt</artifactId>
    <version>3.10.3</version>
</dependency>
  1. 生成JWT Token代码示例
public class JWTTest {
    @Test
    public void testGenerateToken(){
        // 指定token过期时间为10秒
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.SECOND, 10);

        String token = JWT.create()
                .withHeader(new HashMap<>())  // Header
                .withClaim("userId", 21)  // Payload
                .withClaim("userName", "baobao")
                .withExpiresAt(calendar.getTime())  // 过期时间
                .sign(Algorithm.HMAC256("!34ADAS"));  // 签名用的secret
        //注意执行多次生成的token字符串内容是不一样的,虽然payload信息没有变动,但是JWT中携带了超时时间不一样
        System.out.println(token);
    }
}
  1. 解析JWT Token 数据代码示例
@Test
public void testResolveToken(){
    // 创建解析对象，使用的算法和secret要与创建token时保持一致
    JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256("!34ADAS")).build();
    // 解析指定的token
    DecodedJWT decodedJWT = jwtVerifier.verify("JWT TOKEN 字符串easdfagasgXAi");
    // 获取解析后的token中的payload信息
    Claim userId = decodedJWT.getClaim("userId");
    Claim userName = decodedJWT.getClaim("userName");
    System.out.println(userId.asInt());
    System.out.println(userName.asString());
    //因为有超时时间,所以可能可能超时,输出超时时间
    System.out.println(decodedJWT.getExpiresAt());
}
  1. 非对称加密示例,生成jwt串的时候需要指定私钥，解析jwt串的时候需要指定公钥
//私钥
private static final String RSA_PRIVATE_KEY = "...";
//公钥
private static final String RSA_PUBLIC_KEY = "...";

/**
 * 生成token
 * @param payload token携带的信息
 * @return token字符串
 */
public static String getTokenRsa(Map<String,String> payload){
    // 指定token过期时间为7天
    Calendar calendar = Calendar.getInstance();
    calendar.add(Calendar.DATE, 7);

    JWTCreator.Builder builder = JWT.create();
    // 构建payload
    payload.forEach((k,v) -> builder.withClaim(k,v));

    // 利用hutool创建RSA
    RSA rsa = new RSA(RSA_PRIVATE_KEY, null);
    // 获取私钥
    RSAPrivateKey privateKey = (RSAPrivateKey) rsa.getPrivateKey();
    // 签名时传入私钥
    String token = builder.withExpiresAt(calendar.getTime()).sign(Algorithm.RSA256(null, privateKey));
    return token;
}

/**
 * 解析token
 * @param token token字符串
 * @return 解析后的token
 */
public static DecodedJWT decodeRsa(String token){
    // 利用hutool创建RSA
    RSA rsa = new RSA(null, RSA_PUBLIC_KEY);
    // 获取RSA公钥
    RSAPublicKey publicKey = (RSAPublicKey) rsa.getPublicKey();
    // 验签时传入公钥
    JWTVerifier jwtVerifier = JWT.require(Algorithm.RSA256(publicKey, null)).build();
    DecodedJWT decodedJWT = jwtVerifier.verify(token);
    return decodedJWT;
}

2. jjwt-root

  1. 依赖
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>
  1. 对称加密代码示例
public class JwtUtils {
    // token时效：24小时
    public static final long EXPIRE = 1000 * 60 * 60 * 24;
    // 签名哈希的密钥，对于不同的加密算法来说含义不同
    public static final String APP_SECRET = "ukc8BDbRigUDaY6pZFfWus2jZWLPHO";

    /**
     * 根据用户id和昵称生成token
     * @param id  用户id
     * @param nickname 用户昵称
     * @return JWT规则生成的token
     */
    public static String getJwtToken(String id, String nickname){
        String JwtToken = Jwts.builder()
                .setHeaderParam("typ", "JWT")
                .setHeaderParam("alg", "HS256")
                .setSubject("baobao-user")
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + EXPIRE))
                .claim("id", id)
                .claim("nickname", nickname)
            	// HS256算法实际上就是MD5加盐值，此时APP_SECRET就代表盐值
                .signWith(SignatureAlgorithm.HS256, APP_SECRET)
                .compact();

        return JwtToken;
    }

    /**
     * 判断token是否存在与有效
     * @param jwtToken token字符串
     * @return 如果token有效返回true，否则返回false
     */
    public static boolean checkToken(String jwtToken) {
        if(StringUtils.isEmpty(jwtToken)) return false;
        try {
            Jwts.parser().setSigningKey(APP_SECRET).parseClaimsJws(jwtToken);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    /**
     * 判断token是否存在与有效
     * @param request Http请求对象
     * @return 如果token有效返回true，否则返回false
     */
    public static boolean checkToken(HttpServletRequest request) {
        try {
            // 从http请求头中获取token字符串
            String jwtToken = request.getHeader("token");
            if(StringUtils.isEmpty(jwtToken)) return false;
            Jwts.parser().setSigningKey(APP_SECRET).parseClaimsJws(jwtToken);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    /**
     * 根据token获取会员id
     * @param request Http请求对象
     * @return 解析token后获得的用户id
     */
    public static String getMemberIdByJwtToken(HttpServletRequest request) {
        String jwtToken = request.getHeader("token");
        if(StringUtils.isEmpty(jwtToken)) return "";
        Jws<Claims> claimsJws = Jwts.parser().setSigningKey(APP_SECRET).parseClaimsJws(jwtToken);
        Claims claims = claimsJws.getBody();
        return (String)claims.get("id");
    }
}
  1. jjwt在0.10版本以后发生了较大变化,pom中需要多引入一下几个依赖
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-api</artifactId>
    <version>0.11.2</version>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-impl</artifactId>
    <version>0.11.2</version>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-jackson</artifactId> <!-- or jjwt-gson if Gson is preferred -->
    <version>0.11.2</version>
    <scope>runtime</scope>
</dependency>
  1. 并且在jjwt0.10版本之后对secretKey长度有强制要求,否则生成jws时会抛出异常,并且不同算法要求长度不同,如下
HS256：要求至少 256 bits (32 bytes)
HS384：要求至少384 bits (48 bytes)
HS512：要求至少512 bits (64 bytes)
RS256 and PS256：至少2048 bits
RS384 and PS384：至少3072 bits
RS512 and PS512：至少4096 bits
ES256：至少256 bits (32 bytes)
ES384：至少384 bits (48 bytes)
ES512：至少512 bits (64 bytes)
  1. 并且新版本的jjwt中密钥需要传入Key对象,而之前的签名和验签方法都传入密钥的字符串即可
public class JwtUtils {
    // token时效：24小时
    public static final long EXPIRE = 1000 * 60 * 60 * 24;
    // 签名哈希的密钥，对于不同的加密算法来说含义不同
    public static final String APP_SECRET = "ukc8BDbRigUDaY6pZFfWus2jZWLPHOsdadasdasfdssfeweee";

    /**
     * 根据用户id和昵称生成token
     * @param id  用户id
     * @param nickname 用户昵称
     * @return JWT规则生成的token
     */
    public static String getJwtToken(String id, String nickname){
        String JwtToken = Jwts.builder()
                .setSubject("baobao-user")
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + EXPIRE))
                .claim("id", id)
                .claim("nickname", nickname)
                // 传入Key对象
                .signWith(Keys.hmacShaKeyFor(APP_SECRET.getBytes(StandardCharsets.UTF_8)), SignatureAlgorithm.HS256)
                .compact();
        return JwtToken;
    }

    /**
     * 判断token是否存在与有效
     * @param jwtToken token字符串
     * @return 如果token有效返回true，否则返回false
     */
    public static Jws<Claims> decode(String jwtToken) {
        // 传入Key对象
        Jws<Claims> claimsJws = Jwts.parserBuilder()
						       .setSigningKey(Keys.hmacShaKeyFor(APP_SECRET.getBytes(StandardCharsets.UTF_8)))
						       .build()
						       .parseClaimsJws(jwtToken);
        return claimsJws;
    }
}
  1. 非对称加密代码示例, 生成jwt串的时候需要指定私钥，解析jwt串的时候需要指定公钥
private static final String RSA_PRIVATE_KEY = "...";
private static final String RSA_PUBLIC_KEY = "...";

/**
 * 根据用户id和昵称生成token
 * @param id  用户id
 * @param nickname 用户昵称
 * @return JWT规则生成的token
 */
public static String getJwtTokenRsa(String id, String nickname){
    // 利用hutool创建RSA
    RSA rsa = new RSA(RSA_PRIVATE_KEY, null);
    RSAPrivateKey privateKey = (RSAPrivateKey) rsa.getPrivateKey();
    String JwtToken = Jwts.builder()
        .setSubject("baobao-user")
        .setIssuedAt(new Date())
        .setExpiration(new Date(System.currentTimeMillis() + EXPIRE))
        .claim("id", id)
        .claim("nickname", nickname)
        // 签名指定私钥
        .signWith(privateKey, SignatureAlgorithm.RS256)
        .compact();
    return JwtToken;
}

/**
 * 判断token是否存在与有效
 * @param jwtToken token字符串
 * @return 如果token有效返回true，否则返回false
 */
public static Jws<Claims> decodeRsa(String jwtToken) {
    RSA rsa = new RSA(null, RSA_PUBLIC_KEY);
    RSAPublicKey publicKey = (RSAPublicKey) rsa.getPublicKey();
    // 验签指定公钥
    Jws<Claims> claimsJws = Jwts.parserBuilder().setSigningKey(publicKey).build().parseClaimsJws(jwtToken);
    return claimsJws;
}

三. 实际开发中 JWT 的使用

  1. 在实际的SpringBoot项目中,JWT用户登录流程：
  1. 在登录验证通过后,给用户生成一个对应的随机token(注意这个token不是指jwt,可以用uuid等算法生成),然后将这个token作为key的一部分,用户信息作为value存入Redis,并设置过期时间,这个过期时间就是登录失效的时间
  2. 将第1步中生成的随机token作为JWT的payload生成JWT字符串返回给前端
  3. 前端之后每次请求都在请求头中的Authorization字段中携带JWT字符串
  4. 后端定义一个拦截器,当拦截到前端请求时,先从请求头中的Authorization字段中取出JWT字符串并进行验证,验证通过后解析出payload中的随机token,然后再用这个随机token得到key,从Redis中获取用户信息,如果能获取到就说明用户已经登录
  1. 代码示例
public class JWTInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String JWT = request.getHeader("Authorization");
        try {
            // 1.校验JWT字符串
            DecodedJWT decodedJWT = JWTUtils.decode(JWT);
            // 2.取出JWT字符串载荷中的随机token，从Redis中获取用户信息
            ...
            return true;
        }catch (SignatureVerificationException e){
            System.out.println("无效签名");
            e.printStackTrace();
        }catch (TokenExpiredException e){
            System.out.println("token已经过期");
            e.printStackTrace();
        }catch (AlgorithmMismatchException e){
            System.out.println("算法不一致");
            e.printStackTrace();
        }catch (Exception e){
            System.out.println("token无效");
            e.printStackTrace();
        }
        return false;
    }
}
  1. 实际生产中还需要考虑的问题
  1. 因为JWT是在请求头中传递的,所以为了避免网络劫持,推荐使用HTTPS来传输，更加安全
  2. JWT的哈希签名的密钥是存放在服务端的,所以只要服务器不被攻破,理论上JWT是安全的,因此要保证服务器的安全
  3. JWT可以使用暴力穷举来破解,为了应对这种破解方式,可以定期更换服务端的哈希签名密钥(相当于盐值)
苹果香蕉西红柿
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Java JWT
XY02120624的博客
02-17 434
Java JWT 笔记
什么是JWT（JSON WEB TOKEN）
weixin_34280237的博客
11-18 271
转自于:http://www.jianshu.com/p/576dbf44b2ae 什么是JWT Json web token（JWT）是为了网络应用环境间传递声明而执行的一种基于JSON的开发标准（RFC 7519），该token被设计为紧凑且安全的，特别适用于分布式站点的单点登陆（SSO）场景。JWT的声明一般被用来在身份提供者和服务提供...
JAVA实现登录校验（JWT令牌实现）
最新发布
目前专注区块链相关技术的学习与分享
05-06 903
等。例如：{"id":"1","username":"Tom"}第三部分：Signature(签名），防止Token被篡改、确保安全性。将header、payload，并加入指定秘钥，通过指定签名算法计算而来。签名的目的就是为了防止jwt令牌被篡改，而正是因为jwt令牌最后一个部分数字签名的存在，所以整个jwt 令牌是非常安全可靠的。一旦jwt令牌当中任何一个部分、任何一个字符被篡改了，整个令牌在校验的时候都会失败，所以它是非常安全可靠的。
什么是JWT及在JAVA中如何使用？
一切总会归于平淡
10-24 3902
JSON Web token简称JWT， 是用于对应用程序上的用户进行身份验证的标记。 也就是说, 使用 JWTS 的应用程序不再需要保存有关其用户的 cookie 或其他session数据。 此特性便于可伸缩性, 同时保证应用程序的安全
Java课堂：什么是JWT?最全讲解
博哥哥的博客
02-06 829
什么是JWT
登录认证功能中的会话技术
m0_72167535的博客
04-08 344
如果用户没有登录，此时就不允许他执行相关的业务操作，直接给前端响应一个错误的结果，最终跳转到登录页面，要求他登录成功之后，再来访问对应的数据。输出的结果就是生成的JWT令牌,，通过英文的点分割对三个部分进行分割，我们可以将生成的令牌复制一下，然后打开JWT的官网，将生成的令牌直接放在Encoded位置，此时就会自动的将令牌解析出来。接下来，在后续的每次请求时，都会将Cookie的值，携带到服务端，那服务端呢，接收到Cookie之后，会自动的根据JSESSIONID的值，找到对应的会话对象Session。
java-jwt.jar
08-27
实现Java web token JWT所需的jar包，java-jwt.3.3.0.jar，可用于登录验证
java-jwt-3.8.1.jar
05-07
java-jwt-3.8.1.jar 包 下载
java-jwt-3.1.0.jar
04-28
java-jwt-3.1.0.jar
java-jwt-3.4.1.jar
02-25
java运行依赖jar包
java-jwt-3.11.0.jar
03-01
java-jwt-3.11.0.jar
java jwt 统一认证
11-08
包含jwt包和源码 jwt打包成工具 可以直接使用 加密解密方法 快捷开发
Java Web JWT 使用教程
moments的博客
05-17 625
通俗解释：JWT简称JSON Web Token，也就是通过JSON形式作为Web应用中的令牌,用于在各方之间安全地将信息作为JSON对象传输。在数据传输过程中还可以完成数据加密、签名等相关处理。
Jwt选型和实现
qq_45317823的博客
02-19 487
package com.zhjt.zhdataexchange.utils; import io.jsonwebtoken.*; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.stereotype.Component; import jav...
Java基础之《JWT使用》
csj50的专栏
11-07 3269
1、Json web token (JWT) 的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服务器获取资源。也可以增加一些额外的其他业务逻辑所必须的声明信息，该token也可直接被用于认证，也可被加密。传统的token，例如：用户登录成功生成对应的令牌，key为令牌，value为userid，隐藏了数据真实性，同时将该token存放到redis中，返回对应的真实令牌给客户端存放。4、为什么不再用session id。session缺点，集群无法共享。3、传统的token。
Java Token登录验证 使用jjwt生成和解析JWT
热门推荐
CSDN906214391的博客
08-07 1万+
刚学会了点使用Token凭证来验证登录，记录下来 参考 JSON Web Tokens官网 Libraries里有各种语言的推荐包 jjwt的Github网址 推荐里面star最多的，所以用了 jjwt官方 生成和解析的例子 前后端分离之JWT用户认证 对JWT有详细的介绍 Java安全验证之JWT实践 依赖 当时在maven仓库里找到的最新版 流程 登录成功后，在Java中生成Token...
JSON Web Token（JWT）基础概念详解（Java）
DevNinja的博客
09-10 286
JSON Web Token（JWT）是一种开放标准（RFC 7519），用于在不同实体之间安全传输信息。它由三个部分组成：头部（Header）、载荷（Payload）和签名（Signature）。其中，xxxxx代表Base64编码的头部，yyyyy代表Base64编码的载荷，zzzzz代表签名。
Java实战：实现JWT刷新令牌机制
oandy0的博客
02-25 1505
本文将详细介绍如何在Java应用程序中实现JWT刷新令牌机制。我们将探讨JWT刷新令牌的基本概念，以及如何使用Spring Boot和JWT库来实现认证和授权。
2024年Java实现JWT的Token认证机制，rocketmq原理解析
2401_84584391的博客
05-05 1044
小编精心为大家准备了一手资料以上Java高级架构资料、源码、笔记、视频。Dubbo、Redis、设计模式、Netty、zookeeper、Spring cloud、分布式、高并发等架构技术【附】架构书籍BAT面试的20道高频数据库问题解析Java面试宝典Netty实战算法BATJ面试要点及Java架构师进阶资料本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录需要这份系统化的资料的朋友，可以点击这里获取。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值