菜鸟的JWT学习总结

最新推荐文章于 2024-07-23 22:22:28 发布
最新推荐文章于 2024-07-23 22:22:28 发布
阅读量1k 收藏 4
点赞数
分类专栏： java 文章标签： jwt spring boot java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40298902/article/details/108078199
版权

菜鸟的JWT学习总结

说明

更新时间：2020/8/19 11:09，更新了JWT相关内容

本文主要对JWT的学习总结，本文会持续更新，不断地扩充

本文仅为记录学习轨迹，如有侵权,联系删除

一、什么是JWT

JWT全称是JSON Web Token，是目前最流行的跨域认证解决方案，常用于web项目的token校验，用户校验，权限校验等，也可以用于信息的加密传输。

基于session的认证方式
传统的认证方式也就是我们最常用的基于session的认证方式，用户向服务器发送用户名和密码，服务器经过验证后，将数据保存在session里面，并且向用户返回一个sessionid，存入客户端的cookie中，之后的每次访问都会将sessionid通过cookie传给服务器，用来比对服务器存放的session，以此达到用户的身份认证。
在这里插入图片描述

基于JWT的认证方式
这种方式简单来说就是，客户端向服务器发送用户名和密码，服务器经过验证之后，生成一个Token令牌，该令牌主要由3部分组成，里面包含用户信息和签名等数据，之后客户端每次发送请求就需要将该Token发送给服务器端，通过校验签名的方式，实现用户数据的认证。
在这里插入图片描述

两种方式对比

  1. session是保存在服务端的，随着用户认证的数量增多，服务器的压力会越来越大，而jwt是保存在客户端的，不会对服务器造成影响。
  2. 应用程序分布式部署的情况下，session需要做多机数据共享，通常可以存在数据库或者redis里面。而jwt不需要。

二、JWT的组成

主要组成又3部分，Header（头部）、Payload（负载）和Signature（签名）由这3部分组成，类似于Header.Payload.Signature这样的形式，里面就包含了需要的用户信息（建议非敏感信息），一个实际的例子如下:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ

（1）Header

Header 部分是一个 JSON 对象，描述 JWT 的元数据，通常是下面的样子。

{
  "alg": "HS256",//alg属性表示签名的算法（algorithm），默认是 HMAC SHA256（写成 HS256）
  "typ": "JWT"typ属性表示这个令牌（token）的类型（type），JWT 令牌统一写为JWT。
}
注意：

Header 主要由令牌和所使用的签名算法组成，它会使用Base64编码将Header进行编码后形成一串字符串，组成JWT的头部。

（2）Payload

Payload 部分也是一个 JSON 对象，用来存放实际需要传递的数据。JWT 规定了7个官方字段，供选用。

iss (issuer)：签发人
exp (expiration time)：过期时间
sub (subject)：主题
aud (audience)：受众
nbf (Not Before)：生效时间
iat (Issued At)：签发时间
jti (JWT ID)：编号

除此之外，还可以用来存放自定义的用户信息，比如用户名，用户id等自己需要的信息。不i过一般不建议存放像密码这类敏感信息，容易造成安全问题。

userId:"123",
userName:"灰太狼",
age:"12"

它最后也会经过Base64编码形成一串字符串，组成JWT的负载。

（3）Signature

Signature 部分是对前两部分的签名，防止数据篡改。前面两个部分都是使用Base64进行编码的，前端可以解开知道里面的信息，Signature 需要使用编码后的header和payload以及我们提供的一个密钥，使用header中指定的签名算法进行签名，用来保证JWT没有被篡改过，注意，里面用到的密钥是绝对保密的，只能服务器端这边自己知道，防止信息泄露。

签名的目的：当客户端携带token（JWT）向服务器发送请求时，里面携带由上面说的3部分数据，服务器接收到数据后，先进行签名的校验，即将客户端发送的token的前两个部分（header和payload）用header中指定的签名算法加上密钥进行签名，然后将生成的签名和客户端发送的token第三部分（签名）进行比对，如果一致则签名校验通过，信息没有被修改。

三、JJWT

JJWT全称是Java JWT，适用于Java和Android的JSON Web令牌，JJWT旨在成为最容易使用和理解的库，用于在JVM和Android上创建和验证JSON Web令牌（JWT）。JJWT是纯Java实现，完全基于JWT， JWS，JWE， JWK和JWA RFC规范以及Apache 2.0许可条款下的开源。

