JWT生成Token

最新推荐文章于 2024-07-23 17:20:50 发布
最新推荐文章于 2024-07-23 17:20:50 发布
阅读量1.1k 收藏 26
点赞数 14
文章标签： github
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhuge_long/article/details/140086166
版权

一、 JWT 实现无状态 Web 服务

1、什么是有状态

有状态服务，即服务端需要记录每次会话的客户端信息，从而识别客户端身份，根据用户身份进行请求的处理，典型的设计如tomcat中的session。

例如登录：用户登录后，我们把登录者的信息保存在服务端session中，并且给用户一个cookie值，记录对应的session。然后下次请求，用户携带cookie值来，我们就能识别到对应session，从而找到用户的信息。

缺点是什么？

  • 服务端保存大量数据，增加服务端压力

  • 服务端保存用户状态，无法进行水平扩展

  • 客户端请求依赖服务端，多次请求必须访问同一台服务器

2、什么是无状态

服务器不需要记录客户端的状态信息，即：

  • 服务端不保存任何客户端请求者信息

  • 客户端的每次请求必须具备自描述信息，通过这些信息识别客户端身份

带来的好处是什么呢？

  • 客户端请求不依赖服务端的信息，任何多次请求不需要必须访问到同一台服务

  • 服务端的集群和状态对客户端透明

  • 服务端可以任意的迁移和伸缩

  • 减小服务端存储压力

3、如何实现无状态

无状态登录的流程：

  • 当客户端第一次请求服务时，服务端对用户进行信息认证（登录）

  • 认证通过，将用户信息进行加密形成token，返回给客户端，作为登录凭证

  • 以后每次请求，客户端都携带认证的token

  • 服务的对token进行解密，判断是否有效。

流程图：

客户端请求登录，登录之后颁发凭证

整个登录过程中，最关键的点是什么？

token的安全性

token是识别客户端身份的唯一标示，如果加密不够严密，被人伪造那就完蛋了。

采用何种方式加密才是安全可靠的呢？

我们将采用JWT + RSA非对称加密

4、JWT简介

JWT全称是Json Web Token， 是JSON风格轻量级的授权和身份认证规范，可实现无状态、分布式的Web应用授权；官网：https://jwt.io

JWT包含三部分数据：

  • Header：头部，通常头部有两部分信息：

    • 声明类型，这里是JWT 自描述信息

    我们会对头部进行base64编码，得到第一部分数据 base64编码和解码的

  • Payload：载荷，就是有效数据，一般包含下面信息：

    • 用户身份信息（注意，这里因为采用base64编码，可解码 是可逆的，因此不要存放敏感信息）

    • 注册声明：如token的签发时间，过期时间，签发人等 这部分内容 好比身份证的信息

    这部分也会采用base64编码，得到第二部分数据

  • Signature：签名，是整个数据的认证信息。一般根据前两步的数据，再加上服务的密钥（secret）（不要泄漏，最好周期性更换），通过加密算法（不可逆的）生成一个签名。用于验证整个数据完整和可靠性。

生成的数据格式：token==个人证件 jwt=个人身份证

可以看到分为3段，每段就是上面的一部分数据

 

5、JWT交互流程

流程图：

步骤翻译：

  • 1、用户登录

  • 2、服务的认证，通过后根据secret生成token

  • 3、将生成的token返回给浏览器

  • 4、用户每次请求携带token

  • 5、服务端利用公钥解读jwt签名，判断签名有效后，从Payload中获取用户信息

  • 6、处理请求，返回响应结果

因为JWT签发的token中已经包含了用户的身份信息，并且每次请求都会携带，这样服务的就无需保存用户信息，甚至无需去数据库查询，完全符合了Rest的无状态规范。

6、非对称加密

