一.JWT简介

1.概念

JWT (JSON Web Token) 是一种用于在网络上安全传输信息的开放标准（RFC 7519）。它是一种紧凑且自包含的方式，用于在不同组件之间传递信息，通常用于身份验证和授权目的。JWT 是以 JSON 格式编码的令牌，它包含了声明（claims），并使用数字签名或加密来验证其完整性

2.组成

1. Header（头部）：头部通常包括两部分信息，标明该令牌的类型（"typ"）以及所使用的签名算法（"alg"）。例如：

   { 
       "alg": "HS256",
       "typ": "JWT" 
   }

   在头部中，通常也可以指定使用非对称加密算法（例如RSA）来进行签名或加密。

2. Payload（负载）：负载包含了一组声明，这些声明描述了令牌的一些信息。有三种类型的声明：

   • Registered Claims（注册声明）：这些是一些预定义的声明，包括 iss（令牌的发行者）、sub（主题）、aud（受众）、exp（过期时间）、nbf（生效时间）、iat（发布时间）等。
   • Public Claims（公共声明）：这些声明可以由令牌的发行者和使用者协商定义。
   • Private Claims（私有声明）：这些是自定义的声明，用于在双方之间共享信息。

   例如：

   { 
       "sub": "1234567890", 
       "name": "John Doe", 
       "iat": 1516239022 
   }

3. Signature（签名）：签名用于验证令牌的完整性和真实性。签名是通过使用头部中指定的签名算法以及密钥来计算的。它可以防止令牌被篡改。签名是在头部和负载的 Base64 编码字符串上计算的，例如：

   HMACSHA256( base64UrlEncode(header) + "." + base64UrlEncode(payload), secret)

   这个签名将会附加在令牌的末尾，形成最终的JWT，如：header.payload.signature。

3.JWT 的主要优势

• 自包含：JWT 包含了所有必要的信息，不需要在服务器端存储会话信息。
• 可验证：接收方可以验证令牌的完整性和真实性，因为签名是依靠密钥计算的。
• 跨域：JWT 可以在不同域之间传递，因为它是一种标准格式。
• 扩展性：可以包含自定义声明，适用于各种不同的应用场景。
• 轻量级：JWT 是一种紧凑的数据格式，易于传输和处理。

然而，要注意的是，JWT 令牌的安全性高度依赖于密钥的安全性。如果密钥泄露，那么攻击者可能能够伪造有效的JWT。因此，必须妥善保管密钥，并使用适当的安全措施来保护JWT。

二.JWT的工具类

package com.YU.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("YU")
				// 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();
	}
}

1.工具类解析

 1.初始化相关信息

1. JWT_WEB_TTL常量：定义了JWT令牌的有效时间，单位是毫秒，默认为30分钟。这个常量指定了在WEBAPP应用中生成的JWT令牌的有效期限。

2. JWT_HEADER_KEY常量：定义了JWT令牌在HTTP请求的头部中的键名。在HTTP请求的头部中，JWT令牌会作为值与这个键名相关联，用于传递JWT令牌。

3. SIGNATURE_ALGORITHM常量：指定了在JWT中使用的签名算法。在这个例子中，使用了HS256（HMAC SHA-256）签名算法。HS256是一种使用密钥进行签名和验证的算法。

4. JWT_SECRET常量：指定了用于生成JWT签名的密钥。在这个例子中，密钥是一个字符串，用于生成JWT签名。请注意，实际应用中应该将密钥存储在安全的地方，不建议硬编码在代码中。

5. JWT_KEY常量：使用JWT_SECRET密钥生成的加密key。这个key用于在生成JWT签名时进行加密。

6. 静态块：这个类中的静态块用来初始化JWT_KEY。在静态块中，JWT_SECRET字符串经过Base64解码，并使用解码后的字节数组创建了一个SecretKeySpec对象，用于生成JWT签名时的加密key。

2.解密JWT令牌

1. 使用Jwts.parser()创建一个JWT解析器对象。

2. 使用.setSigningKey(JWT_KEY)方法将JWT解析器配置为使用特定的密钥JWT_KEY来验证JWT令牌的签名。这是为了确保JWT令牌的完整性和真实性。

3. 使用.parseClaimsJws(jwt)方法来解析传入的JWT令牌jwt，并将其转换为Jws<Claims>对象。Jws表示JWT令牌的完整签名结构，包括头部、负载和签名。

4. 最后，使用.getBody()方法从Jws对象中获取JWT令牌的声明部分，这些声明包括标准声明（例如iss、sub、exp等）以及任何自定义的私有声明。这些声明将被包装在一个Claims对象中。

如果JWT解析成功，将返回包含声明的Claims对象，如果JWT解析成功，将返回包含声明的Claims对象

3.创建JWT令牌

1. 获取当前时间的时间戳，用作JWT令牌的签发时间。

2. 使用JwtBuilder对象创建JWT令牌，采用链式语法。

3. 使用.setClaims(claims)方法设置JWT的声明部分，包括标准声明和自定义的私有声明。claims参数是一个包含声明信息的Map对象。

4. 使用.setId()方法设置JWT的唯一标识，通常用于防止重放攻击。

5. 使用.setIssuer("YU")方法设置JWT的签发者。