相关地址
JWT官网： https://jwt.io/
JJWT github: https://github.com/jwtk/jjwt#features-unsupported

在平时的使用中可以通过JJWT来进行JWT的相关操作。

基本使用
引入依赖

        <!--JJWT-->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt-api</artifactId>
            <version>0.10.7</version>
        </dependency>
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt-impl</artifactId>
            <version>0.10.7</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt-jackson</artifactId>
            <version>0.10.7</version>
            <scope>runtime</scope>
        </dependency>

这里在网上找了一个工具类JwtUtil

package com.zsc.utils;

import io.jsonwebtoken.*;
import io.jsonwebtoken.security.Keys;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.tomcat.util.codec.binary.Base64;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import javax.crypto.SecretKey;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

@Slf4j
@RequiredArgsConstructor
@SuppressWarnings("WeakerAccess")
@Component
@Data
@AllArgsConstructor
public class JwtUtil {
    /**
     * 秘钥
     * - 默认aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqqrrrsssttt
     * - 长度必须大于128位
     */
    @Value("${jwt.secret:aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqqrrrsssttt}")
    private String secret;
    /**
     * 有效期，单位秒
     * - 默认2周
     */
    @Value("${jwt.expire-time-in-second:1209600}")
    private Long expirationTimeInSecond;

    /**
     * 从token中获取claim
     *
     * @param token token
     * @return claim
     */
    public Claims getClaimsFromToken(String token) {
        try {
            return Jwts.parser()
                    .setSigningKey(this.secret.getBytes())
                    .parseClaimsJws(token)
                    .getBody();
        } catch (ExpiredJwtException | UnsupportedJwtException | MalformedJwtException | IllegalArgumentException e) {
            log.error("token解析错误", e);
            throw new IllegalArgumentException("Token invalided.");
        }
    }

    /**
     * 获取token的过期时间
     *
     * @param token token
     * @return 过期时间
     */
    public Date getExpirationDateFromToken(String token) {
        return getClaimsFromToken(token)
                .getExpiration();
    }

    /**
     * 判断token是否过期
     *
     * @param token token
     * @return 已过期返回true，未过期返回false
     */
    private Boolean isTokenExpired(String token) {
        Date expiration = getExpirationDateFromToken(token);
        return expiration.before(new Date());
    }

    /**
     * 计算token的过期时间
     *
     * @return 过期时间
     */
    private Date getExpirationTime() {
        return new Date(System.currentTimeMillis() + this.expirationTimeInSecond * 1000);
    }

    /**
     * 为指定用户生成token
     *
     * @param claims 用户信息
     * @return token
     */
    public String generateToken(Map<String, Object> claims) {
        Date createdTime = new Date();
        Date expirationTime = this.getExpirationTime();


        byte[] keyBytes = secret.getBytes();
        SecretKey key = Keys.hmacShaKeyFor(keyBytes);

        System.out.println("key="+key.toString());
        return Jwts.builder()
                .setClaims(claims)//payload
                .setIssuedAt(createdTime)
                .setExpiration(expirationTime)//过期时间
                // 你也可以改用你喜欢的算法
                // 支持的算法详见：https://github.com/jwtk/jjwt#features
                .signWith(key, SignatureAlgorithm.HS256)//header
                .compact();
    }

    /**
     * 判断token是否非法
     *
     * @param token token
     * @return 未过期返回true，否则返回false
     */
    public Boolean validateToken(String token) {
        return !isTokenExpired(token);
    }

}

对于该工具类可以用配置文件的方式配置密钥和过期时间，如果不配置则用默认的密钥和过期时间，配置如下

jwt:
  secret: aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqqrrrs1232134214
  # 有效期，单位秒
  expire-time-in-second: 60

使用的时候将该类直接注入即可

    @Autowired
    private JwtUtil jwtUtil;
	......

测试案例

package com.zsc.utils;

import io.jsonwebtoken.Claims;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.awt.desktop.ScreenSleepEvent;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

/**
 * @ClassName : JwtUtilTest
 * @Description : JWT工具类测试
 * @Author : CJH
 * @Date: 2020-08-18 17:06
 */
@Slf4j
@SpringBootTest
public class JwtUtilTest {

    @Autowired
    private JwtUtil jwtUtil;