加密技术是对信息进行编码和解码的技术，编码是把原来可读信息（又称明文）译成代码形式（又称密文），其逆过程就是解码（解密），加密技术的要点是加密算法，加密算法可以分为三类：

  • 对称加密，如AES

    • 基本原理：将明文分成N个组，然后使用密钥对各个组进行加密，形成各自的密文，最后把所有的分组密文进行合并，形成最终的密文。

    • 优势：算法公开、计算量小、加密速度快、加密效率高

    • 缺陷：双方都使用同样密钥，安全性得不到保证

  • 非对称加密，如RSA

    • 基本原理：同时生成两把密钥：私钥和公钥，私钥隐秘保存，公钥可以下发给信任客户端

      • 私钥加密，持有私钥或公钥才可以解密

      • 公钥加密，持有私钥才可解密

    • 优点：安全，难以破解

    • 缺点：算法比较耗时

  • 不可逆加密，如MD5，SHA

    • 基本原理：加密过程中不需要使用密钥，输入明文后由系统直接经过加密算法处理成密文，这种加密后的数据是无法被解密的，无法根据密文推算出明文。

RSA算法历史：

1977年，三位数学家Rivest、Shamir 和 Adleman 设计了一种算法，可以实现非对称加密。这种算法用他们三个人的名字缩写：RSA

目前流行的还有oauth2

二、nimbus-jose-jwt 库

nimbus-jose-jwt、jose4j、java-jwt 和 jjwt 是几个 Java 中常见的操作 JWT 的库。就使用细节而言，nimbus-jos-jwt（和jose4j）要好于 java-jwt 和 jjwt 。

nimbus-jose-jwt 官网：https://connect2id.com/products/nimbus-jose-jwt

所需坐标

<dependency>
    <groupId>com.nimbusds</groupId>
    <artifactId>nimbus-jose-jwt</artifactId>
    <version>9.11.1</version>
</dependency>

1、 JWT 和 JWS

这里我们需要了解下 JWT、JWS、JWE 三者之间的关系：

  • JWT（JSON Web Token）指的是一种规范，这种规范允许我们使用 JWT 在两个组织之间传递安全可靠的信息。

  • JWS（JSON Web Signature）和 JWE（JSON Web Encryption）是 JWT 规范的两种不同实现，我们平时最常使用的实现就是 JWS 。

简单来说，JWT 和 JWS、JWE 类似于接口与实现类。由于，我们使用的是 JWS ，所以，后续内容中，就直接列举 JWS 相关类，不再细分 JWS 和 JWE 了，numbus-jose-jwt 中的 JWE 相关类和接口我们也不会使用到

2、加密算法

  • 对称加密』指的是使用相同的秘钥来进行加密和解密，如果你的秘钥不想暴露给解密方，考虑使用非对称加密。在加密方和解密方是同一个人（或利益关系紧密）的情况下可以使用它。

  • 『非对称加密』指的是使用公钥和私钥来进行加密解密操作。对于加密操作，公钥负责加密，私钥负责解密，对于签名操作，私钥负责签名，公钥负责验证。非对称加密在 JWT 中的使用显然属于签名操作。在加密方和解密方是不同人（或不同利益方）的情况下可以使用它。

nimbus-jose-jwt 支持的算法都在它的 JWSAlgorithm 和 JWEAlgorithm 类中有定义。

例如：JWSAlgorithm algorithm = JWSAlgorithm.HS256

3、核心 API

a、加密过程

  • 在 nimbus-jose-jwt 中，使用 Header 类代表 JWT 的头部，不过，Header 类是一个抽象类，我们使用的是它的子类 JWSHeader 。

    创建头部对象：

     @Test
 public void createToken(){
     //创建头部对象
     JWSHeader jwsHeader =
             new JWSHeader.Builder(JWSAlgorithm.HS256)       // 加密算法
                     .type(JOSEObjectType.JWT) // 静态常量
                     .build();
     System.out.println(jwsHeader);
 }

    你可以通过 .getParsedBase64URL() 方法求得头部信息的 Base64 形式（这也是 JWT 中的实际头部信息）：

  • 使用 Payload 类的代表 JWT 的荷载部分

    创建荷载部对象:

    @Test
    public void createToken(){
        //创建头部对象
        JWSHeader jwsHeader =
                new JWSHeader.Builder(JWSAlgorithm.HS256)       // 加密算法
                        .type(JOSEObjectType.JWT) // 静态常量
                        .build();
        System.out.println(jwsHeader);

        //创建map保存要放在载荷中的内容
         Map<String, Object> map = new HashMap<String, Object>();
            map.put("user_key", "hello world");
        //创建载荷
        Payload payload = new Payload(map);
        System.out.println(payload);
    }

    你可以通过 .toBase64URL() 方法求得荷载部信息的 Base64 形式（这也是 JWT 中的实际荷载部信息）：

  • 签名部分

    签名部分没有专门的类表示，只有通用类 Base64URL ，而且签名部分并非你自己创建出来的，而是靠 头部 + 荷载部 + 加密算法 算出来的。在 nimbus-jose-jwt 中，签名算法由 JWSAlgorithm 表示。

    注意：在创建 JWSHeader 对象时就需要指定签名算法，因为在标准中，头部需要保存签名算法名字。

    用头部和荷载部分，再加上指定的签名算法和密钥来生成签名部分的过程，在 nimbus-jose-jwt 中被称为『签名（sign）』。nimbus-jose-jwt 专门提供了一个签名器 JWSSigner ，用来参与到签名过程中。密钥就是在创建签名器的时候指定的：

    JWSSigner jwsSigner = new MACSigner("密钥");  //MACSigner()中要指定一个密钥

    最终，整个 JWT 由一个 JWSObject 对象表示：

    JWSObject jwsObject = new JWSObject(jwsHeader, payload);
