目录
[( 1 ) 什么是JWT](#( 1 ) 什么是JWT)
[( 2 ) 为什么要学](#( 2 ) 为什么要学)
[1. 依赖](#1. 依赖)
[2. 工具类](#2. 工具类)
[3. 过滤器](#3. 过滤器)
[4. 控制器](#4. 控制器)
[5. 配置](#5. 配置)
[6. 测试类](#6. 测试类)
一、介绍&讲述
( 1 ) 什么是JWT
JWT**(JSON Web Token)** 是一种用于身份验证的开放标准,它是在前后端分离项目中常用的身份验证方式之一。它由三部分组成:++头部++ 、++载荷++ 和**++签名++**。其中,头部包含加密算法和类型信息,载荷包含用户信息、权限等数据,签名则是对头部和载荷的加密结果。
头部(Header):头部通常由两部分组成,加密算法和类型信息。加密算法指定了如何对JWT进行签名,常用的算法有HMAC、RSA和ECDSA等。类型信息通常是"JWT"。
载荷(Payload):载荷是JWT的主要部分,包含了需要传递的用户信息、权限、角色等数据。载荷是一个JSON对象,可以自定义存储所需的信息。常用的标准声明有iss(签发者)、sub(主题)、exp(过期时间)等。
签名(Signature):签名是对头部和载荷进行加密生成的结果。签名使用头部中指定的加密算法和密钥,确保JWT的完整性和真实性。服务器端在接收到JWT后,可以使用相同的密钥对JWT进行解密和验证。
JWT的使用流程如下:
-
用户在登录时,将用户名和密码发送给后端。
-
后端验证用户名和密码,如果验证通过,则生成一个JWT并将其返回给前端。
-
前端将JWT保存在本地,一般使用浏览器的本地存储(localStorage或sessionStorage)或者HTTP Only的Cookie。
-
当前端需要访问需要身份验证的资源时,将JWT添加到请求头中发送给后端。
-
后端验证JWT的合法性,包括验证签名、有效期等。如果验证通过,则返回请求的资源。
JWT的工作原理可以简单概括为:认证、签发和验证。
-
- 认证(Authentication):用户在登录时提供有效的用户名和密码进行认证。服务器验证用户的身份,并生成一个JWT作为用户的身份凭证。
-
- 签发(Issuance):服务器根据用户的身份信息和其他相关信息(如角色、权限等)生成一个JWT,并使用密钥对JWT进行签名。签名是为了确保JWT的完整性和真实性,防止被篡改。
-
- 验证(Verification):用户在后续的请求中将JWT作为身份凭证发送给服务器。服务器收到请求后,会验证JWT的签名和有效期。如果验证通过,服务器会根据JWT中的信息判断用户的身份和权限,然后返回相应的资源或执行相应的操作。
具体的工作流程如下:
-
用户在登录时提供用户名和密码进行认证。
-
服务器验证用户的身份,并生成一个JWT。JWT由三部分组成:头部(Header)、载荷(Payload)和签名(Signature)。
-
头部:包含了JWT的类型(typ)和签名算法(alg)等信息。
-
载荷:包含了用户的身份信息和其他相关信息,如用户ID、角色、权限等。载荷还可以包含一些自定义的信息,如过期时间(exp)等。
-
签名:通过将头部、载荷和服务器的密钥进行加密生成的签名,用于验证JWT的完整性和真实性。
-
服务器将生成的JWT返回给用户。
-
用户在后续的请求中将JWT作为身份凭证添加到请求头中发送给服务器。通常,JWT放在Authorization头部的Bearer字段中,如:Authorization: Bearer <JWT>。
-
服务器收到请求后,解析JWT并验证其签名和有效期。如果验证通过,服务器可以根据JWT中的信息判断用户的身份和权限,并返回相应的资源或执行相应的操作。
注意 : JWT是无状态的,服务器不需要保存任何状态信息。每次请求都包含了身份验证信息,服务器可以通过验证JWT的签名和有效期来确认用户的身份。这样可以减少服务器的负担,并且适用于分布式系统和高并发环境。
( 2 ) 为什么要学
-
无状态的身份验证:传统的session认证方式需要在服务器端存储和管理session信息,而JWT是无状态的,服务器不需要保存任何状态信息。每个请求都包含了身份验证信息,服务器可以通过验证JWT的签名和有效期来确认用户的身份。这样可以减少服务器的负担,并且适用于分布式系统和高并发环境。
-
跨平台和跨语言:JWT基于标准的JSON格式,可以在不同的平台和语言之间进行传递和解析。无论是使用Java、Python、Node.js还是其他语言,都可以轻松地处理JWT。使得前后端分离的项目更加灵活和可扩展。
-
安全性:JWT使用签名验证数据的完整性,防止数据被篡改。服务器使用密钥对JWT进行签名,当客户端发送JWT时,服务器可以验证签名的有效性,确保数据的真实性和完整性。同时,JWT可以进行加密,保护用户信息的安全性。这样可以提供更高的安全性,防止恶意攻击和数据泄露。
-
减少服务器负担:传统的session认证方式需要在服务器端存储和管理session信息,而JWT在客户端保存,减轻了服务器的负担。服务器不需要在内存中保存session信息,也不需要查询数据库来验证用户的身份。
-
可扩展性:JWT的载荷中可以存储用户的自定义信息,如权限、角色等。这使得JWT在应对复杂的授权需求时更加灵活和可扩展。
-
前后端分离:JWT适用于前后端分离的项目,前端可以将JWT保存在本地,如浏览器的本地存储(localStorage或sessionStorage)或者HTTP Only的Cookie中。每次请求时,前端将JWT添加到请求头中发送给后端,后端可以验证JWT的合法性,并返回相应的资源。这种方式使得前后端的开发和维护可以独立进行,提高了开发效率和灵活性。
总的来说,JWT具有更好的可扩展性、安全性和跨平台性,适用于前后端分离的项目。
JWT是一种简单、安全、可靠的身份验证方式,适用于前后端分离的项目。它通过将用户信息和权限等数据存储在JWT中,实现了无状态的身份验证,并提供了数据完整性和安全性的保障。
二、结构
JWT(JSON Web Token)是一种用于在网络上安全传输信息的开放标准(RFC 7519)。它由三部分组成:头部(Header)、载荷(Payload)和签名(Signature)。
- 头部(Header):JWT的头部是一个JSON对象,用于描述JWT的元数据,例如令牌的类型(typ)和签名算法(alg)。通常情况下,头部会包含以下信息:
javascript
{
"alg": "HS256",
"typ": "JWT"
}
-
alg:指定签名算法,常见的有HMAC SHA256(HS256)和RSA SHA256(RS256)等。
-
typ:指定令牌的类型,一般为JWT。
头部需要经过Base64编码后作为JWT的第一部分。
- 载荷(Payload):JWT的载荷是存储实际数据的部分,也是一个JSON对象。它包含了一些声明(claims),用于描述令牌的信息。常见的声明有:
-
iss(Issuer):令牌的发行者。
-
sub(Subject):令牌所面向的用户。
-
aud(Audience):令牌的接收者。
-
exp(Expiration Time):令牌的过期时间。
-
nbf(Not Before):令牌的生效时间。
-
iat(Issued At):令牌的发行时间。
-
jti(JWT ID):令牌的唯一标识符。
示例:
javascript
{
"sub": "1234567890",
"name": "John Doe",
"admin": true
}
载荷也需要经过Base64编码后作为JWT的第二部分。
- 签名(Signature):JWT的签名是由头部、载荷和密钥组成的字符串,用于验证JWT的完整性和真实性。签名的生成方式取决于指定的签名算法。
-
对于HMAC SHA256,签名的生成方式为:HMACSHA256(base64UrlEncode(header) + "." + base64UrlEncode(payload), secret)。
-
对于RSA SHA256,签名的生成方式为:RSASHA256(base64UrlEncode(header) + "." + base64UrlEncode(payload), privateKey)。
生成的签名将作为JWT的第三部分。
最终,将经过Base64编码的头部、载荷和签名用点号连接起来,形成最终的JWT:
javascript
base64UrlEncode(header) + "." + base64UrlEncode(payload) + "." + signature
JWT的结构示例:
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c
需要注意的是,JWT中的信息是经过Base64编码的,虽然可以通过Base64解码获取原始内容,但是不能修改JWT中的内容,因为签名会验证JWT的完整性和真实性。
三、Jwt的工具类的使用
1. 依赖
在后端项目中导入依赖:
在properties配置标签中
XML<jwt.version>0.9.1</jwt.version> <java.jwt.version>3.4.0</java.jwt.version>
在dependencies配置标签中
XML<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
java
package com.CloudJun.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 :
java
package com.CloudJun.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 = false;// 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 :
java
package com.CloudJun.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
java
@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 ) 进行对以上编写的类及过滤器进行配置
XML
<!--CrosFilter跨域过滤器-->
<filter>
<filter-name>corsFilter</filter-name>
<filter-class>com.CloudJun.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.CloudJun.ssm.jwt.JwtFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>jwtFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
6. 测试类
在对JWT进行测试,创建一个测试类,编写以下方法
注 : 在测试类中需要增加以下代码
java
private SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
用于生成JWT
测试方法一 :
test1()
java@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)); }
解析Jwt
测试方法二 :
test2()
用以上生成的JWT字符串进行解析
java@Test public void test2() {// 解析oldJwt //io.jsonwebtoken.ExpiredJwtException:JWT过期异常 //io.jsonwebtoken.SignatureException:签名异常 String newJwt="eyJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJ6a2luZyIsImV4cCI6MTY5NzE4Nzc0OSwiaWF0IjoxNjk3MTg1OTQ5LCJhZ2UiOjE4LCJqdGkiOiJlNGZlOWFjYWY0Njk0YTZmYjg4ZmVkNjE3NGEyZGUxZiIsInVzZXJuYW1lIjoienNzIn0.ThB8lHAw4mfPdwoTE6gnzWYN2hZbaNxvt4n2QYDOOEE"; 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)); }
复制jwt,并延时30分钟
测试方法三 :
test3()
将以上生成的JWT字符串进行延时&复制
java@Test public void test3() {// 复制jwt,并延时30分钟 String oldJwt = "eyJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJ6a2luZyIsImV4cCI6MTY5NzE4Nzc0OSwiaWF0IjoxNjk3MTg1OTQ5LCJhZ2UiOjE4LCJqdGkiOiJlNGZlOWFjYWY0Njk0YTZmYjg4ZmVkNjE3NGEyZGUxZiIsInVzZXJuYW1lIjoienNzIn0.ThB8lHAw4mfPdwoTE6gnzWYN2hZbaNxvt4n2QYDOOEE"; 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)); }
测试JWT的有效时间
测试方法四 :
test4()
将以上生成的JWT字符串进行测试有效时间
java@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)); }
测试过期JWT的解析
测试方法五 :
test5()
测试过期JWT的解析
java@Test public void test5() {// 三秒后再解析上面过期时间只有三秒的令牌,因为过期则会报错io.jsonwebtoken.ExpiredJwtException //String oldJwt = "eyJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2MzU1NjMzODIsImlhdCI6MTYzNTU2MTU4MiwiYWdlIjoxOCwianRpIjoiN2RlYmIzM2JiZTg3NDBmODgzNDI5Njk0ZWE4NzcyMTgiLCJ1c2VybmFtZSI6InpzcyJ1.F4pZFCjWP6wlq8v_udfhOkNCpErF5QlL7DXJdzXTHqE"; String oldJwt = "eyJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJ6a2luZyIsImV4cCI6MTY5NzE4MDM2MywiaWF0IjoxNjk3MTc4NTYzLCJhZ2UiOjE4LCJqdGkiOiJmYmVhOTUyZDVlMTA0OTFiODA5MjkxNDcxNjNlMDIxYiIsInVzZXJuYW1lIjoienNzIn0.63jn2lHoFzIrWJ0yS_mTOSTlLebwcF2P2wlzutapIqs"; 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)); }
四、应用
在我们的spa项目中找到state.js文件 ( src/store/state.js)进行编写 :
javascriptexport default { eduName: '默认值~~', jwt: '' }
在我们的spa项目中找到getters.js文件 ( src/store/getters.js)进行编写 :
javascriptexport default { getEduName: (state) => { return state.eduName; }, getJwt: (state) => { return state.jwt; } }
在我们的spa项目中找到mutations.js文件 ( src/store/mutations.js)进行编写 :
javascriptexport default { // type(事件类型): 其值为setEduName // payload:官方给它还取了一个高大上的名字:载荷,其实就是一个保存要传递参数的容器 setEduName: (state, payload) => { state.eduName = payload.eduName; }, setJwt: (state, payload) => { state.jwt = payload.jwt; } }
在我们的spa项目中找到main.js文件,进行编写 :
javascript/* eslint-disable no-new */ window.mm = new Vue({ el: '#app', router, store, data() { return { bus: new Vue() } }, components: { App }, template: '<App/>' })
在我们的spa项目中找到http.js文件 ( src/api/http.js)进行编写请求拦截器 & 响应拦截器 :
javascript// 请求拦截器 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); });
在执行目录开启前端项目,并且打开idea开启后台项目(服务器),进行测试效果 :