    //生成Token
    public String generateTokenTest(){
        Map<String,Object> map = new HashMap<>();
        map.put("userId",123);
        map.put("userName","灰太狼");
        map.put("admin",true);

        String token = jwtUtil.generateToken(map);


        return token;
    }

    //获取Token
    @Test
    public void getClaimsFromTokenTest(){
        String token = generateTokenTest();
        log.info("token=[{}]",token);

        try {
            Thread.sleep(30000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        Claims claims = jwtUtil.getClaimsFromToken(token);




        Object userId = claims.get("userId");
        Object userName = claims.get("userName");
        Object admin = claims.get("admin");

        log.info("userId = [{}],userName = [{}],admin = [{}]",userId,userName,admin);
    }

    //获取token过期时间
    @Test
    public void getExpirationDateFromTokenTest(){
        String token = generateTokenTest();
        Date expirationDateFromToken = jwtUtil.getExpirationDateFromToken(token);
        log.info("token过期时间=[{}]",expirationDateFromToken);
    }

    //判断token是否非法
    @Test
    public void isTokenExpiredTest(){
        String token = generateTokenTest();
        Boolean aBoolean = jwtUtil.validateToken(token);
        log.info("token是否非法=[{}]",aBoolean);
    }
}

四、登录接口实战

为了规范化，这里将登录接口实战集成进我的api_demo2项目里面，集成的方式跟上面的JJWT里面的一样，先添加依赖，引入工具类，配置号密钥和过期时间。

依赖

        <!--JJWT-->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt-api</artifactId>
            <version>0.10.7</version>
        </dependency>
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt-impl</artifactId>
            <version>0.10.7</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt-jackson</artifactId>
            <version>0.10.7</version>
            <scope>runtime</scope>
        </dependency>

配置

jwt:
  secret: aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqqrrrs1232134214
  # 有效期，单位秒
  expire-time-in-second: 60

引入工具类

package com.zsc.utils;

import io.jsonwebtoken.*;
import io.jsonwebtoken.security.Keys;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import javax.crypto.SecretKey;
import java.util.Date;
import java.util.Map;

@Slf4j
@RequiredArgsConstructor
@SuppressWarnings("WeakerAccess")
@Component
@Data
@AllArgsConstructor
public class JwtUtil {
    /**
     * 秘钥
     * - 默认aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqqrrrsssttt
     * - 长度必须大于128位
     */
    @Value("${jwt.secret:aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqqrrrsssttt}")
    private String secret;
    /**
     * 有效期，单位秒
     * - 默认2周
     */
    @Value("${jwt.expire-time-in-second:1209600}")
    private Long expirationTimeInSecond;

    /**
     * 从token中获取claim
     *
     * @param token token
     * @return claim
     */
    public Claims getClaimsFromToken(String token) {
        return Jwts.parser()
                .setSigningKey(this.secret.getBytes())
                .parseClaimsJws(token)
                .getBody();
//        try {
//            return Jwts.parser()
//                    .setSigningKey(this.secret.getBytes())
//                    .parseClaimsJws(token)
//                    .getBody();
//        } catch (ExpiredJwtException | UnsupportedJwtException | MalformedJwtException | IllegalArgumentException e) {
//            log.error("token解析错误", e);
//            throw new IllegalArgumentException("Token invalided.");
//        }
    }

    /**
     * 获取token的过期时间
     *
     * @param token token
     * @return 过期时间
     */
    public Date getExpirationDateFromToken(String token) {
        return getClaimsFromToken(token)
                .getExpiration();
    }

    /**
     * 判断token是否过期
     *
     * @param token token
     * @return 已过期返回true，未过期返回false
     */
    private Boolean isTokenExpired(String token) {
        Date expiration = getExpirationDateFromToken(token);
        return expiration.before(new Date());
    }

    /**
     * 计算token的过期时间
     *
     * @return 过期时间
     */
    private Date getExpirationTime() {
        return new Date(System.currentTimeMillis() + this.expirationTimeInSecond * 1000);
    }

    /**
     * 为指定用户生成token
     *
     * @param claims 用户信息
     * @return token
     */
    public String generateToken(Map<String, Object> claims) {
        Date createdTime = new Date();
        Date expirationTime = this.getExpirationTime();


        byte[] keyBytes = secret.getBytes();
        SecretKey key = Keys.hmacShaKeyFor(keyBytes);

        System.out.println("key=" + key.toString());
        return Jwts.builder()
                .setClaims(claims)//payload
                .setIssuedAt(createdTime)
                .setExpiration(expirationTime)//过期时间
                // 你也可以改用你喜欢的算法
                // 支持的算法详见：https://github.com/jwtk/jjwt#features
                .signWith(key, SignatureAlgorithm.HS256)//header
                .compact();
    }

    /**
     * 判断token是否非法
     *
     * @param token token
     * @return 未过期返回true，否则返回false
     */
    public Boolean validateToken(String token) {
        return !isTokenExpired(token);
    }

}

创建JWT的拦截器JwtInterceptor

package com.zsc.interceptor;

import com.zsc.enums.ResultCode;
import com.zsc.exception.BusinessException;
import com.zsc.utils.JwtUtil;
import io.jsonwebtoken.ExpiredJwtException;
import io.jsonwebtoken.MalformedJwtException;
import io.jsonwebtoken.UnsupportedJwtException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * @ClassName : JwtInterceptor
 * @Description : Jwt拦截器
 * @Author : CJH
 * @Date: 2020-08-18 22:01
 */
@Slf4j
@Component
public class JwtInterceptor implements HandlerInterceptor {

    @Autowired
    private JwtUtil jwtUtil;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        /**
         * 注意，token一般存放在请求头中，所以发起请求时，请求头必须携带有token,字段名为token
         */
        String token = request.getHeader("token");

        try{
            Boolean tokenResult= jwtUtil.validateToken(token);
            if (tokenResult){
                return true;
            }else {
                log.error("token无效");
                throw new BusinessException(ResultCode.TOKEN_INVALID);
            }

        }catch (ExpiredJwtException e){
            log.error("token异常：[{}]",e.getMessage());
            throw new BusinessException(ResultCode.TOKEN_EXPIRED);

        }catch (MalformedJwtException e){
            log.error("token异常：[{}]",e.getMessage());
            throw new BusinessException(ResultCode.TOKEN_FORMAT_ERROR);

        }catch (UnsupportedJwtException e){
            log.error("token异常：[{}]",e.getMessage());
            throw new BusinessException(3011,e.getMessage());

        }catch (IllegalArgumentException e){
            log.error("token异常：[{}]",e.getMessage());
            throw new BusinessException(ResultCode.TOKEN_IS_EMPTY);
        }
    }
}

在自定义的web配置类中添加拦截器

package com.zsc.config;

import com.zsc.interceptor.JwtInterceptor;
import com.zsc.interceptor.RateLimitInterceptor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import javax.annotation.Resource;

/**
 * @ClassName : WebConfig
 * @Description : web配置类
 * @Author : CJH
 * @Date: 2020-08-17 21:35
 */
@Configuration
@EnableWebMvc
@Slf4j
public class WebConfig implements WebMvcConfigurer {

