【JWT】快速了解什么是jwt及如何使用jwt

小鱼儿 2024-02-22 08:54 73阅读 0赞

## 一、导言 ##

### 1、什么是jwt及组成部分 ###

>  **JWT（JSON Web Token）**是一种用于在网络应用间安全传递声明（claim）的开放标准。它由三部分组成：**头部（Header）**、**载荷（Payload）**和**签名（Signature）**。
> 
> 头部主要包含了用于描述 JWT 类型以及所使用的签名算法的信息。载荷包含了需要传递的声明（claim），比如用户身份、权限等信息。签名则是对头部、载荷和一个密钥进行的签名，用于验证数据的完整性。

#### 1.1 Header ####

> \{"typ":"JWT","alg":"HS256"\}  
> 这个json中的typ属性，用来标识整个token字符串是一个JWT字符串；它的alg属性，用来说明这个JWT签发的时候所使用的签名和摘要算法  
> typ跟alg属性的全称其实是type跟algorithm，分别是类型跟算法的意思。之所以都用三个字母来表示，也是基于JWT最终字串大小的考虑，  
> 同时也是跟JWT这个名称保持一致，这样就都是三个字符了…typ跟alg是JWT中标准中规定的属性名称

#### 1.2 Payload(负荷) ####

> \{"sub":"123","name":"Tom","admin":true\}  
> payload用来承载要传递的数据，它的json结构实际上是对JWT要传递的数据的一组声明，这些声明被JWT标准称为claims， 它的一个“属性值对”其实就是一个claim(要求)， 每一个claim的都代表特定的含义和作用。
> 
> 1.  英文“claim”就是要求的意思
> 2.  如上面结构中的sub代表这个token的所有人，存储的是所有人的ID；name表示这个所有人的名字；admin表示所有人是否管理员的角色。 当后面对JWT进行验证的时候，这些claim都能发挥特定的作用
> 3.  根据JWT的标准，这些claims可以分为以下三种类型：
> 
> **A. Reserved claims(保留)**  
> 它的含义就像是编程语言的保留字一样，属于JWT标准里面规定的一些claim。JWT标准里面定义好的claim有：  
> iss(Issuser)：代表这个JWT的签发主体；  
> sub(Subject)：代表这个JWT的主体，即它的所有人；  
> aud(Audience)：代表这个JWT的接收对象；  
> exp(Expiration time)：是一个时间戳，代表这个JWT的过期时间；  
> nbf(Not Before)：是一个时间戳，代表这个JWT生效的开始时间，意味着在这个时间之前验证JWT是会失败的；  
> iat(Issued at)：是一个时间戳，代表这个JWT的签发时间；  
> jti(JWT ID)：是JWT的唯一标识。  
> **B. Public claims**
> 
> **C. Private claims(私有)**  
> 这个指的就是自定义的claim，比如前面那个示例中的admin和name都属于自定的claim。这些claim跟JWT标准规定的claim区别在于：JWT规定的claim，  
> JWT的接收方在拿到JWT之后，都知道怎么对这些标准的claim进行验证；而private claims不会验证，除非明确告诉接收方要对这些claim进行验证以及规则才行
> 
> 按照JWT标准的说明：保留的claims都是可选的，在生成payload不强制用上面的那些claim，你可以完全按照自己的想法来定义payload的结构，不过这样搞根本没必要：  
> 第一是，如果把JWT用于认证， 那么JWT标准内规定的几个claim就足够用了，甚至只需要其中一两个就可以了，假如想往JWT里多存一些用户业务信息，  
> 比如角色和用户名等，这倒是用自定义的claim来添加；第二是，JWT标准里面针对它自己规定的claim都提供了有详细的验证规则描述，  
> 每个实现库都会参照这个描述来提供JWT的验证实现，所以如果是自定义的claim名称，那么你用到的实现库就不会主动去验证这些claim

#### 1.3 signature ####

> 签名是把header和payload对应的json结构进行base64url编码之后得到的两个串用英文句点号拼接起来，然后根据header里面alg指定的签名算法生成出来的。  
> 算法不同，签名结果不同。以alg: HS256为例来说明前面的签名如何来得到。  
> 按照前面alg可用值的说明，HS256其实包含的是两种算法：HMAC算法和SHA256算法，前者用于生成摘要，后者用于对摘要进行数字签名。这两个算法也可以用HMACSHA256来统称

### 2、为什么要使用jwt ###

> JWT 的主要优势在于它的无状态性和自包含性。因为 JWT 包含了所有需要的信息，在服务端不需要存储任何状态，只需通过密钥验证 JWT 的有效性即可。这使得 JWT 在分布式系统中非常适用。
> 
>  JWT的精髓在于：“去中心化”，数据是保存在客户端的。

### 3、jwt的工作原理 ###

> **JWT 的工作原理如下：**
> 
> 1.  用户使用有效的凭证（如用户名和密码）进行身份认证；
> 2.  服务器验证凭证成功后，生成一个 JWT 并将其发送给客户端；
> 3.  客户端将 JWT 存储起来，通常是在前端的本地存储中（如浏览器的 localStorage 或移动端的 Keychain）；
> 4.  客户端在每次与服务器通信时都将 JWT 在请求头或请求参数中携带；
> 5.  服务器对 JWT 进行验证和解码，以获取其中的信息并验证签名的有效性；
> 6.  如果验证成功，服务器可以根据其中的声明来授权用户访问特定资源。
> 
> **简化工作原理的步骤：**
> 
> 1.  是在服务器身份验证之后，将生成一个JSON对象并将其发送回用户
> 2.  之后，当用户与服务器通信时，客户在请求中发回JSON对象
> 3.  为了防止用户篡改数据，服务器将在生成对象时添加签名，并对发回的数据进行验证

