jwt详细介绍

已于 2023-10-14 00:38:31 修改
阅读量380 收藏
点赞数
文章标签： jwt
于 2023-10-14 00:25:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74018330/article/details/133819359
版权

jwt详细介绍

1.jwt 简介：

。JWT（JSON Web Token）
是一种用于安全传输信息的开放标准（RFC 7519）。它由三部分组成：头部（header）、负载（payload）和签名（signature）。

头部包含了关于该JWT的元数据，如使用的加密算法类型等。负载存储了需要传输的数据，比如用户的身份信息、权限等。签名是由头部、负载和一个密钥生成的，用于验证JWT是否被篡改。

JWT的工作流程如下：

用户登录时，服务器验证用户的身份，并生成一个JWT。
服务器将JWT发送给客户端，并保存在客户端的存储介质中（通常是浏览器的Cookie或本地存储）。
客户端在后续的请求中将JWT通过HTTP头部或请求参数的方式发送给服务器。
服务器接收到JWT后，会对其进行验证，包括验证签名的有效性、判断JWT是否过期等。
如果JWT验证通过，服务器可以使用其中的数据来完成相应的操作，比如认证用户身份、授权等。
JWT的优点包括：

简洁：JWT使用JSON格式存储数据，使得它更易读、编写和解析。
自包含：JWT中包含了所有必要的信息，减少了服务器查询数据库的次数。
可扩展：JWT的负载部分可以自定义，可以根据需要添加额外的字段。
安全性：通过使用签名和密钥，JWT可以验证数据的完整性和源信任。
然而，需要注意的是，由于JWT是基于客户端存储的，因此在使用时需要考虑到安全性问题，比如防止JWT被篡改、泄露等。

2.jwt 工具类介绍

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

这段代码是一个用于生成和解析JWT（JSON Web Token）的工具类。JWT是一种用于安全传输信息的开放标准，通过使用签名和密钥来验证数据的完整性和源信任。

该工具类包括以下功能：

解密JWT：根据传入的JWT字符串，使用密钥对其进行解密，获取其中的所有声明（包括标准和私有声明）。

创建JWT令牌：根据传入的私有声明、有效时间等参数，生成一个新的JWT令牌，并返回该令牌。

复制JWT：根据传入的JWT字符串和有效时间，复制并重新设置JWT的签发时间和失效时间，并返回新的JWT字符串。

在构建JWT时，该工具类使用了Apache Commons Codec库中的Base64类进行编码和解码操作。另外，使用了io.jsonwebtoken库提供的JwtBuilder和Jwts类进行JWT的创建和解析操作。

需要注意的是，JWT_SECRET是一个密钥字符串，用于生成加密key，并且应当保持安全；JWT_WEB_TTL是JWT的有效时间，默认为30分钟；JWT_HEADER_KEY是将JWT令牌保存到HTTP头部中的键名。

此外，在使用该工具类时，需要按照一定的顺序配置过滤器，以确保JWT验证的正确进行。

总体而言，这个工具类提供了便捷的方法来生成和解析JWT令牌，方便在WEB应用中进行身份验证和授权操作。
工具类测试

package com.zking.ssm.service.impl;

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

import com.zking.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.eyJpc3MiOiJ6a2luZyIsImV4cCI6MTY5NzIxMTkxNywiaWF0IjoxNjk3MjEwMTE3LCJhZ2UiOjE4LCJqdGkiOiJlMmM1MDViYTcyMDA0NjZjOGVjNzExMTc4NjBiM2QzYiIsInVzZXJuYW1lIjoienNzIn0.FUWLkxJD64JyT_PepC2sxlOc1TFHBOQc_Fx3xHoDn2Y";
		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.eyJpc3MiOiJ6a2luZyIsImV4cCI6MTY5NzIxMTkxNywiaWF0IjoxNjk3MjEwMTE3LCJhZ2UiOjE4LCJqdGkiOiJlMmM1MDViYTcyMDA0NjZjOGVjNzExMTc4NjBiM2QzYiIsInVzZXJuYW1lIjoienNzIn0.FUWLkxJD64JyT_PepC2sxlOc1TFHBOQc_Fx3xHoDn2Y";
		//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));
	}

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

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

这段代码包含了几个测试方法，用于演示JWT的生成、解析和复制功能。

test1() 方法：生成JWT

首先定义了一个包含私有声明的 Map 对象，其中包括了用户的用户名和年龄信息。
然后调用 JwtUtils.createJwt() 方法生成JWT令牌，并将令牌打印输出。
接着使用 JwtUtils.parseJwt() 方法解析JWT，获取其中的声明信息并打印出来，包括标准声明和私有声明。
最后打印出令牌的签发时间和过期时间。
在这里插入图片描述