    /**
     * 全局限流拦截器
     */
    @Resource
    private RateLimitInterceptor rateLimitInterceptor;

    /**
     * jwt拦截器
     */
    @Autowired
    private JwtInterceptor jwtInterceptor;

    /**
     * 向web中添加拦截器
     * @param registry
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //限流拦截器
        registry.addInterceptor(rateLimitInterceptor)
                .addPathPatterns("/api/**");

        //JWT拦截器
        registry.addInterceptor(jwtInterceptor)
                .addPathPatterns("/api/**")
                .excludePathPatterns("/api/users/**");
    }

    /**
     * 静态资源配置
     * @param registry
     */
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        /**
         * 资源映射到本地目录
         */
        registry.addResourceHandler("/uploads/**")
                .addResourceLocations("file:F:\\Git\\GitRepository\\java\\java_springboot\\api_demo2\\uploads\\");
    }
}

登录接口


    @PostMapping("/login")
    public ResponseResult login(@RequestBody UserQueryDto userQueryDto){
        //构成查询参数
        PageQuery<UserQueryDto> userDtoPageQuery = new PageQuery<>();
        userDtoPageQuery.setPageIndex(1);
        userDtoPageQuery.setPageSize(10);
        userDtoPageQuery.setQuery(userQueryDto);

        //查询
        PageResult<List<UserDto>> result = userServer.query(userDtoPageQuery);

        if(!result.getData().isEmpty()){
            UserDto userDto = result.getData().get(0);

            Map<String,Object> map = new HashMap<>();
            map.put("name",userDto.getName());
            map.put("age",userDto.getAge());
            map.put("email",userDto.getEmail());
            map.put("phone",userDto.getPhone());

            UserTokenVo userTokenVo = new UserTokenVo(jwtUtil.generateToken(map));

            return ResponseResult.success(userTokenVo);
        }else{
            return ResponseResult.failure(ResultCode.USER_OR_PASSWORD_ERROR);
        }

    }