![177323217c134be69a75c8981a8c5fe3.png][]

## 二、jwt工具类 ##

> 我们这里提供一个写好的jwt工具类，在这之前我们要导入**jwt**的**pom**文件

**pom.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>

**JwtUtils.java**

package com.tgq.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("tgq")
    				// 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的方法。
> 
> 第一个参数放的是我们的用户信息；第二个参数的意思是活着的时间，这代码里面我们设置的时间是30分钟
> 
>     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("tgq")
>     				// 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的方法
> 
>     public static Claims parseJwt(String jwt) {
>     		Claims claims = Jwts.parser()
>     				.setSigningKey(JWT_KEY)
>     				.parseClaimsJws(jwt)
>     				.getBody();
>     		return claims;
>     	}

> 复制jwt的方法
> 
> 这个方法的作用是将现有的jwt的有效时间延长
> 
>     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的使用 ##

> 我们编写测试一下jwt的功能

**创建jwt**

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

![871497c7a88245dc99914dd84073b1c8.png][]

**解析jwt**

@Test
    	public void test2() {// 解析oldJwt
    		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));
    	}

> 使用已经过期的jwt令牌会报错，我们只需要用我们新生成的jwt就可以编译出来。

![de078ff95f1042b496d6aaf6e5660a94.png][]

![5c9f3eb019894d6a8ec7a2a0dfe50572.png][]

**延长jwt的时间**

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

![46270a825a2442ea95410d9233ac2616.png][]

## 四、jwt运用（与SPA项目结合） ##

> 在这之前我们要确保我们的后台登陆方法有jwt的使用，还有我们的**jwt校验也就是过滤器**。

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

**JwtFilter**

package com.tgq.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 tgq
     *
     */
    
    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);
    	// }
    
    }

> 运用之前我们就要问到我们的跨域问题了，我们要运用这个跨域问题。
> 
> **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() {
>     
>     	}
>     }

**state.js**

export default {
      stateName:'王德法',
      jwt:''
    }

**mutations.js**

export default {
      // state == state.js文件中导出的对象；payload是vue文件传过来的参数
      setName: (state, payload) => {
        state.stateName = payload.stateName
      },
      setJwt: (state, payload) => {
        state.jwt = payload.jwt
      }
    }

**getters.js**

export default {
      // state == state.js文件中导出的对象；payload是vue文件传过来的参数
      getName: (state) => {
        return state.stateName;
      },
      getJwt: (state) => {
        return state.jwt;
      }
    }

**http.js**

// 请求拦截器
    axios.interceptors.request.use(function (config) {
      var jwt = window.ss.$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) {
        //将响应头中的jwt串放入state.js中
        window.ss.$store.commit('setJwt', {
          jwt: jwt
        })
      }
      return response;
    }, function (error) {
      return Promise.reject(error);
    });

> 记得在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>

> **main.js**
> 
>     // The Vue build version to load with the `import` command
>     // (runtime-only or standalone) has been set in webpack.base.conf with an alias.
>     import Vue from 'vue'
>     //开发环境下才会引入mockjs
>     // process.env.MOCK && require('@/mock')
>     // 新添加1
>     import ElementUI from 'element-ui'
>     // 新添加2，避免后期打包样式不同，要放在import App from './App';之前
>     import 'element-ui/lib/theme-chalk/index.css'
>     
>     import App from './App'
>     import router from './router'
>     import store from './store'
>     
>     // 新添加3----实例进行一个挂载
>     Vue.use(ElementUI)
>     Vue.config.productionTip = false
>     
>     import axios from '@/api/http'
>     import VueAxios from 'vue-axios'
>     
>     Vue.use(VueAxios, axios)
>     
>     /* eslint-disable no-new */
>     window.ss = new Vue({
>       el: '#app',
>       router,
>       store,
>       //定义变量
>       data() {
>         return {
>           Bus: new Vue()
>         }
>       },
>       components: {App},
>       template: '<App/>'
>     })
> 
> 记得更改**window.ss**。
> 
> ![4a4aa98e8a6a43f98c871208c71453d6.png][]
> 
> 直接运行有出现令牌出错，这就需要我们登录了。
> 
> ![3dfb5c67bb444f4783323c5c2ef22daa.png][]![80ec804e6759409f9241220b41cee895.png][]

[177323217c134be69a75c8981a8c5fe3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/7e24480e93cb4cbfb0e09742ac083ef9.png
[871497c7a88245dc99914dd84073b1c8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/fe8bb203fef045b1801f252206c089b6.png
[de078ff95f1042b496d6aaf6e5660a94.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/c4b085dd4a0d4692a169cada09573cdc.png
[5c9f3eb019894d6a8ec7a2a0dfe50572.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/bb7bf1b925fc4c3899b54ff6a9156fdb.png
[46270a825a2442ea95410d9233ac2616.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/30b601a66d044a4f9c4fe4b2268238fe.png
[4a4aa98e8a6a43f98c871208c71453d6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/57af8417f24844e5877e20b99bcb9183.png
[3dfb5c67bb444f4783323c5c2ef22daa.png]: https://img-blog.csdnimg.cn/3dfb5c67bb444f4783323c5c2ef22daa.png
[80ec804e6759409f9241220b41cee895.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/7e673acc52a341b6bf6add66e3e928a0.png