test2() 方法：解析JWT

将一个已经生成的 JWT 令牌传入 JwtUtils.parseJwt() 方法进行解析。
使用循环遍历的方式打印出解析后的所有声明信息，包括标准声明和私有声明。
打印出令牌的签发时间和过期时间。
在这里插入图片描述
test3() 方法：复制JWT并延时30分钟
将一个已经生成的 JWT 令牌传入 JwtUtils.copyJwt() 方法进行复制，同时指定新的有效时间（延时30分钟）。
返回复制后的新的 JWT 令牌并打印出来。
使用 JwtUtils.parseJwt() 方法解析新的 JWT 令牌，打印出所有声明信息，并打印出令牌的签发时间和过期时间。
在这里插入图片描述

test4() 方法：测试JWT的有效时间

定义一个只包含用户名信息的私有声明。
调用 JwtUtils.createJwt() 方法生成 JWT 令牌，并指定有效时间为3秒。
打印出生成的 JWT 令牌。
使用 JwtUtils.parseJwt() 方法解析 JWT 令牌，打印出令牌的签发时间和过期时间。
在这里插入图片描述

test5() 方法：测试JWT过期

将一个已经过期的 JWT 令牌传入 JwtUtils.parseJwt() 方法进行解析。
由于令牌已经过期，解析时会抛出 io.jsonwebtoken.ExpiredJwtException 异常，不会执行后续代码
在这里插入图片描述
工具类测试结果。

3.案列演示：

1.前面提到过JWT跨语言那就涉及到跨域问题，首先在我们的过滤器里面加入允许JWT的跨域请求

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.1并在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
  >

3.2过滤

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

state

export default{
	eduName:'猪猪教育',
	jwt:''
}

getters

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

mutation

export default{
	setName:(state,payload)=>{
		state.eduName=payload.eduName;
	},setJwt:(state,payload)=>{
		state.jwt=payload.jwt;
	}
}

3.3全局响应设置

/**
 * vue项目对axios的全局配置
 */
import axios from 'axios'
import qs from 'qs'

//引入action模块，并添加至axios的类属性urls上
import action from '@/api/action'
axios.urls = action

// axios默认配置
axios.defaults.timeout = 10000; // 超时时间
// axios.defaults.baseURL = 'http://localhost:8080/j2ee15'; // 默认地址
axios.defaults.baseURL = action.SERVER;

//整理数据
// 只适用于 POST,PUT,PATCH，transformRequest` 允许在向服务器发送前，修改请求数据
axios.defaults.transformRequest = function(data) {
	data = qs.stringify(data);
	return data;
};


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

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

// // 路由请求拦截
// // http request 拦截器
// axios.interceptors.request.use(
// 	config => {
// 		//config.data = JSON.stringify(config.data);  
// 		//config.headers['Content-Type'] = 'application/json;charset=UTF-8';
// 		//config.headers['Token'] = 'abcxyz';
// 		//判断是否存在ticket，如果存在的话，则每个http header都加上ticket
// 		// if (cookie.get("token")) {
// 		// 	//用户每次操作，都将cookie设置成2小时
// 		// 	cookie.set("token", cookie.get("token"), 1 / 12)
// 		// 	cookie.set("name", cookie.get("name"), 1 / 12)
// 		// 	config.headers.token = cookie.get("token");
// 		// 	config.headers.name = cookie.get("name");
// 		// }
// 		return config;
// 	},
// 	error => {
// 		return Promise.reject(error.response);
// 	});

// // 路由响应拦截
// // http response 拦截器
// axios.interceptors.response.use(
// 	response => {
// 		if (response.data.resultCode == "404") {
// 			console.log("response.data.resultCode是404")
// 			// 返回 错误代码-1 清除ticket信息并跳转到登录页面
// 			//      cookie.del("ticket")
// 			//      window.location.href='http://login.com'
// 			return
// 		} else {
// 			return response;
// 		}
// 	},
// 	error => {
// 		return Promise.reject(error.response) // 返回接口返回的错误信息
// 	});