到此集成完成，开始测试，为了测试方便，这里新建了一个测试的控制器

package com.zsc.controller;

import com.zsc.common.ResponseResult;
import lombok.extern.slf4j.Slf4j;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @ClassName : TestController
 * @Description : 用于测试的控制器
 * @Author : CJH
 * @Date: 2020-08-18 22:43
 */
@RestController
@Slf4j
@Validated//开启校验支持
@RequestMapping("/api/test")
public class TestController {

    //测试token接口1
    @GetMapping("/test01")
    public ResponseResult<String> test01(String str){
       return ResponseResult.success(str);
    }
}

由于拦截器配置了拦截所有除了"/api/usrs/**"的所有路径，所以，在请求test01接口的时候需要带上token，不然会请求失败，当然上面也做了相应的错误处理
在这里插入图片描述
测试登录接口，返回对应的tonken
在这里插入图片描述

再次请求test01，带上登录返回的token
在这里插入图片描述
到此JWT集成完成，之后开发如果某些接口需要token保护的可以将其路径添加到拦截器里面，以达到认证的目的。

最强菜鸟
关注
专栏目录
JWT学习
kedadiannao220的专栏
04-14 772
什么是JWT?jwt的全称是JSON Web Token；JSON Web Token是一个开源标准(rfc7519) ，是一个轻量，携带着用户信息的json Object对象，安全的进行服务器端与客户端交互；这个对象可以校验、信任，因为它由数字组成； 轻量：因为轻量，所以可以更好地放在http header里面，在服务器与客户端之间快速交互 携带用户信息：将用户的重要信息:userId
JWT学习笔记
大葱Blog
02-24 3619
为一个自娱自乐的项目开发WebAPI的时候，我尝试使用了Token验证机制。 对于我这样一个菜鸟来说，Token的验证机制在我理解中十分简单： 先使用用户名和密码登录系统，服务器会返回一个字符串，约定好这个字符串就是系统出入的通行令牌 客户端之后除了登录操作的所有请求只要带上这个字符串，系统就会放行。 好，到现在就明白了，“Token”在当时的我看来只是一个字符串，我...
jwt的学习
weixin_48864616的博客
01-20 2498
JWT 什么是JWT jwt：json web token 是目前来说，最流行的跨域认证解决方案。 身份认证 验证身份，鉴定权限。 服务端渲染推荐使用session认证机制 前后端分离推荐使用JWT认证机制 工作原理和流程 用户的信息通过Token字符串的形式，保存在客户端浏览器中。 服务器通过还原Token字符串的形式来认证用户的身份。 JWT的组成部分 分为三部分组成：Header（头部），Payload（载荷），Signature（签名） Token是字符串，三者之间使用英文的.分割。【h
WebApi验证JWT爬坑记录
最新发布
yqsy123123的博客
07-23 399
环境是VS2022，JWT验证。
jwt学习总结
zhangan_的博客
04-29 175
package com.zhangan.utils; import com.auth0.jwt.JWT; import com.auth0.jwt.JWTCreator; import com.auth0.jwt.JWTVerifier; import com.auth0.jwt.algorithms.Algorithm; import com.auth0.jwt.interfaces.DecodedJWT; import java.security.Signature; import java.uti
JWT学习——原理/实现
AlexZ的博客
03-15 980
背景： 在学习SpringCloud框架时，用到JWT做用户的认证登录和鉴权。为了更好的理解其工作原理，接下来就是具体学习JWT了。 什么是JWT？ JSON Web Token（JWT）是一个开放标准（RFC 7519），它定义了一种紧凑且独立的方式，用于在各方之间作为JSON对象安全地传输信息。 此信息可以通过数字签名进行验证和信任。 JWT可以使用秘密（使用HMAC算法）或使用RSA或...
JWT的基础学习知识
wangjingyuing的博客
11-04 258
JWT的基础知识学习
Nodejs知识点总结及个人学习心得
weixin_60537353的博客
11-19 1554
Nodejs学习笔记，学习感悟
Java 学习路线大全，再也不用迷路啦（持续更新）
腾讯全栈-ITCJF
10-14 2771
路线特点 最新，完整一条龙，从入门到入土（⭐ 表示推荐学习） 给出目标、学习建议、关键知识点、最优资源以及各类资源推荐（视频、书籍、文档、项目、工具等） 划分阶段、更有计划，且在最后给出持续学习的方向、探索 Java 程序员发展的无限可能 前言 首先呢，我们要了解 Java 的应用场景和就业方向，看看和自己的学习目的是否一致，目前，Java 的岗位需求多，是后台开发的主流编程语言，功能强大，还是很值得学习的。 阶段 1：Java 入门 目标 培养兴趣、快速上手 前期准备 准备好一款在线、随时随地
Python复习计划（也可以作为Python的学习路线）
逆行而上，老不止戈。
09-04 624
Python复习计划（第一次写博客）前言一.Python基础相关二.数据结构/基本算法三.网络编程四.数据库(1.关系型数据库)五.web开发(前端)六.web开发（后端）七.数据库(2.非关系型数据库，MangoDB有时间会添加其中。)八.爬虫(此处学习的自认为不太好所以要着重学习以便于加深HTTP协议的了解。)九.Linux系统(常用操作)十.扩展十一.展望（学如逆水行舟，不进则退。） 前言 ...
MongoDB+Socket.io+async+JWT+Express+Webpack+ES6+Sass+React
Rain120
01-09 1404
最近在github上学习一个前端项目 机票 KieSun/Chat-Buy-React 主要是利用 React / Node 实现的应用，代码虽然不难，但涉及的东西很多，所以我把我最近学到的东西，作为笔记写在这里，供我以后使用，或者大家参考，有什么问题还请大佬指点 主要是利用 React / Node 实现的应用，代码虽然不难，但涉及的东西很多，所以我把我最近学到的东西，作为笔记
人类高质量 Java 学习路线【一条龙版】
Feng_clay的博客
12-04 1598
大家好，我是张讨嫌。现在网上的编程资料实在太多了，而且人人肯定都说自己的最好，那就导致大家又不知道怎么选了。大部分的博主推荐资源，也就是把播放量高的视频说一遍，水一期视频，没有一条很清晰的学习路线。 所以今天我的这个 Java 学习路线就做做减法，给大家来个一条龙服务，Java 要学的知识点、对应的最佳学习资源和预计要花费的时间，都安排的明明白白的，不用选了，有计划了，也别再迷茫和纠结了，就无脑跟着学就行了。 我还在文档中整理了链接，也不用自己搜了，还有思维导图。 大纲 实在太长了，没办法全部展开，
JWT
qq_28764557的博客
11-30 66
https://baijiahao.baidu.com/s?id=1608021814182894637&wfr=spider&for=pc 会话：https://blog.csdn.net/qin_xiaofang/article/details/77725946
JWT使用教程
啊狸的Java的博客
03-12 2727
JWT是json web token的简写，意为json格式的token。（官网） 使用场景 常用于web项目的token校验，用户校验，权限校验等，也可以用于信息的加密传输。 由于http的无状态的，所以我们通常会使用session cookie来保存用户的状态，随着微服务的兴起，session cookie无法在分布式环境下达到保存用户状态的目的，所以我们需要寻找另外的途径来保存用户的状态 ...
JWT入门教程
笨鸟贤妃的博客
07-30 211
JSON Web Token 强烈推荐ruanyifeng老师的文章《JSON Web Token 入门教程》 <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt</artifactId> <version>0.9.0</version> </depe
JWT学习（一）：JWT简介
This Is Why We Coding
11-08 1793
1、简介： Json web token (JWT), 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准（(RFC 7519).该token被设计为紧凑且安全的，特别适用于分布式站点的单点登录（SSO）场景。JWT的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服务器获取资源，也可以增加一些额外的其它业务逻辑所必须的声明信息，该token也可直
JWT入门学习
m0_53127728的博客
08-02 179
引入JWT的原因、JWT内容介绍以及JWT的简单实用
苍穹外卖技术：个人JWT总结与实战应用
在本篇个人总结中，我们关注的是苍穹外卖技术，特别是关于JWT（Json Web Tokens）的运用。JWT是一种轻量级的身份验证协议，用于在网络应用中安全地传递用户信息。以下是总结中的关键知识点： 1. **JWT准备工作**： ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值