// 进行签名（根据前两部分生成第三部分）
jwsObject.sign(jwsSigner);

    在 nimbus-jose-jwt 中 JWSObject 是有状态的：未签名、已签名和签名中。很显然，在执行完 .sign() 方法之后，JWSObject 对象就变成了已签名状态。

    当然，我们最终『要』的是 JWT 字符串，而不是对象，这里接着对代表 JWT 的 JWSObject 对象调用 .serialize() 方法即可：

    String token = jwsObject.serialize();

    完整示例：

        @Test
    public void createToken() throws JOSEException {
        //创建头部对象
        JWSHeader jwsHeader =
                new JWSHeader.Builder(JWSAlgorithm.HS256)       // 加密算法
                        .type(JOSEObjectType.JWT) // 静态常量
                        .build();
        
          //生成载荷
            Map<String, Object> map = new HashMap<String, Object>();
            map.put("USER_KEY", "hello jwt");
            Payload payload = new Payload(map);//要保存的用户数据，一般是用户的帐号
        
         //创建签名器
            JWSSigner jwsSigner = new MACSigner("woniuxy");  //MACSigner()中要指定一个密钥，需要256bits
        //创建签名对象
            JWSObject jwsObject = new JWSObject(jwsHeader, payload); //将头部和截荷接到签名器中
            //生成签名（头+载荷+密钥）
            jwsObject.sign(jwsSigner);
        
         //生成token字符串
            String token = jwsObject.serialize();
        	System.out.println(token);
    }

    如果出现:com.nimbusds.jose.KeyLengthException: The secret length must be at least 256 bits异常，是因为密钥的长度不够增加密钥长度即可

    //创建签名器
JWSSigner jwsSigner = new MACSigner("woniuwoniuwoniuwoniuwoniuwoniuwoniuwoniuwoniuwoniuwoniuwoniuwoniuwoniuwoniu");

生成的token如下:
	eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.aGVsbG8gd29ybGQ.p1E7jMNXs4zzCHDDbFzQXOko6s9NtT7Sqt15-T-7KVY

b、获得token中的内容
 /**
     * 取出token中的内容
     */
    @Test
    public void getToken() throws IOException {
         String token="eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.aGVsbG8gd29ybGQ.p1E7jMNXs4zzCHDDbFzQXOko6s9NtT7Sqt15-T-7KVYA";
        
        //将token字符串反序列化为签名对象
         JWSObject jwsObject = JWSObject.parse(token);
        //获得载何中的内容   
         Map<String,Object> map=jwsObject.getPayload().toJSONObject();
        String username= (String) map.get("USER_KEY");
        System.out.println(username);
    }

b、 解密

反向的解密和验证过程核心 API 就 2 个：JWSObject 的静态方法 parse 方法和验证其 JWSVerifier 对象。

JWSObject.parse() 方法是上面的 serialize 方法的反向操作，它可以通过一个 JWT 串生成 JWSObject 。有了 JWObject 之后，你就可以获得 header 和 payload 部分了。

如果你想直接验证 JWSObject 对象的合法性，你需要创建一个 JWSVerifier 对象。