export default axios;
匿瘾:
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JWT（简介）
qq_65345936的博客
09-18 2057
JWT工具类/*** JWT验证过滤器：配置顺序 CorsFilte->JwtUtilsr-->StrutsPrepareAndExecuteFilter**//*** JWT_WEB_TTL：WEBAPP应用中token的有效时间,默认30分钟*//*** 将jwt令牌保存到header中的key*/// 指定签名的时候使用的签名算法，也就是header那部分，jjwt已经将这部分内容封装好了。// JWT密匙// 使用JWT密匙生成的加密key。
Jwt介绍
weixin_66202611的博客
09-17 1505
JWT运行机制1.第一次发送登录请求，必然会携带用户信息（用户名&密码）2.通过用户信息（用户名&密码）登录成功，会将用户信息通过jwt工具类生成一个加密的字符串3.加密字符串 会以 response header 响应头的形式 响应到前端4.前端服务器，会有响应拦截器拦截，截取到响应头承载的jwt串，有会放到Vuex中5.当第二次请求，前端服务器中有一个请求拦截器，会将Vuex中的jwt串放入request header请求头中的jwt串。
JWT 简介
weixin_34194317的博客
05-03 164
本文翻译自JWT官方网站对JWT是什么以及能做什么的简介。 JWT是一种用于双方之间传递安全信息的简洁的、URL安全的表述性声明规范。JWT作为一个开放的标准（RFC 7519），定义了一种简洁的，自包含的方法用于通信双方之间以Json对象的形式安全的传递信息。因为数字签名的存在，这些信息是可信的，JWT可以使用HMAC算法或者是RSA的...
【JWT】基本使用
luojingam的博客
01-11 304
简介: JSON Web Token（JWT）是一个开放的行业标准（RFC 7519），它定义了一种简洁的、自包含的协议格式，用于在通信双方传递json对象，传递的信息经过数字签名可以被验证和信任。 JWT令牌结构： JWT令牌由Header、Payload、Signature三部分组成，每部分中间使用点（.）分隔，比如：xxxxx.yyyyy.zzzzz Header --头部包括令牌的类型（即JWT）及使用的哈希算法（如HMAC、SHA256或RSA）。 { "alg": "HS256"，
JWT介绍
qq_30525851的博客
06-06 278
提到jwt首先想到的就是token，jwt跟token又有什么关系呢？大致知道jwt是生成和解析token的，但具体什么是jwt，为什么要用jwt，工作原理是什么？
通俗易懂的详细介绍Springboot如何集成/整合JWT
01-18
文章大体结构如下，若对你有启发，请点赞支持一下！谢谢 1.定义 2.优点 3.缺点 4.组成 4.1.头部(header) 4.2.载荷(payload) 4.3.签证(signature) 5.应用 ...（2）实现跳过认证（AuthAccess）或需要认证（USERLOGINTOKEN...
JWT Token实现方法及步骤详解
09-07
主要介绍了JWT Token实现方法及步骤详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
gateway和jwt网关认证实现过程解析
08-25
主要介绍了gateway和jwt网关认证实现过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
SpringSecurity整合Jwt过程图解
08-25
主要介绍了SpringSecurity整合Jwt过程图解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
基于springboot+jwt实现刷新token过程解析
08-19
主要介绍了基于springboot+jwt实现刷新token过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Ruby-JWTRFC7519OAuthJSONWebTokenJWT标准的一个纯Ruby实现
08-15
JWT - RFC 7519 OAuth JSON Web Token (JWT)标准的一个纯Ruby实现
JWT的介绍
凉茶铺的博客
04-28 548
介绍了JWT的基本概念和其使用方式
jwt简单介绍
远方的少年
11-09 609
jwt全称为jsonwebtoken,尤其在前后端分离的情形下，由于它自包含，轻量安全的特性常常使用在后端用户权限校验中。 jwt由三部分组成 1.头部(header) 常包含1加密算法 2token类型 2.载荷(payload) 包含颁发者，有效期等和用户自定义属性 3.签名 下面演示在Java中如何使用Jwt 1.引入依赖 <dependency> ...
JWT基本介绍
qq_51133939的博客
08-14 4621
JWT基本介绍
JWT简介
HsiunKao
12-15 482
JWT简介什么是JWTJWT组成headerpayloadSignature一些想法，不知道是不是对的。 什么是JWT Json web token (JWT), 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准（(RFC 7519).该token被设计为紧凑且安全的，特别适用于分布式站点的单点登录（SSO）场景。JWT的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份...
JWT基础介绍
Alan0517
03-13 1902
有状态服务，即服务端需要记录每次会话的客户端信息，从而识别客户端身份，根据用户身份进行请求的处理，典型的设计如tomcat中的session。例如登录：用户登录后，我们把登录者的信息保存在服务端session中，并且给用户一个cookie值，记录对应的session。然后下次请求，用户携带cookie值来，我们就能识别到对应session，从而找到用户的信息。缺点是什么？服务端保存大量数据，增加服务端压力服务端保存用户状态，无法进行水平扩展客户端请求依赖服务端，多次请求必须访问同一台服务器。
【ChirpStack 】如何获取 JWT TOKEN并利用 API 下发数据？
欢迎来到博客主页
05-09 1686
LoRa App Server 提供了两类 API 接口，其中 RESTful JSON API 提供了一个 API console，在AS地址的基础上使用 /api 即可访问，罗列了 API 端点和文档介绍，测试起来非常方便。 本文主要介绍 如何使用 chirpstack 的API 进行测试以及如何获取 JWT TOKEN。
使用jwt在请求头中获取token从而获取用户信息
weixin_42759398的博客
04-09 3393
在 Spring Boot 项目中使用 JWT，你可以从请求头中获取 JWT，然后使用 JWT 中的信息来获取用户信息，然后进行业务处理。一般情况下，JWT 的信息会包含用户 ID、用户名、角色等信息，你可以根据这些信息来确定用户的身份和权限。在这个示例中，我们使用 @RequestHeader 注解从请求头中获取 JWT，然后使用 JJWT 库解析 JWT 中的信息。在解析 JWT 后，我们可以从 JWT 中获取用户 ID，然后使用 UserService 来获取用户信息。
详细介绍一下session cookie token jwt
最新发布
08-09
### 回答1： Session、Cookie、Token、JWT都是在Web开发中用于管理用户身份认证和会话管理的工具。 1. Session：Session指的是服务器端保存的用户信息。当用户登录成功后，服务器会创建一个session，为该用户分配一个session ID，并将该ID保存到cookie中，发送给客户端。客户端浏览器保存了这个cookie，以后每次请求都会带上这个cookie，服务器通过这个cookie就可以识别出用户身份，从而进行相应的操作。Session机制存在一定的风险，比如会话劫持、会话固定等问题，需要注意安全性。 2. Cookie：Cookie是一种客户端保存用户信息的机制，它是由服务器在响应HTTP请求时通过Set-Cookie头部字段发给客户端浏览器的一小段文本信息。浏览器将这些信息保存在客户端，以后每次向服务器发送请求时都会自动带上这些cookie，从而实现身份认证和会话管理。但是Cookie也存在一些安全问题，比如会话劫持、跨站脚本攻击等问题。 3. Token：Token是一种用户身份认证和授权的机制，通常由服务器生成，以便在客户端和服务端之间进行身份认证和授权。客户端在登录成功后，服务器会为该用户生成一个Token，并将Token发送给客户端浏览器。客户端在之后的请求中需要携带该Token，服务器验证Token的有效性后，就可以识别出用户身份，并进行相应的操作。Token相比Session和Cookie，具有更高的安全性和可扩展性。 4. JWT：JWT是一种基于Token的身份认证和授权机制。JWT包含三部分，分别是头部、载荷和签名。头部包含加密算法和类型等信息；载荷包含用户的身份信息和相关的元数据等信息；签名则是对头部和载荷进行签名生成的一段密文，用于验证Token的有效性。JWT具有无状态、可扩展、跨域等特点，被广泛用于Web开发中的用户身份认证和授权。 ### 回答2： Session、Cookie、Token和JWT都是常见的身份验证和会话管理方法。下面我会分别介绍它们。 Session：Session是服务器端记录用户状态的一种机制。当用户通过用户名和密码登录后，服务器会为该用户创建一个唯一的Session。之后，用户再发送请求时，服务器会根据Session来识别用户并获取用户的状态信息。 Cookie：Cookie是一种在客户端存储的小型文本文件。在用户通过用户名和密码登录成功后，服务器可以将一个包含Session信息的Cookie发送给客户端，客户端会将该Cookie保存下来。之后，客户端发送请求时，会自动附带上该Cookie，用于向服务器证明用户的身份。 Token：Token是一种代表用户身份的令牌。与Cookie不同，Token是在客户端保存的，并且不需要服务器端存储用户状态。当用户登录成功后，服务器会生成一个Token并发送给客户端，客户端将其保存起来。之后，客户端发送请求时，会将Token作为请求头信息的一部分发送给服务器，服务器根据Token验证用户身份。 JWT：JWT（JSON Web Token）是一种基于JSON的开放标准，用于在各方之间安全传输信息。它由三部分组成：Header、Payload和Signature。其中，Header用于描述JWT的元数据，Payload用于存储实际传输的数据，Signature用于验证JWT的合法性。在使用JWT进行身份验证时，服务器会生成一个JWT并发送给客户端，客户端将其保存起来。之后，客户端发送请求时，会将JWT作为请求头信息的一部分发送给服务器，服务器根据JWT验证用户身份的合法性。 总结：Session、Cookie、Token和JWT都是常用于身份验证和会话管理的方法，它们各有优劣和适用场景。Session和Cookie依赖于服务器端存储用户状态，而Token和JWT则可以减轻服务器的负担，并且适用于分布式系统。其中，JWT由于其自包含性和可扩展性，在分布式系统和前后端分离的架构中得到了广泛应用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值