JWT的原理及实际应用

朱雀 2024-02-22 09:30 151阅读 0赞

![3aedcc68f42e486b9357dfedb20b6609.jpeg][]

## 前言： ##

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

[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的结构是什么样的 ###

![e9e03ead2c2547128cbee84d6fe06a11.png][]

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

*  Header
 *  Payload
 *  Signature

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

Header.Payload.Signature

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

#### Header ####

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

例如：

![9ae9646eefb5d6a782e23b26617e5fea.png][]

然后，用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的发送方是否为它所称的发送方。

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

![52ca5e421b153849bb96a72519076b9e.png][]

### 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解析就可以了。

原理图：

![2a0847e29e76467fb5c2f596f52a6bfe.png][]

#### 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 的如下几个。

![image-20200817112359199][]

### 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配置 ####

<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>
    
      
      <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);
    });

[3aedcc68f42e486b9357dfedb20b6609.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/9d26b9b8cc3c4d3f996b1f5f4d9da9a1.png
[JWT]: https://jwt.io/
[986d3df9333241078e369d67e57968b5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/78c5a4ba9c7642f79dc4ae2627106c8b.png
[e9e03ead2c2547128cbee84d6fe06a11.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/6956b2da647e412d9c08347461abdaa0.png
[9ae9646eefb5d6a782e23b26617e5fea.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/4b8b9872329c4adc97dd08bf26d278b3.png
[f7a151bcc5fd8b6255ae31f3352877fb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/e8d07e6196f24c2ba8cddfbbedf07dc5.png
[52ca5e421b153849bb96a72519076b9e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/9af7bebcdd464728b276341989bbf46c.png
[fce73200a67eb74ba92c0c1d3b890ad0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/960a36de53f04f8a84fe33287a3d665b.png
[079e7bd51845474f831cdd9b55d8aa15.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/b67ef6420ef14464a3d21c5af05d9966.png
[2a0847e29e76467fb5c2f596f52a6bfe.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/505c768041114b128df25aa0d7d4c676.png
[6d468272722d497cd386f8088764ed33.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/2c265f14111b4ea58c174c1e0f43ba45.png
[467ea89f7b151dcfa0c3532685fd28d7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/15c68ae1f1d8468885a12047cd680ccd.png
[image-20200817112359199]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/7baacb86f5e640a584e8eea83db353ef.png
[eca072e441ef46f89a017ea13a15086f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/0587e1eea3764aa48a9a30b29d293a8c.png
[a0184d183773494abd76fc58a33aa728.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/f6251a5f8d9a4e4087caad044cb65439.png
[2af1cd5a119945c88fd079d62d4e8a4a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/cebfc62857df4ec6be90a722dceec942.png
[905b6b05122048e1b2f440114f81979a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/d01deb75df1b4d8fa7f264d69297c35f.png
[ec71e32b43e24e82987d2f33c3f98577.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/851d51a4fd084fb997c5ddcd837b999d.png