//创建验证器
JWSVerifier jwsVerifier = new MACVerifier("密钥");//密钥要和加密时的相同

然后直接调用 jwsObject 对象的 verify 方法：

if (!jwsObject.verify(jwsVerifier)) {
    throw new RuntimeException("token 签名不合法！");
}

案例二：验证token是否合法

 /**
     * 验证token
     */
    @Test
    public void validationToken() throws Exception {
        //获得token
        String token="eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.aGVsbG8gd29ybGQ.p1E7jMNXs4zzCHDDbFzQXOko6s9NtT7Sqt15-T-7KVYA";
        //将token字符串反序列化为签名对象
         JWSObject jwsObject = JWSObject.parse(token);
          //创建验证器
        JWSVerifier jwsVerifier=new MACVerifier("woniuwoniuwoniuwoniuwoniuwoniuwoniuwoniuwoniuwoniuwoniuwoniuwoniuwoniuwoniu");
        //使用jws较验器，验证用户传递token是否合法
        if (!jwsObject.verify(jwsVerifier)) {
            throw new RuntimeException("token 签名不合法！");
        }
   }

4、创建jwt工具类

/**
 * jwt工具类
 */
public class JwtUtils {
    //使用uuid生成密钥
    private  final static String secret="202cb962ac59075b964b07152d234b70";
    //用户数据的key
    private  final static String usernameKey="usernameKey";

