AI 助理
备案控制台
开发者社区 大数据 文章 正文

JWT的原理及实际应用

2023-10-25 174
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
公共DNS（含HTTPDNS解析），每月1000万次HTTP解析
云解析 DNS，旗舰版 1个月
密钥管理服务KMS，1000个密钥，100个凭据，1个月
简介： JWT的原理及实际应用

ec71e32b43e24e82987d2f33c3f98577.png3aedcc68f42e486b9357dfedb20b6609.jpg



前言：

定义：JSON Web Token（缩写 JWT）是目前最流行的跨域认证解决方案

JWT官网


由于HTTP协议是无状态的，这意味着如果我们想判定一个接口是否被认证后访问，就需要借助cookie或者session会话机制进行判定，但是由于现在的系统架构大部分都不止一台服务器，此时又要借助数据库或者全局缓存 做存储，这种方案显然受限太多。


那么我们可不可以让认证令牌的发布者自己去识别这个令牌是不是我曾经发布的令牌呢（JWT核心思想），这是JWT最大的优点也是最大的缺点，优点是简单快捷、不需要依赖任何第三方操作就能实现身份认证，缺点就是对于任何拥有用户发布令牌的请求都会认证通过。


1.  JWT是什么

JSON Web Token (JWT)是一个开放标准(RFC 7519)，它定义了一种紧凑的、自包含的方式，用于作为JSON对象在各方之间安全地传输信息。该信息可以被验证和信任，因为它是数字签名的。


2. 什么时候你应该用JWT


下列场景中使用JSON Web Token是很有用的：


Authorization (授权) : 这是使用JWT的最常见场景。一旦用户登录，后续每个请求都将包含JWT，允许用户访问该令牌允许的路由、服务和资源。单点登录是现在广泛使用的JWT的一个特性，因为它的开销很小，并且可以轻松地跨域使用。

Information Exchange (信息交换) : 对于安全的在各方之间传输信息而言，JSON Web Tokens无疑是一种很好的方式。因为JWTs可以被签名，例如，用公钥/私钥对，你可以确定发送人就是它们所说的那个人。另外，由于签名是使用头和有效负载计算的，您还可以验证内容没有被篡改。



986d3df9333241078e369d67e57968b5.png


3. JWT的结构是什么样的



JSON Web Token由三部分组成，它们之间用圆点(.)连接。这三部分分别是：

  • Header
  • Payload
  • Signature

因此，一个典型的JWT看起来是这个样子的：

1. 
2. Header.Payload.Signature


接下来，具体看一下每一部分：

Header


header典型的由两部分组成：token的类型（“JWT”）和算法名称（比如：HMAC SHA256或者RSA等等）。

例如：

然后，用Base64对这个JSON编码就得到JWT的第一部分



Payload


JWT的第二部分是payload，它包含声明（要求）。声明是关于实体(通常是用户)和其他数据的声明。声明有三种类型: registered, public 和 private。


Registered claims : 这里有一组预定义的声明，它们不是强制的，但是推荐。比如：iss (issuer), exp (expiration time), sub (subject), aud (audience)等。

Public claims : 可以随意定义。

Private claims : 用于在同意使用它们的各方之间共享信息，并且不是注册的或公开的声明。

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


iss (issuer)：签发人

exp (expiration time)：过期时间

sub (subject)：主题

aud (audience)：受众

nbf (Not Before)：生效时间

iat (Issued At)：签发时间

jti (JWT ID)：编号

除了官方字段，你还可以在这个部分定义私有字段，下面就是一个例子。

f7a151bcc5fd8b6255ae31f3352877fb.png


对payload进行Base64编码就得到JWT的第二部分

注意，不要在JWT的payload或header中放置敏感信息，除非它们是加密的。

Signature

为了得到签名部分，你必须有编码过的header、编码过的payload、一个秘钥，签名算法是header中指定的那个，然对它们签名即可。


例如：


HMACSHA256(base64UrlEncode(header) + "." + base64UrlEncode(payload), secret)签名是用于验证消息在传递过程中有没有被更改，并且，对于使用私钥签名的token，它还可以验证JWT的发送方是否为它所称的发送方。

看一张官网的图就明白了：




4. JWT是如何工作的


在认证的时候，当用户用他们的凭证成功登录以后，一个JSON Web Token将会被返回。此后，token就是用户凭证了，你必须非常小心以防止出现安全问题。一般而言，你保存令牌的时候不应该超过你所需要它的时间。


无论何时用户想要访问受保护的路由或者资源的时候，用户代理（通常是浏览器）都应该带上JWT，典型的，通常放在Authorization header中，用Bearer schema。


header应该看起来是这样的：


Authorization: Bearer <token>


服务器上的受保护的路由将会检查Authorization header中的JWT是否有效，如果有效，则用户可以访问受保护的资源。如果JWT包含足够多的必需的数据，那么就可以减少对某些操作的数据库查询的需要，尽管可能并不总是如此。