6. 使用.setIssuedAt()方法设置JWT的签发时间。

7. 使用.signWith(SIGNATURE_ALGORITHM, JWT_KEY)方法来对JWT进行签名，SIGNATURE_ALGORITHM表示签名算法，JWT_KEY表示用于签名的密钥。

8. 使用.setExpiration()方法设置JWT的过期时间，即JWT的有效期。

9. 最后，使用.compact()方法将JWT令牌压缩为字符串并返回

4. 复制jwt

1. 方法签名：这个方法被定义为public static String copyJwt(String jwt, Long ttlMillis)，它接受两参数：jwt是要被复制的JWT令牌，ttlMillis是JWT的有效时间，以毫秒为单位。ttlMillis会被用来计算新JWT的失效时间。

2. 解密JWT：在方法内部的第一行，代码调用了parseJwt(jwt)函数来解密jwt，并将其内容提取为声明（claims），包括标准声明和私有声明。

3. 签发时间（Issued At - iat）：在JWT的payload（令牌的主体部分）中，设置了签发时间，即iat。这个时间用System.currentTimeMillis()获取当前时间，然后作为JWT的签发时间。

4. JWT的构建：接下来，通过JwtBuilder对象来构建一个新的JWT。这个对象会包含JWT的各种声明。

5. 私有声明：在JWT中，你可以包含一些自定义的私有声明，用来存储额外的信息。在这个代码中，通过.setClaims(claims)将之前解密的声明添加到JWT的payload中。

6. 唯一标识（JWT ID - jti）：这段代码注释掉了唯一标识声明的设置，但你可以根据需要取消注释，并为每个JWT生成一个唯一的标识。

7. 签发者（Issuer - iss）：签发者声明通常是JWT的签发者，这里被写死为"zking"。

8. 签名算法和秘钥：使用.signWith(SIGNATURE_ALGORITHM, JWT_KEY)设置JWT的签名算法和秘钥，以确保JWT的完整性和安全性。

9. 失效时间：最后，通过.setExpiration(new Date(nowMillis + ttlMillis))设置JWT的失效时间。失效时间是签发时间加上有效时间(ttlMillis)。

10. 返回值：最后，使用builder.compact()将JWT构建为一个紧凑的字符串表示，并返回这个字符串。

2.JWT测试

package com.YU.ssm.service.impl;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

import com.YU.ssm.jwt.JwtUtils;
import io.jsonwebtoken.Claims;
import org.junit.*;

public class JwtDemo {

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

	@Test
	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.eyJpc3MiOiJ6a2luZyIsImV4cCI6MTY2MjM0Njg3MSwiaWF0IjoxNjYyMzQ1MDcxLCJhZ2UiOjE4LCJqdGkiOiI4YjllNzc3YzFlMDM0MjViYThmMDVjNTFlMTU3NDQ1MiIsInVzZXJuYW1lIjoienNzIn0.UWpJxPxwJ09PKxE2SY5ME41W1Kv3jP5bZGKK-oNUDuM";
		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));
	}

	@Test
	public void test3() {// 复制jwt，并延时30分钟
		String oldJwt = "eyJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJ6a2luZyIsImV4cCI6MTY2MjM0Njg3MSwiaWF0IjoxNjYyMzQ1MDcxLCJhZ2UiOjE4LCJqdGkiOiI4YjllNzc3YzFlMDM0MjViYThmMDVjNTFlMTU3NDQ1MiIsInVzZXJuYW1lIjoienNzIn0.UWpJxPxwJ09PKxE2SY5ME41W1Kv3jP5bZGKK-oNUDuM";
		//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));
	}

}

1.测试方法1

运行结果

当我们通过携带身份信息运行时会获得jwt值并携带它的一个签发时间和过期值

2.测试方法2

我们可以通过token值来解析获取到令牌的信息以及签发时间和过期时间，但是只能获取到还未过期的令牌

当我们使用已经过期的令牌时会抛出异常

例：

1.已过期令牌

2.未过期令牌

 使用未过期令牌即可获取它的登录信息值以及它的签发时间和过期时间

3.测试方法3

复制延长jwt值的有效时间

可以对比上面的令牌时间，我们使用同一个令牌进行延长时间 

三.JWT集成spa项目

1.定义好jwt的基本信息

1.1定义变量

export default {
  TName:'YU',
  jwt:''
}

1.2 基本get、set方法

setJWT:(state,payload)=>{
    state.jwt = payload.jwt;
  }

getJWT:(state)=>{
    return state.jwt;
  }

2.存值

2.1 在响应拦截器和请求拦截器中将响应头中的jwt串放入state.js中

// 请求拦截器
axios.interceptors.request.use(function(config) {
	let jwt = window.vm.$store.getters.getJWT;
  if(jwt){
    config.headers['jwt'] = jwt;
  }
  return config;
}, function(error) {
	return Promise.reject(error);
});

// 响应拦截器
axios.interceptors.response.use(function(response) {
  let jwt = response.headers['jwt'];
  if(jwt){
    window.vm.$store.commit('setJWT',{
      jwt:jwt
    });
  }
	return response;
}, function(error) {
	return Promise.reject(error);
});

2.2执行效果

我们在登录之后的userLogin包中会展示我们的jwt值