    /**
     * 生成token
     * @param username 用户名
     * @return
     */
    public static String createJwtToken(String username) throws Exception {
        try {
            //创建头部对象
            JWSHeader jwsHeader =
                    new JWSHeader.Builder(JWSAlgorithm.HS256)       // 加密算法
                            .type(JOSEObjectType.JWT) // 静态常量
                            .build();

            //创建载荷
            Map<String, Object> map = new HashMap<String, Object>();
            map.put(usernameKey, username);
            Payload payload = new Payload(map);

            //创建签名器
            JWSSigner jwsSigner = new MACSigner(secret);//密钥

            //创建签名
            JWSObject jwsObject = new JWSObject(jwsHeader, payload);// 头部+载荷
            jwsObject.sign(jwsSigner);//再+签名部分

            //生成token字符串
            return jwsObject.serialize();
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 验证jwt token是否合法
     * @param jwtStr
     * @return
     */
    public static boolean verify(String jwtStr) {
        try {
            JWSObject jwsObject = JWSObject.parse(jwtStr);
            JWSVerifier jwsVerifier = new MACVerifier(secret);
            return jwsObject.verify(jwsVerifier);
        }catch (Exception e){
            return false;
        }
    }

    /**
     * 从token中解析出用户名
     * @param jwtStr
     * @return
     */
    public static  String getUserNameFormJwt(String jwtStr){
        try {
            JWSObject jwsObject = JWSObject.parse(jwtStr);
            Map<String, Object> map = jwsObject.getPayload().toJSONObject();
            return (String) map.get(usernameKey);
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }
}

三、根据帐号密码登录

1、登录步骤

  • 输入帐号密码到数据库中查询

  • 查询成功根据帐号生成token保存到redis中，同时发送token给浏览器

    • service代码

      @Service
@Transactional
public class UserService {
    @Autowired
    private StringRedisTemplate redisTemplate;
    @Autowired
    private JwtUtils jwtUtils;

    /**
     * 登录业务
     * @param account  帐号
     * @param password  密码
     * @return
     */
    @SneakyThrows
    public String getLogin(String account, String password){
        String token=null;
        if(account.equals("tom") && password.equals("123")){
            //登录成功，生成token保存到redis中
            token=jwtUtils.createJwtToken(account);
            //保存token到redis中，有效期一分钟
            ValueOperations<String,String> operations=redisTemplate.opsForValue();
            operations.set("login:token:"+account, token, 60, TimeUnit.SECONDS);
        }
        return token;
    }
}

    • controller代码

      @RestController
public class LoginController {

    @Autowired
    private UserService userService;

    /**
     * 登录
     * @param account
     * @param password
     * @return
     */
    @GetMapping("login")
    public ResponseResult<Object> login(String account,String password){
        String token=userService.getLogin(account, password);
        if(token!=null){
            return new ResponseResult<Object>(2000,"OK",token);
        }
        return new ResponseResult<Object>(2001,"帐号或密码错误");
    }
    
}

2、非登录步骤

  • 发送请求将token一起发给服务器

  • 服务端获得token对tken进行合法性验证

  • 验证成功放行到controller,验证失败则提示

    • controller代码

      @RestController
public class UserController {
    /**
     * 查询用户列表
     * @return
     */
    public ResponseResult<Void> userList(){
        return new ResponseResult<Void>(2000,"用户列表成功");
    }
}

    • 拦截器代码

      /**
 * token验证拦截器
 */
@Component
public class TokenHandler implements HandlerInterceptor {

    @Autowired
    private StringRedisTemplate redisMapper;

    @Autowired
    private JwtUtils jwtUtils;

    //json工具
    private ObjectMapper objectMapper=new ObjectMapper();

    /**
     * 在请求到达conttroller前判断权限
     * @param request
     * @param response
     * @param object
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request,
                             HttpServletResponse response,
                             Object object) throws Exception {
      	response.setContentType("application/json;charset=UTF-8");

        //获得请求头中的token
        String token=request.getHeader("x-jwt-token");

        //请求头中没有token
        if(token==null){
            String json=objectMapper.writeValueAsString(new ResponseResult<Void>(6001,"请求中没有token"));
            response.getWriter().write(json);
            return false;
        }

        //验证请求头中的token是否合法
        if(jwtUtils.verify(token)==false){
            String json=objectMapper.writeValueAsString(new ResponseResult<Void>(6002,"token不合法"));
            response.getWriter().write(json);
            return false;
        }

        //token合法则取出token中保存的帐号
        String account=jwtUtils.getUserNameFormJwt(token);
        //根据帐号验证redis中保存的token是否存在
        if(redisMapper.hasKey("login:token:"+account)==false){
            String json=objectMapper.writeValueAsString(new ResponseResult<Void>(6003,"未登录或token已过期"));
            response.getWriter().write(json);
            return false;
        }

       return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
    }
}

    • springmvc配置类

      @Configuration
public class WebConfigurer implements WebMvcConfigurer {

    @Autowired
    private TokenHandler tokenHandler;

    /**
     * 注册自定义拦截器
     * @param registry
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(tokenHandler)
                .addPathPatterns("/**")  //拦截哪些url   /**表示拦截所有
                .excludePathPatterns("/","/login");
        //放行哪些请求  所有在登录前需要直接显示的就放行
    }
}

四、token续期

在实际的开发中，token不可能一直有效，比如30分钟内一次都没有进行操作，则认证过期，需要重新登录，如果一直在进行请求访问则token一直有效，直到上一次访问距离下一次访问的时间超过了30分钟，则认证过期。

基于上面的需求：如果用户一直在进行请求，则认证一直有效，如何做到这一点。需要对token进行续期操作。对token进行续期有很多种方案，常见的方案是：使用redis控制过期时间，使用双Token。我们采用redis方案

  • 修改token拦截器

    /**
 * token验证拦截器
 */
@Component
public class JwtTokenHandler implements HandlerInterceptor {

    @Resource
    private RedisMapper redisMapper;

    /**
     * 请求到达controller前验证token
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request,
                             HttpServletResponse response,
                             Object handler) throws Exception {
        //设置response编码
        response.setContentType("application/json;charset=UTF-8");

        //保存输到页面的结果
        ResponseResult<Void> responseResult=null;

        //取出请求头中的token
        String token=request.getHeader("x_token");

        //请求头中没有token,表示未登录
        if(token==null){
            responseResult=new ResponseResult<>(6001,"未登录请先登录。。。");
            response.getWriter().write(JacksonUtil.toJsonString(responseResult));
            return false;
        }

        //请求头中有token,验证token是否合法
        if(!JwtUtils.verify(token)){
            //不合法
            responseResult=new ResponseResult<>(6002,"token非法。。。");
            response.getWriter().write(JacksonUtil.toJsonString(responseResult));
            return false;
        }

        //token合法,取出载荷中的帐号
        String account=JwtUtils.getUserNameFormJwt(token);
        //判断redis中token是否失效
        if(!redisMapper.hasKey(account+":token")){
            responseResult=new ResponseResult<>(6003,"token已过期，请重新登录。。。");
            response.getWriter().write(JacksonUtil.toJsonString(responseResult));
            return false;
        }

        String redisToken= (String) redisMapper.getKey(account+":token");
        //判断用户发过来的token和redis中的token是否是同一个
        if(!token.equals(redisToken)){
            responseResult=new ResponseResult<>(6002,"token非法。。。");
            response.getWriter().write(JacksonUtil.toJsonString(responseResult));
            return false;
        }

        //token合法，且未过期,对reids中的认证token续期
        redisMapper.setKey(account+":token", redisToken, 30, TimeUnit.MINUTES);
        //取出权限token进行续期
        String perms= (String) redisMapper.getKey(account+":perms");
        redisMapper.setKey(account+":perms", perms, 30, TimeUnit.MINUTES);
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
    }
}

  • 注册拦截器

    /**
 * springmvc配置类
 */
@Configuration
public class WebMvcConfigurer implements WebMvcConfigurer {
    @Resource
    private JwtTokenHandler jwtTokenHandler;

    /**
     * 注册自定义拦截器
     * @param registry
     */
     @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(jwtTokenHandler)
                .addPathPatterns("/**")  //拦截哪些url   /**表示拦截所有
                .excludePathPatterns("/","/login");
        //放行哪些请求  所有在登录前需要直接显示的就放行
    }
}

 

蜗牛学苑_武汉
关注
  • 14
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JWT生成token
ywn0601的博客
12-02 3863
token是什么？ 答：token就是一段字符串，由三部分组成(头部(header),荷载(payload,签名(sign))) 头部： 是token的最基本信息，包含类型和用的算法。比如 { "type":"JWT", "alg":"HS256" } 荷载/载荷： 是核心，自定义的数据，一般是用户id，过期时间等 { "uid":"XXXXid", "exp":"122223" } 签名： 就是头部和荷载base64加密后用.连接起来的，然后形成xx.xx的前两段token, 最后一段是用前两
JWT应用功能
SurepMan的博客
08-03 253
服务端不保存任何客户端请求者信息客户端的每次请求必须具备自描述信息，通过这些信息识别客户端身份带来的好处是什么呢？客户端请求不依赖服务端的信息，任何多次请求不需要必须访问到同一台服务服务端的集群和状态对客户端透明服务端可以任意的迁移和伸缩减小服务端存储压力JWT全称是Json Web Token， 是JSON风格轻量级的授权和身份认证规范，可实现无状态、分布式的Web应用授权；官网：https://jwt.ioJWT包含三部分数据：声明类型，这里是JWT 自描述信息。
基于jwt的token验证、原理及流程
最新发布
2401_85239883的博客
07-23 418
就写到这了，也算是给这段时间的面试做一个总结，查漏补缺，祝自己好运吧，也希望正在求职或者打算跳槽的 程序员看到这个文章能有一点点帮助或收获，我就心满意足了。多思考，多问为什么。希望小伙伴们早点收到满意的offer!越努力越幸运！金九银十已经过了，就目前国内的面试模式来讲，在面试前积极的准备面试，复习整个 Java 知识体系将变得非常重要，可以很负责任的说一句，复习准备的是否充分，将直接影响你入职的成功率。
利用JWT生成Token
兜兜的博客
11-21 1683
开篇 实现Token的方式有很多，本篇介绍的是利用Json Web Token(JWT)生成的Token.JWT生成的Token有什么好处呢？ 安全性比较高，加上密匙加密而且支持多种算法。 携带的信息是自定义的，而且可以做到验证token是否过期。 验证信息可以由前端保存，后端不需要为保存token消耗内存。 本篇分3部分进行讲解。 什么是JWT JWT的代码实现，代码将JWT封...
jwt生成token
爪哇人的博客
11-21 1万+
1 基于传统的session认证 http本身是一种无状态的协议，而这就意味着如果用户向我们的应用提供了用户名和密码来进行用户认证，那么下一次请求时，用户还再一次进行用户认证。因为根据http协议，我们不知道是哪个用户发出的请求，所以为了能让我们应用识别是哪一个用户发出的请求，我们只能在服务器端存储一份用户登录的信息，这份登录信息会在响应时传递给浏览器。告诉其保存为cookie，以便下次请求时发送给我们的应用，这样我们的用户就能识别是哪一个用户了，这就是传统的基于session认证。 当...
JWT Token生成
weixin_45805672的博客
09-01 5699
Jwt token生成的方式有几种，可根据具体情况决定生成方式，以下为本人使用的一种，仅供参考。 官网地址：https://jwt.io/introduction 1.jwt生成的Token格式 eyJhbGciOiJIUzI1NiJ9.eyJqd3RDbGFpbSI6eyJ1c2VySWQiOiIyIiwiYXBpSWRzIjoiMSwyLDMiLCJuYW1lIjpudWxsfSwiaWF0IjoxNjMwNDg3MjA5LCJleHAiOjE2MzA0OTQ0MDl9.apV5AqF6tgeV
Java中使用JWT生成Token进行接口鉴权实现方法
08-25
Java中使用JWT生成Token进行接口鉴权实现方法 Java中使用JWT生成Token进行接口鉴权实现方法是当前最流行的鉴权方式之一。通过本文，读者可以了解到使用JWT生成Token进行接口鉴权的详细实现方法。 什么是JWT？ JWT...
SpringBoot集成JWT生成token及校验方法过程解析
08-19
SpringBoot集成JWT生成token及校验方法过程解析 本文主要介绍了SpringBoot集成JWT生成token及校验方法的过程解析，通过示例代码详细介绍了JWT token的生成和校验过程，为读者提供了详细的Reference和学习价值。 一...
JWT Token生成及验证
07-16
4. **JWT生成**：生成JWT时，你需要提供一个签发者（issuer, `iss`）、接收者（audience, `aud`）、有效时间（expiration time, `exp`）以及其他自定义声明。例如，使用`JwtSecurityToken`类，设置这些参数并生成...
使用JWT生成token
热门推荐
zjjcchina的博客
04-24 1万+
一、使用JWT进行身份验证 1、传统用户身份验证 Internet服务无法与用户身份验证分开。一般过程如下： 用户向服务器发送用户名和密码。 验证服务器后，相关数据（如用户角色，登录时间等）将保存在当前会话中。 服务器向用户返回session_id，session信息都会写入到用户的Cookie。 用户的每个后续请求都将通过在Cookie中取出session_id传给服务器。 服务器收到session_id并对比之前保存的数据，确认用户的身份。 这种模式最大的问题是，没有分布式架构，无
JWT 生成Token及验证
01-22
JWT生成token及验证（过期时间）用于前后断分离，及APP认证，可结合redis使用也可单独使用。
JWT-生成token
m0_69128892的博客
05-11 7119
一、什么是JWT JWT 即Json Web Token，将用户登录态以及数据用加密的json格式存储在客户端，服务端可以完全依靠这个字符串认定用户身份。简单来说，这是一种用户身份认证的解决方案。 二、JWT的组成 一个JWT实际上就是一个字符串，由三部分组成分别是： header（头部） payload（载荷） signature（签名） 结构如下：header.payload.signature 1.header（头部） header（头部）的信息指定了其Token类型和所使用的加密算法。 示例：
Token生成方案-JWT
奇遇少年
01-17 2662
JWT的使用简化了用户身份验证的流程，使得开发者能够在Web应用中轻松实现高效的身份认证和信息传递。
JWT生成token工具类
weixin_52776724的博客
05-07 550
/** * JWT 工具类 * 对JJWT的封装 */ public class JwtUtils { private static final String JWT_PAYLOAD_USER_KEY = "id"; // 加密KEY private static final String TOKEN_ENCRY_KEY = "MDk4ZjZiY2Q0NjIxZDM3M2NhZGU0ZTgzMjYyN2I0ZjY"; /** * 加密token
什么是JWT（JSON WEB TOKEN）
昆仔的博客
07-24 275
原文传送门 什么是JWT Json web token（JWT）是为了网络应用环境间传递声明而执行的一种基于JSON的开发标准（RFC 7519），该token被设计为紧凑且安全的，特别适用于分布式站点的单点登陆（SSO）场景。JWT的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服务器获取资源，也可以增加一些额外的其它业务逻辑所必须的声明信息，该toke...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值