如果token是在授权头（Authorization header）中发送的，那么跨源资源共享(CORS)将不会成为问题，因为它不使用cookie。


下面这张图显示了如何获取JWT以及使用它来访问APIs或者资源：

fce73200a67eb74ba92c0c1d3b890ad0.png

  1. 应用（或者客户端）想授权服务器请求授权。例如，如果用授权码流程的话，就是/oauth/authorize
  2. 当授权被许可以后，授权服务器返回一个access token给应用
  3. 应用使用access token访问受保护的资源（比如：API）

4.1JWT原理


JWT全称JSON Web Token。当服务器认证成功后会生成一个Token，这个token包含了header、payload、signature三部分信息。其中payload的内容有过期时间、签发时间、还有自定义的字段。自定义字段往往用来存放用户信息，比如UserId，UserName等等信息。当客户端收到这个token后存储在Cookie，localstorage或者别的什么地方并且以后每次请求都带上token。服务端对请求所携带的token进行解析，判断是否过期是否合法。


079e7bd51845474f831cdd9b55d8aa15.png

以上简单的描述了下JWT的工作原理，因为jwt的payload携带了过期时间、用户信息等，所以JWT有别于传统Session方案的一个最大不同就是JWT是无状态的，JWT不用在内存或DB里维持session的状态，直接拿到token解析就可以了。

原理图：


4.2 JWT 的几个特点



1）JWT 默认是不加密，但也是可以加密的。生成原始 Token 以后，可以用密钥再加密一次。


（2）JWT 不加密的情况下，不能将秘密数据写入 JWT。


（3）JWT 不仅可以用于认证，也可以用于交换信息。有效使用 JWT，可以降低服务器查询数据库的次数。


（4）JWT 的最大缺点是，由于服务器不保存 session 状态，因此无法在使用过程中废止某个 token，或者更改 token 的权限。也就是说，一旦 JWT 签发了，在到期之前就会始终有效，除非服务器部署额外的逻辑。


（5）JWT 本身包含了认证信息，一旦泄露，任何人都可以获得该令牌的所有权限。为了减少盗用，JWT 的有效期应该设置得比较短。对于一些比较重要的权限，使用时应该再次对用户进行认证。


（6）为了减少盗用，JWT 不应该使用 HTTP 协议明码传输，要使用 HTTPS 协议传输。

4.3 JWT常见问题


① JWT 安全吗?


Base64编码方式是可逆的，也就是透过编码后发放的Token内容是可以被解析的。一般而言，我们都不建议在有效载荷内放敏感讯息，比如使用者的密码。


② JWT Payload 內容可以被伪造吗？


JWT其中的一个组成内容为Signature，可以防止通过Base64可逆方法回推有效载荷内容并将其修改。因为Signature是经由Header跟Payload一起Base64组成的。


③ 如果我的 Cookie 被窃取了，那不就表示第三方可以做 CSRF 攻击?


是的，Cookie丢失，就表示身份就可以被伪造。故官方建议的使用方式是存放在LocalStorage中，并放在请求头中发送。


④ 空间及长度问题？


JWT Token通常长度不会太小，特别是Stateless JWT Token，把所有的数据都编在Token里，很快的就会超过Cookie的大小（4K）或者是URL长度限制。


⑤ Token失效问题？


无状态JWT令牌（Stateless JWT Token）发放出去之后，不能通过服务器端让令牌失效，必须等到过期时间过才会失去效用。

假设在这之间Token被拦截，或者有权限管理身份的差异造成授权Scope修改，都不能阻止发出去的Token失效并要求使用者重新请求新的Token。

JWT 有个问题，导致很多开发团队放弃使用它，那就是一旦颁发一个 JWT 令牌，服务端就没办法废弃掉它，除非等到它自身过期。有很多应用默认只允许最新登录的一个客户端正常使用，不允许多端登录，JWT 就没办法做到，因为颁发了新令牌，但是老的令牌在过期前仍然可用。这种情况下，就需要服务端增加相应的逻辑。

4.4 使用方式

了解了 JWT 的结构和算法后，那怎么使用呢？假设我这儿有个网站。


1、在用户登录网站的时候，需要输入用户名、密码或者短信验证的方式登录，登录请求到达服务端的时候，服务端对账号、密码进行验证，然后计算出 JWT 字符串，返回给客户端。


2、客户端拿到这个 JWT 字符串后，存储到 cookie 或者 浏览器的 LocalStorage 中。


3、再次发送请求，比如请求用户设置页面的时候，在 HTTP 请求头中加入 JWT 字符串，或者直接放到请求主体中。


4、服务端拿到这串 JWT 字符串后，使用 base64的头部和 base64 的载荷部分，通过HMACSHA256算法计算签名部分，比较计算结果和传来的签名部分是否一致，如果一致，说明此次请求没有问题，如果不一致，说明请求过期或者是非法请求。6d468272722d497cd386f8088764ed33.png





467ea89f7b151dcfa0c3532685fd28d7.png

4.5 常用的 JWT 库

JWT 官网列出了各种语言对应的库，其中 Java 的如下几个。


5. JWT的工具类的使用

1. 依赖

在后端项目中导入依赖:

properties配置

<jwt.version>0.9.1</jwt.version>
<java.jwt.version>3.4.0</java.jwt.version>



在dependencies配置标签中 

<dependency>
  <groupId>io.jsonwebtoken</groupId>
  <artifactId>jjwt</artifactId>
  <version>${jwt.version}</version>
</dependency>
<dependency>
  <groupId>com.auth0</groupId>
  <artifactId>java-jwt</artifactId>
  <version>${java.jwt.version}</version>
</dependency>

2. 后台工具类

CorsFilter：

package com.zking.ssm.util;
import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
 * 配置tomcat允许跨域访问
 * 
 * @author Administrator
 *
 */
public class CorsFilter implements Filter {
  @Override
  public void init(FilterConfig filterConfig) throws ServletException {
  }
  @Override
  public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)
      throws IOException, ServletException {
    HttpServletResponse httpResponse = (HttpServletResponse) servletResponse;
    HttpServletRequest req = (HttpServletRequest) servletRequest;
    // Access-Control-Allow-Origin就是我们需要设置的域名
    // Access-Control-Allow-Headers跨域允许包含的头。
    // Access-Control-Allow-Methods是允许的请求方式
    httpResponse.setHeader("Access-Control-Allow-Origin", "*");// *,任何域名
    httpResponse.setHeader("Access-Control-Allow-Methods", "POST, GET, PUT, DELETE");
    //允许客户端发一个新的请求头jwt
    httpResponse.setHeader("Access-Control-Allow-Headers","responseType,Origin,X-Requested-With, Content-Type, Accept, jwt");
    //允许客户端处理一个新的响应头jwt
    httpResponse.setHeader("Access-Control-Expose-Headers", "jwt,Content-Disposition");
    //httpResponse.setHeader("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");
    //httpResponse.setHeader("Access-Control-Allow-Methods", "POST, GET, PUT, DELETE");
    // axios的ajax会发两次请求，第一次提交方式为：option，直接返回即可
    if ("OPTIONS".equals(req.getMethod())) {
      return;
    }
    filterChain.doFilter(servletRequest, servletResponse);
  }
  @Override
  public void destroy() {
  }
}


3. 过滤器

在后台创建过滤器 : JwtFilter  &  JwtUtils

JwtFilter ：

package com.zking.ssm.jwt;
import java.io.IOException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import io.jsonwebtoken.Claims;
/**
 * * JWT验证过滤器，配置顺序 ：CorsFilter-->JwtFilter-->struts2中央控制器
 * 
 * @author Administrator
 *
 */
public class JwtFilter implements Filter {
  // 排除的URL，一般为登陆的URL(请改成自己登陆的URL)
  private static String EXCLUDE = "^/user/userLogin?.*$";
  private static Pattern PATTERN = Pattern.compile(EXCLUDE);
  private boolean OFF = true;// true关闭jwt令牌验证功能
  @Override
  public void init(FilterConfig filterConfig) throws ServletException {
  }
  @Override
  public void destroy() {
  }
  @Override
  public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
      throws IOException, ServletException {
    HttpServletRequest req = (HttpServletRequest) request;
    HttpServletResponse resp = (HttpServletResponse) response;
    //获取当前请求路径。只有登录的请求路径不进行校验之外，其他的URL请求路径必须进行JWT令牌校验
    //http://localhost:8080/ssh2/bookAction_queryBookPager.action
    //req.getServletPath()==/bookAction_queryBookPager.action
    String path = req.getServletPath();
    if (OFF || isExcludeUrl(path)) {// 登陆直接放行
        chain.doFilter(request, response);
        return;
    }
    // 从客户端请求头中获得令牌并验证
    //token=头.载荷.签名
    String jwt = req.getHeader(JwtUtils.JWT_HEADER_KEY);
    Claims claims = this.validateJwtToken(jwt);
    //在这里请各位大哥大姐从JWT令牌中提取payload中的声明部分
    //从声明部分中获取私有声明
    //获取私有声明中的User对象 -> Modules
    Boolean flag=false;
    if (null == claims) {
      // resp.setCharacterEncoding("UTF-8");
      resp.sendError(403, "JWT令牌已过期或已失效");
      return;
    } else {
      //1.获取已经解析后的payload（私有声明）
      //2.从私有声明中当前用户所对应的权限集合List<String>或者List<Module>
      //3.循环权限(Module[id,url])
      // OK,放行请求 chain.doFilter(request, response);
      // NO,发送错误信息的JSON
      // ObjectMapper mapper=new ObjectMapper()
      // mapper.writeValue(response.getOutputStream(),json)
      String newJwt = JwtUtils.copyJwt(jwt, JwtUtils.JWT_WEB_TTL);
      resp.setHeader(JwtUtils.JWT_HEADER_KEY, newJwt);
      chain.doFilter(request, response);
    }
  }
  /**
   * 验证jwt令牌，验证通过返回声明(包括公有和私有)，返回null则表示验证失败
   */
  private Claims validateJwtToken(String jwt) {
    Claims claims = null;
    try {
      if (null != jwt) {
        //该解析方法会验证：1）是否过期 2）签名是否成功
        claims = JwtUtils.parseJwt(jwt);
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
    return claims;
  }
  /**
   * 是否为排除的URL
   * 
   * @param path
   * @return
   */
  private boolean isExcludeUrl(String path) {
    Matcher matcher = PATTERN.matcher(path);
    return matcher.matches();
  }
  // public static void main(String[] args) {
  // String path = "/sys/userAction_doLogin.action?username=zs&password=123";
  // Matcher matcher = PATTERN.matcher(path);
  // boolean b = matcher.matches();
  // System.out.println(b);
  // }
}


JwtUtils ：

package com.zking.ssm.jwt;
import java.util.Date;
import java.util.Map;
import java.util.UUID;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import org.apache.commons.codec.binary.Base64;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
/**
 * JWT验证过滤器：配置顺序 CorsFilte->JwtUtilsr-->StrutsPrepareAndExecuteFilter
 *
 */
public class JwtUtils {
  /**
   * JWT_WEB_TTL：WEBAPP应用中token的有效时间,默认30分钟
   */
  public static final long JWT_WEB_TTL = 30 * 60 * 1000;
  /**
   * 将jwt令牌保存到header中的key
   */
  public static final String JWT_HEADER_KEY = "jwt";
  // 指定签名的时候使用的签名算法，也就是header那部分，jwt已经将这部分内容封装好了。
  private static final SignatureAlgorithm SIGNATURE_ALGORITHM = SignatureAlgorithm.HS256;
  private static final String JWT_SECRET = "f356cdce935c42328ad2001d7e9552a3";// JWT密匙
  private static final SecretKey JWT_KEY;// 使用JWT密匙生成的加密key
  static {
    byte[] encodedKey = Base64.decodeBase64(JWT_SECRET);
    JWT_KEY = new SecretKeySpec(encodedKey, 0, encodedKey.length, "AES");
  }
  private JwtUtils() {
  }
  /**
   * 解密jwt，获得所有声明(包括标准和私有声明)
   * 
   * @param jwt
   * @return
   * @throws Exception
   */
  public static Claims parseJwt(String jwt) {
    Claims claims = Jwts.parser()
        .setSigningKey(JWT_KEY)
        .parseClaimsJws(jwt)
        .getBody();
    return claims;
  }
  /**
   * 创建JWT令牌，签发时间为当前时间
   * 
   * @param claims
   *            创建payload的私有声明（根据特定的业务需要添加，如果要拿这个做验证，一般是需要和jwt的接收方提前沟通好验证方式的）
   * @param ttlMillis
   *            JWT的有效时间(单位毫秒)，当前时间+有效时间=过期时间
   * @return jwt令牌
   */
  public static String createJwt(Map<String, Object> claims, 
      long ttlMillis) {
    // 生成JWT的时间，即签发时间 2021-10-30 10:02:00 -> 30 10:32:00
    long nowMillis = System.currentTimeMillis();
    //链式语法：
    // 下面就是在为payload添加各种标准声明和私有声明了
    // 这里其实就是new一个JwtBuilder，设置jwt的body
    JwtBuilder builder = Jwts.builder()
        // 如果有私有声明，一定要先设置这个自己创建的私有的声明，这个是给builder的claim赋值，一旦写在标准的声明赋值之后，就是覆盖了那些标准的声明的
        .setClaims(claims)
        // 设置jti(JWT ID)：是JWT的唯一标识，根据业务需要，这个可以设置为一个不重复的值，主要用来作为一次性token,从而回避重放攻击。
        // 可以在未登陆前作为身份标识使用
        .setId(UUID.randomUUID().toString().replace("-", ""))
        // iss(Issuser)签发者，写死
        .setIssuer("zking")
        // iat: jwt的签发时间
        .setIssuedAt(new Date(nowMillis))
        // 代表这个JWT的主体，即它的所有人，这个是一个json格式的字符串，可放数据{"uid":"zs"}。此处没放
        // .setSubject("{}")
        // 设置签名使用的签名算法和签名使用的秘钥
        .signWith(SIGNATURE_ALGORITHM, JWT_KEY)
        // 设置JWT的过期时间
        .setExpiration(new Date(nowMillis + ttlMillis));
    return builder.compact();
  }
  /**
   * 复制jwt，并重新设置签发时间(为当前时间)和失效时间
   * 
   * @param jwt
   *            被复制的jwt令牌
   * @param ttlMillis
   *            jwt的有效时间(单位毫秒)，当前时间+有效时间=过期时间
   * @return
   */
  public static String copyJwt(String jwt, Long ttlMillis) {
    //解密JWT，获取所有的声明（私有和标准）
    //old
    Claims claims = parseJwt(jwt);
    // 生成JWT的时间，即签发时间
    long nowMillis = System.currentTimeMillis();
    // 下面就是在为payload添加各种标准声明和私有声明了
    // 这里其实就是new一个JwtBuilder，设置jwt的body
    JwtBuilder builder = Jwts.builder()
        // 如果有私有声明，一定要先设置这个自己创建的私有的声明，这个是给builder的claim赋值，一旦写在标准的声明赋值之后，就是覆盖了那些标准的声明的
        .setClaims(claims)
        // 设置jti(JWT ID)：是JWT的唯一标识，根据业务需要，这个可以设置为一个不重复的值，主要用来作为一次性token,从而回避重放攻击。
        // 可以在未登陆前作为身份标识使用
        //.setId(UUID.randomUUID().toString().replace("-", ""))
        // iss(Issuser)签发者，写死
        // .setIssuer("zking")
        // iat: jwt的签发时间
        .setIssuedAt(new Date(nowMillis))
        // 代表这个JWT的主体，即它的所有人，这个是一个json格式的字符串，可放数据{"uid":"zs"}。此处没放
        // .setSubject("{}")
        // 设置签名使用的签名算法和签名使用的秘钥
        .signWith(SIGNATURE_ALGORITHM, JWT_KEY)
        // 设置JWT的过期时间
        .setExpiration(new Date(nowMillis + ttlMillis));
    return builder.compact();
  }
}


4. 控制器

UserController

 @RequestMapping("/userLogin")
    @ResponseBody
    public JsonResponseBody<?> userLogin(UserVo userVo, HttpServletResponse response){
        if(userVo.getUsername().equals("admin")&&userVo.getPassword().equals("123")){
            //私有要求claim
            Map<String,Object> json=new HashMap<String,Object>();
            json.put("username", userVo.getUsername());
            //生成JWT，并设置到response响应头中
            String jwt=JwtUtils.createJwt(json, JwtUtils.JWT_WEB_TTL);
            response.setHeader(JwtUtils.JWT_HEADER_KEY, jwt);
            return new JsonResponseBody<>("用户登陆成功！",true,0,null);
        }else{
            return new JsonResponseBody<>("用户名或密码错误！",false,0,null);
        }
    }


5. web.xml配置

 <!--CrosFilter跨域过滤器-->
  <filter>
    <filter-name>corsFilter</filter-name>
    <filter-class>com.zking.ssm.util.CorsFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>corsFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
  <!--JwtFilter-->
  <filter>
    <filter-name>jwtFilter</filter-name>
    <filter-class>com.zking.ssm.jwt.JwtFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>jwtFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

6. 测试类

生成JWT 
private SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
  @Test
  public void test1() {// 生成JWT
    //JWT Token=Header.Payload.Signature
    //头部.载荷.签名
    //Payload=标准声明+私有声明+公有声明
    //定义私有声明
    Map<String, Object> claims = new HashMap<String, Object>();
    claims.put("username", "zss");
    claims.put("age", 18);
      //TTL:Time To Live
    String jwt = JwtUtils.createJwt(claims, JwtUtils.JWT_WEB_TTL);
    System.out.println(jwt);
    //获取Payload（包含标准和私有声明）
    Claims parseJwt = JwtUtils.parseJwt(jwt);
    for (Map.Entry<String, Object> entry : parseJwt.entrySet()) {
      System.out.println(entry.getKey() + "=" + entry.getValue());
    }
    Date d1 = parseJwt.getIssuedAt();
    Date d2 = parseJwt.getExpiration();
    System.out.println("令牌签发时间：" + sdf.format(d1));
    System.out.println("令牌过期时间：" + sdf.format(d2));
  }


eca072e441ef46f89a017ea13a15086f.png

解析JWT
public void test2() {// 解析oldJwt
    //io.jsonwebtoken.ExpiredJwtException：JWT过期异常
    //io.jsonwebtoken.SignatureException：签名异常
    //String oldJwt="eyJhbGciOiJIUzI1NiJ9.eyJleHAiOjE1OTA3MTg2NzcsImlhdCI6MTU5MDcxNjg3NywiYWdlIjoxOCwianRpIjoiNDFmZjFiZGFkYzkxNDA3OGE4ZGUyNGRkZDEwYjU4N2IiLCJ1c2VybmFtZSI6InpzcyJ9.DdPvioX6kuhV6lEfD9QAN2eQSk_mO3dYkmDmTQsqa78";
    //eyJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2MzU1NjE3MjcsImlhdCI6MTYzNTU1OTkyNywiYWdlIjoxOCwianRpIjoiN2RlYmIzM2JiZTg3NDBmODgzNDI5Njk0ZWE4NzcyMTgiLCJ1c2VybmFtZSI6InpzcyJ9.dUR-9JUlyRdoYx-506SxXQ3gbHFCv0g5Zm8ZGzK1fzw
    String newJwt="eyJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJ6a2luZyIsImV4cCI6MTY5NzIwODE1OCwiaWF0IjoxNjk3MjA2MzU4LCJhZ2UiOjE4LCJqdGkiOiJjZjA4YjYxZjQxMDY0MTA3YTkyNTc2NGI5ZGIwMTAyZSIsInVzZXJuYW1lIjoienNzIn0.tIIb3wQizd6GkfivNc4XDLE09hyuaW1jLTLtHpnwJ2Q";
    String oldJwt = "eyJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2MzU1NjE3MjcsImlhdCI6MTYzNTU1OTkyNywiYWdlIjoxOCwianRpIjoiN2RlYmIzM2JiZTg3NDBmODgzNDI5Njk0ZWE4NzcyMTgiLCJ1c2VybmFtZSI6InpzcyJ9.dUR-9JUlyRdoYx-506SxXQ3gbHFCv0g5Zm8ZGzK1fzw";
    Claims parseJwt = JwtUtils.parseJwt(newJwt);
    for (Map.Entry<String, Object> entry : parseJwt.entrySet()) {
      System.out.println(entry.getKey() + "=" + entry.getValue());
    }
    Date d1 = parseJwt.getIssuedAt();
    Date d2 = parseJwt.getExpiration();
    System.out.println("令牌签发时间：" + sdf.format(d1));
    System.out.println("令牌过期时间：" + sdf.format(d2));
  }

a0184d183773494abd76fc58a33aa728.png


复制JWT，并延时30分钟
@Test
  public void test3() {// 复制jwt，并延时30分钟
    String oldJwt = "eyJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJ6a2luZyIsImV4cCI6MTY5NzIwODE1OCwiaWF0IjoxNjk3MjA2MzU4LCJhZ2UiOjE4LCJqdGkiOiJjZjA4YjYxZjQxMDY0MTA3YTkyNTc2NGI5ZGIwMTAyZSIsInVzZXJuYW1lIjoienNzIn0.tIIb3wQizd6GkfivNc4XDLE09hyuaW1jLTLtHpnwJ2Q";
    //String newJwt = "eyJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2MDU3NTM2NTUsImlhdCI6MTYwNTc1MTg1NSwiYWdlIjoxOCwianRpIjoiYmNmN2Q1MzQ2YjE3NGU2MDk1MmIxYzQ3ZTlmMzQyZjgiLCJ1c2VybmFtZSI6InpzcyJ9.m1Qn84RxgbKCnsvrdbbAnj8l_5Jwovry8En0j4kCxhc";
    //String oldJwt = "eyJhbGciOiJIUzI1NiJ9.eyJleHAiOjE1NjI5MDMzNjAsImlhdCI6MTU2MjkwMTU2MCwiYWdlIjoxOCwianRpIjoiZDVjMzE4Njg0MDcyNDgyZDg1MDE5ODVmMDY3OGQ4NjkiLCJ1c2VybmFtZSI6InpzcyJ9.XDDDRRq5jYq5EdEBHtPm7GcuBz4S0VhDTS1amRCdf48";
    String newJwt = JwtUtils.copyJwt(oldJwt, JwtUtils.JWT_WEB_TTL);
    System.out.println(newJwt);
    Claims parseJwt = JwtUtils.parseJwt(newJwt);
    for (Map.Entry<String, Object> entry : parseJwt.entrySet()) {
      System.out.println(entry.getKey() + "=" + entry.getValue());
    }
    Date d1 = parseJwt.getIssuedAt();
    Date d2 = parseJwt.getExpiration();
    System.out.println("令牌签发时间：" + sdf.format(d1));
    System.out.println("令牌过期时间：" + sdf.format(d2));
  }



2af1cd5a119945c88fd079d62d4e8a4a.png

测试JWT的有效时间
@Test
  public void test4() {// 测试JWT的有效时间
    Map<String, Object> claims = new HashMap<String, Object>();
    claims.put("username", "zss");
    String jwt = JwtUtils.createJwt(claims, 3 * 1000L);
    System.out.println(jwt);
    Claims parseJwt = JwtUtils.parseJwt(jwt);
    Date d1 = parseJwt.getIssuedAt();
    Date d2 = parseJwt.getExpiration();
    System.out.println("令牌签发时间：" + sdf.format(d1));
    System.out.println("令牌过期时间：" + sdf.format(d2));
  }


905b6b05122048e1b2f440114f81979a.png


测试过期JWT的解析
@Test
  public void test5() {// 三秒后再解析上面过期时间只有三秒的令牌，因为过期则会报错io.jsonwebtoken.ExpiredJwtException
    //String oldJwt = "eyJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2MzU1NjMzODIsImlhdCI6MTYzNTU2MTU4MiwiYWdlIjoxOCwianRpIjoiN2RlYmIzM2JiZTg3NDBmODgzNDI5Njk0ZWE4NzcyMTgiLCJ1c2VybmFtZSI6InpzcyJ1.F4pZFCjWP6wlq8v_udfhOkNCpErF5QlL7DXJdzXTHqE";
    String oldJwt = "eyJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJ6a2luZyIsImV4cCI6MTY2MjM0Njg3MSwiaWF0IjoxNjYyMzQ1MDcxLCJhZ2UiOjE4LCJqdGkiOiI4YjllNzc3YzFlMDM0MjViYThmMDVjNTFlMTU3NDQ1MiIsInVzZXJuYW1lIjoienNzIn9.UWpJxPxwJ09PKxE2SY5ME41W1Kv3jP5bZGKK-oNUDuM";
    Claims parseJwt = JwtUtils.parseJwt(oldJwt);
    // 过期后解析就报错了，下面代码根本不会执行
    Date d1 = parseJwt.getIssuedAt();
    Date d2 = parseJwt.getExpiration();
    System.out.println("令牌签发时间：" + sdf.format(d1));
    System.out.println("令牌过期时间：" + sdf.format(d2));
  }



ec71e32b43e24e82987d2f33c3f98577.png



7. JWT集成spa项目

state.js

export default {
  eduName: 'ar.小白',
  jwt: ''
}


getters.js

export default {
  getEduName: (state) => {
    return state.eduName;
  },
  getJwt: (state) => {
    return state.jwt;
  }
}


mutations.js

export default {
  // type(事件类型)： 其值为setEduName
  // payload：官方给它还取了一个高大上的名字：载荷，其实就是一个保存要传递参数的容器
  setEduName: (state, payload) => {
    state.eduName = payload.eduName;
  },
  setJwt: (state, payload) => {
    state.jwt = payload.jwt;
  }
}


main.js

/* eslint-disable no-new */
window.mm = new Vue({
  el: '#app',
  router,
  store,
  data() {
    return {
      bus: new Vue()
    }
  },
  components: {
    App
  },
  template: '<App/>'
})


http.js

// 请求拦截器
axios.interceptors.request.use(function(config) {
  let jwt = window.mm.$store.getters.getJwt;
  if(jwt){
    config.headers['jwt'] = jwt;
  }
  return config;
}, function(error) {
  return Promise.reject(error);
});
// 响应拦截器
axios.interceptors.response.use(function(response) {
  //将响应头中的jwt字符串放入state.js中
  let jwt = response.headers['jwt'];
  if (jwt) {
    window.mm.$store.commit('setJwt', {
      jwt: jwt
    });
  }
  return response;
}, function(error) {
  return Promise.reject(error);
});


文章标签：
密钥管理服务
云解析DNS
数据格式
JSON
数据安全/隐私保护
算法
存储
关键词：
jwt应用
jwt原理
jwt原理应用
Ar.小白
目录
相关文章
小王老师呀
|
20天前
|
JSON 算法 安全
JWT Bearer 认证在 .NET Core 中的应用
【10月更文挑战第30天】JWT（JSON Web Token）是一种开放标准，用于在各方之间安全传输信息。它由头部、载荷和签名三部分组成，用于在用户和服务器之间传递声明。JWT Bearer 认证是一种基于令牌的认证方式，客户端在请求头中包含 JWT 令牌，服务器验证令牌的有效性后授权用户访问资源。在 .NET Core 中，通过安装 `Microsoft.AspNetCore.Authentication.JwtBearer` 包并配置认证服务，可以实现 JWT Bearer 认证。具体步骤包括安装 NuGet 包、配置认证服务、启用认证中间件、生成 JWT 令牌以及在控制器中使用认证信息
小王老师呀
56 2
龙大吉
|
2月前
|
JSON 安全 数据库
Python安全性大升级：OAuth与JWT，让你的应用穿上防弹衣🛡️
【9月更文挑战第6天】在数字世界中，每个应用都面临着安全威胁。作为Python开发者，构建强大的系统至关重要。OAuth和JWT为我们提供了坚实的安全保障。OAuth作为一种授权机制，让用户无需向第三方应用暴露敏感信息；JWT则通过自包含的信息传输，增强了安全性并提高了系统性能。利用Python生态中的这些工具，我们可以更好地保护用户数据，守护他们的信任与期待。下面是一个使用PyJWT生成和验证JWT的示例代码：（示例代码同上）通过这些技术，我们的应用能够更加稳健地在数字海洋中航行。
龙大吉
31 3
土木林森
|
3月前
|
安全 Nacos 数据安全/隐私保护
【技术干货】破解Nacos安全隐患：连接用户名与密码明文传输！掌握HTTPS、JWT与OAuth2.0加密秘籍，打造坚不可摧的微服务注册与配置中心！从原理到实践，全方位解析如何构建安全防护体系，让您从此告别数据泄露风险！
【8月更文挑战第15天】Nacos是一款广受好评的微服务注册与配置中心，但其连接用户名和密码的明文传输成为安全隐患。本文探讨加密策略提升安全性。首先介绍明文传输风险，随后对比三种加密方案：HTTPS简化数据保护；JWT令牌减少凭证传输，适配分布式环境；OAuth2.0增强安全，支持多授权模式。每种方案各有千秋，开发者需根据具体需求选择最佳实践，确保服务安全稳定运行。
土木林森
317 0
白如意i
|
3月前
|
JSON 人工智能 算法
Golang 搭建 WebSocket 应用（四） - jwt 认证
Golang 搭建 WebSocket 应用（四） - jwt 认证
白如意i
54 0
兀码
|
5月前
|
存储 JSON API
在django3应用中使用现代的JWT鉴权
【6月更文挑战第8天】本文介绍流行的鉴权方式，JSON Web Tokens (JWT) 是一种验证JSON数据所有者的机制，它是一个编码的、安全的字符串，包含可信任的数据且能加密签名。无状态的令牌认证允许客户端存储令牌并将其在每次请求。
兀码
62 8
在django3应用中使用现代的JWT鉴权
龙大吉
|
3月前
|
JSON 安全 数据安全/隐私保护
Python安全性大升级：OAuth与JWT，让你的应用穿上防弹衣🛡️
【8月更文挑战第4天】在数字海洋中，应用如船，承载用户信任，面对安全挑战。OAuth与JWT成为Python开发者构建安全系统的利器。OAuth作为授权桥梁，简化流程，保护隐私；JWT则以自包含的信息传递，加速验证过程，增强安全性。两者结合，为应用穿上坚固防弹衣，确保数据安全，守护用户信任。
龙大吉
27 0
磊哥聊Java
|
5月前
|
存储 算法 Java
闲鱼面试：说说JWT工作原理？
闲鱼面试：说说JWT工作原理？
磊哥聊Java
55 0
闲鱼面试：说说JWT工作原理？
真的很搞笑
|
5月前
|
消息中间件 Serverless Go
Serverless 应用引擎操作报错合集之通过自定义域名配置jwt认证，始终报错："Code": "JWTTokenIsInvalid",是什么导致的
Serverless 应用引擎（SAE）是阿里云提供的Serverless PaaS平台，支持Spring Cloud、Dubbo、HSF等主流微服务框架，简化应用的部署、运维和弹性伸缩。在使用SAE过程中，可能会遇到各种操作报错。以下是一些常见的报错情况及其可能的原因和解决方法。
真的很搞笑
110 2
泥腿子架构师
|
4月前
|
存储 JSON 算法
JWT原理与在身份验证中的应用
JWT原理与在身份验证中的应用
泥腿子架构师
47 0
code袁
|
6月前
|
存储 JSON JavaScript
session和JWT的应用及区别
在Node.js中实现登录认证，可以使用`express-session`进行Session管理。首先安装`express-session`，然后全局引入并配置。登录成功后，存储用户信息和登录状态至Session，之后可从Session中获取或销毁用户信息。另外，JWT（Json Web Token）也是一个选择。JWT包含header、payload和signauter三部分，通过`jsonwebtoken`包生成和解密Token，设置秘钥和过期时间。使用`express-jwt`进行解密，并配置全局错误处理中间件来处理无效Token的情况。
code袁
46 2

热门文章

最新文章

  • 1
    如何在SpringBoot中集成JWT(JSON Web Token)鉴权
  • 2
    使用JWT简化http接口鉴权，告别烦人的加密、解密代码吧
  • 3
    在线JWT Token解析解码工具
  • 4
    无懈可击的身份验证：深入了解JWT的工作原理
  • 5
    【Spring Boot 快速入门】十九、Spring Boot 集成JWT
  • 6
    微服务网关鉴权：gateway使用、网关限流使用、用户密码加密、JWT鉴权（二）
  • 7
    自己写token类（无视jwt）
  • 8
    SpringBoot通过拦截器和JWT令牌实现登录验证
  • 9
    Vue3 + Nest 实现权限管理系统 后端篇（二）：使用 JWT 实现注册与登录
  • 10
    SpringBoot整合JWT
  • 1
    SpringCloudAlibaba:4.3云原生网关higress的JWT 认证
    118
  • 2
    SpringBoot之JWT令牌校验
    195
  • 3
    切图仔做全栈：React&Nest.js社区平台(一)——基础架构与邮箱注册、JWT登录实现
    145
  • 4
    Serverless 应用引擎产品使用之阿里函数计算中要关掉http触发器的jwt认证才可以进行性能探测如何解决
    62
  • 5
    pyjwt，一个强大的 Python JWT解析校验库！
    157
  • 6
    node实战——后端koa结合jwt连接mysql实现权限登录（node后端就业储备知识）
    106
  • 7
    使用JWT的服务分布式部署之后报错：JWT Check Failure:
    109
  • 8
    微服务之Springboot整合Oauth2.0 + JWT
    152
  • 9
    ❤Nodejs 第九章（token身份认证和express-jwt的安装认识）
    108
  • 10
    JWT解密：探秘令牌魔法与Java的完美交互
    82

    • 相关电子书

    更多
  • 低代码开发师（初级）实战教程
  • 冬季实战营第三期：MySQL数据库进阶实战
  • 阿里巴巴DevOps 最佳实践手册
    • 下一篇
    阿里云OSS设置跨域访问