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

    一、导言

    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.  为了防止用户篡改数据，服务器将在生成对象时添加签名，并对发回的数据进行验证

    二、jwt工具类

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

    pom.xml

    1. <dependency>
    2.             <groupId>io.jsonwebtokengroupId>
    3.             <artifactId>jjwtartifactId>
    4.             <version>${jwt.version}version>
    5.         dependency>
    6.         <dependency>
    7.             <groupId>com.auth0groupId>
    8.             <artifactId>java-jwtartifactId>
    9.             <version>${java.jwt.version}version>
    10.         dependency>

    JwtUtils.java

    1. package com.tgq.ssm.jwt;
    2.  
    3. import java.util.Date;
    4. import java.util.Map;
    5. import java.util.UUID;
    6.  
    7. import javax.crypto.SecretKey;
    8. import javax.crypto.spec.SecretKeySpec;
    9.  
    10. import org.apache.commons.codec.binary.Base64;
    11.  
    12. import io.jsonwebtoken.Claims;
    13. import io.jsonwebtoken.JwtBuilder;
    14. import io.jsonwebtoken.Jwts;
    15. import io.jsonwebtoken.SignatureAlgorithm;
    16.  
    17. /**
    18.  * JWT验证过滤器：配置顺序 CorsFilte->JwtUtilsr-->StrutsPrepareAndExecuteFilter
    19.  *
    20.  */
    21. public class JwtUtils {
    22. 	/**
    23. 	 * JWT_WEB_TTL：WEBAPP应用中token的有效时间,默认30分钟
    24. 	 */
    25. 	public static final long JWT_WEB_TTL = 30 * 60 * 1000;
    26.  
    27. 	/**
    28. 	 * 将jwt令牌保存到header中的key
    29. 	 */
    30. 	public static final String JWT_HEADER_KEY = "jwt";
    31.  
    32. 	// 指定签名的时候使用的签名算法，也就是header那部分，jwt已经将这部分内容封装好了。
    33. 	private static final SignatureAlgorithm SIGNATURE_ALGORITHM = SignatureAlgorithm.HS256;
    34. 	private static final String JWT_SECRET = "f356cdce935c42328ad2001d7e9552a3";// JWT密匙
    35. 	private static final SecretKey JWT_KEY;// 使用JWT密匙生成的加密key
    36.  
    37. 	static {
    38. 		byte[] encodedKey = Base64.decodeBase64(JWT_SECRET);
    39. 		JWT_KEY = new SecretKeySpec(encodedKey, 0, encodedKey.length, "AES");
    40. 	}
    41.  
    42. 	private JwtUtils() {
    43. 	}
    44.  
    45. 	/**
    46. 	 * 解密jwt，获得所有声明(包括标准和私有声明)
    47. 	 * 
    48. 	 * @param jwt
    49. 	 * @return
    50. 	 * @throws Exception
    51. 	 */
    52. 	public static Claims parseJwt(String jwt) {
    53. 		Claims claims = Jwts.parser()
    54. 				.setSigningKey(JWT_KEY)
    55. 				.parseClaimsJws(jwt)
    56. 				.getBody();
    57. 		return claims;
    58. 	}
    59.  
    60. 	/**
    61. 	 * 创建JWT令牌，签发时间为当前时间
    62. 	 * 
    63. 	 * @param claims
    64. 	 *            创建payload的私有声明（根据特定的业务需要添加，如果要拿这个做验证，一般是需要和jwt的接收方提前沟通好验证方式的）
    65. 	 * @param ttlMillis
    66. 	 *            JWT的有效时间(单位毫秒)，当前时间+有效时间=过期时间
    67. 	 * @return jwt令牌
    68. 	 */
    69. 	public static String createJwt(Map claims, 
    70. 			long ttlMillis) {
    71. 		// 生成JWT的时间，即签发时间 2021-10-30 10:02:00 -> 30 10:32:00
    72. 	
    73. 		long nowMillis = System.currentTimeMillis();
    74.  
    75. 		
    76. 		//链式语法：
    77. 		// 下面就是在为payload添加各种标准声明和私有声明了
    78. 		// 这里其实就是new一个JwtBuilder，设置jwt的body
    79. 		JwtBuilder builder = Jwts.builder()
    80. 				// 如果有私有声明，一定要先设置这个自己创建的私有的声明，这个是给builder的claim赋值，一旦写在标准的声明赋值之后，就是覆盖了那些标准的声明的
    81. 				.setClaims(claims)
    82. 				// 设置jti(JWT ID)：是JWT的唯一标识，根据业务需要，这个可以设置为一个不重复的值，主要用来作为一次性token,从而回避重放攻击。
    83. 				// 可以在未登陆前作为身份标识使用
    84. 				.setId(UUID.randomUUID().toString().replace("-", ""))
    85. 				// iss(Issuser)签发者，写死
    86. 				.setIssuer("tgq")
    87. 				// iat: jwt的签发时间
    88. 				.setIssuedAt(new Date(nowMillis))
    89. 				// 代表这个JWT的主体，即它的所有人，这个是一个json格式的字符串，可放数据{"uid":"zs"}。此处没放
    90. 				// .setSubject("{}")
    91. 				// 设置签名使用的签名算法和签名使用的秘钥
    92. 				.signWith(SIGNATURE_ALGORITHM, JWT_KEY)
    93. 				// 设置JWT的过期时间
    94. 				.setExpiration(new Date(nowMillis + ttlMillis));
    95.  
    96. 		return builder.compact();
    97. 	}
    98.  
    99. 	/**
    100. 	 * 复制jwt，并重新设置签发时间(为当前时间)和失效时间
    101. 	 * 
    102. 	 * @param jwt
    103. 	 *            被复制的jwt令牌
    104. 	 * @param ttlMillis
    105. 	 *            jwt的有效时间(单位毫秒)，当前时间+有效时间=过期时间
    106. 	 * @return
    107. 	 */
    108. 	public static String copyJwt(String jwt, Long ttlMillis) {
    109. 		//解密JWT，获取所有的声明（私有和标准）
    110. 		//old
    111. 		Claims claims = parseJwt(jwt);
    112.  
    113. 		// 生成JWT的时间，即签发时间
    114. 		long nowMillis = System.currentTimeMillis();
    115.  
    116. 		// 下面就是在为payload添加各种标准声明和私有声明了
    117. 		// 这里其实就是new一个JwtBuilder，设置jwt的body
    118. 		JwtBuilder builder = Jwts.builder()
    119. 				// 如果有私有声明，一定要先设置这个自己创建的私有的声明，这个是给builder的claim赋值，一旦写在标准的声明赋值之后，就是覆盖了那些标准的声明的
    120. 				.setClaims(claims)
    121. 				// 设置jti(JWT ID)：是JWT的唯一标识，根据业务需要，这个可以设置为一个不重复的值，主要用来作为一次性token,从而回避重放攻击。
    122. 				// 可以在未登陆前作为身份标识使用
    123. 				//.setId(UUID.randomUUID().toString().replace("-", ""))
    124. 				// iss(Issuser)签发者，写死
    125. 				// .setIssuer("zking")
    126. 				// iat: jwt的签发时间
    127. 				.setIssuedAt(new Date(nowMillis))
    128. 				// 代表这个JWT的主体，即它的所有人，这个是一个json格式的字符串，可放数据{"uid":"zs"}。此处没放
    129. 				// .setSubject("{}")
    130. 				// 设置签名使用的签名算法和签名使用的秘钥
    131. 				.signWith(SIGNATURE_ALGORITHM, JWT_KEY)
    132. 				// 设置JWT的过期时间
    133. 				.setExpiration(new Date(nowMillis + ttlMillis));
    134. 		return builder.compact();
    135. 	}
    136. }
    137.  
    138.  
    139.  
    140.

    解析代码：

            创建jwt的方法。

            第一个参数放的是我们的用户信息；第二个参数的意思是活着的时间，这代码里面我们设置的时间是30分钟

    1. public static String createJwt(Map claims, 
    2. 			long ttlMillis) {
    3. 		// 生成JWT的时间，即签发时间 2021-10-30 10:02:00 -> 30 10:32:00
    4. 	
    5. 		long nowMillis = System.currentTimeMillis();
    6.  
    7. 		
    8. 		//链式语法：
    9. 		// 下面就是在为payload添加各种标准声明和私有声明了
    10. 		// 这里其实就是new一个JwtBuilder，设置jwt的body
    11. 		JwtBuilder builder = Jwts.builder()
    12. 				// 如果有私有声明，一定要先设置这个自己创建的私有的声明，这个是给builder的claim赋值，一旦写在标准的声明赋值之后，就是覆盖了那些标准的声明的
    13. 				.setClaims(claims)
    14. 				// 设置jti(JWT ID)：是JWT的唯一标识，根据业务需要，这个可以设置为一个不重复的值，主要用来作为一次性token,从而回避重放攻击。
    15. 				// 可以在未登陆前作为身份标识使用
    16. 				.setId(UUID.randomUUID().toString().replace("-", ""))
    17. 				// iss(Issuser)签发者，写死
    18. 				.setIssuer("tgq")
    19. 				// iat: jwt的签发时间
    20. 				.setIssuedAt(new Date(nowMillis))
    21. 				// 代表这个JWT的主体，即它的所有人，这个是一个json格式的字符串，可放数据{"uid":"zs"}。此处没放
    22. 				// .setSubject("{}")
    23. 				// 设置签名使用的签名算法和签名使用的秘钥
    24. 				.signWith(SIGNATURE_ALGORITHM, JWT_KEY)
    25. 				// 设置JWT的过期时间
    26. 				.setExpiration(new Date(nowMillis + ttlMillis));
    27.  
    28. 		return builder.compact();
    29. 	}

            解析jwt的方法

            

    1. public static Claims parseJwt(String jwt) {
    2. 		Claims claims = Jwts.parser()
    3. 				.setSigningKey(JWT_KEY)
    4. 				.parseClaimsJws(jwt)
    5. 				.getBody();
    6. 		return claims;
    7. 	}

            复制jwt的方法

            这个方法的作用是将现有的jwt的有效时间延长

    1. public static String copyJwt(String jwt, Long ttlMillis) {
    2. 		//解密JWT，获取所有的声明（私有和标准）
    3. 		//old
    4. 		Claims claims = parseJwt(jwt);
    5.  
    6. 		// 生成JWT的时间，即签发时间
    7. 		long nowMillis = System.currentTimeMillis();
    8.  
    9. 		// 下面就是在为payload添加各种标准声明和私有声明了
    10. 		// 这里其实就是new一个JwtBuilder，设置jwt的body
    11. 		JwtBuilder builder = Jwts.builder()
    12. 				// 如果有私有声明，一定要先设置这个自己创建的私有的声明，这个是给builder的claim赋值，一旦写在标准的声明赋值之后，就是覆盖了那些标准的声明的
    13. 				.setClaims(claims)
    14. 				// 设置jti(JWT ID)：是JWT的唯一标识，根据业务需要，这个可以设置为一个不重复的值，主要用来作为一次性token,从而回避重放攻击。
    15. 				// 可以在未登陆前作为身份标识使用
    16. 				//.setId(UUID.randomUUID().toString().replace("-", ""))
    17. 				// iss(Issuser)签发者，写死
    18. 				// .setIssuer("zking")
    19. 				// iat: jwt的签发时间
    20. 				.setIssuedAt(new Date(nowMillis))
    21. 				// 代表这个JWT的主体，即它的所有人，这个是一个json格式的字符串，可放数据{"uid":"zs"}。此处没放
    22. 				// .setSubject("{}")
    23. 				// 设置签名使用的签名算法和签名使用的秘钥
    24. 				.signWith(SIGNATURE_ALGORITHM, JWT_KEY)
    25. 				// 设置JWT的过期时间
    26. 				.setExpiration(new Date(nowMillis + ttlMillis));
    27. 		return builder.compact();
    28. 	}

    三、jwt的使用

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

    创建jwt

    1. @Test
    2. 	public void test1() {// 生成JWT
    3. 		
    4. 		//JWT Token=Header.Payload.Signature
    5. 		//头部.载荷.签名
    6. 		//Payload=标准声明+私有声明+公有声明
    7. 		
    8. 		//定义私有声明
    9. 		Map claims = new HashMap();
    10. 		claims.put("username", "zss");
    11. 		claims.put("age", 18);
    12. 		
    13. 	    //TTL:Time To Live
    14. 		String jwt = JwtUtils.createJwt(claims, JwtUtils.JWT_WEB_TTL);
    15. 		System.out.println(jwt);
    16.  
    17. 		//获取Payload（包含标准和私有声明）
    18. 		Claims parseJwt = JwtUtils.parseJwt(jwt);
    19. 		for (Map.Entry entry : parseJwt.entrySet()) {
    20. 			System.out.println(entry.getKey() + "=" + entry.getValue());
    21. 		}
    22. 		Date d1 = parseJwt.getIssuedAt();
    23. 		Date d2 = parseJwt.getExpiration();
    24. 		System.out.println("令牌签发时间：" + sdf.format(d1));
    25. 		System.out.println("令牌过期时间：" + sdf.format(d2));
    26. 	}

    解析jwt

    1. @Test
    2. 	public void test2() {// 解析oldJwt
    3. 		String newJwt="eyJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJ6a2luZyIsImV4cCI6MTY2MjM0Njg3MSwiaWF0IjoxNjYyMzQ1MDcxLCJhZ2UiOjE4LCJqdGkiOiI4YjllNzc3YzFlMDM0MjViYThmMDVjNTFlMTU3NDQ1MiIsInVzZXJuYW1lIjoienNzIn0.UWpJxPxwJ09PKxE2SY5ME41W1Kv3jP5bZGKK-oNUDuM";
    4. 		//String oldJwt = "eyJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2MzU1NjE3MjcsImlhdCI6MTYzNTU1OTkyNywiYWdlIjoxOCwianRpIjoiN2RlYmIzM2JiZTg3NDBmODgzNDI5Njk0ZWE4NzcyMTgiLCJ1c2VybmFtZSI6InpzcyJ9.dUR-9JUlyRdoYx-506SxXQ3gbHFCv0g5Zm8ZGzK1fzw";
    5. 		Claims parseJwt = JwtUtils.parseJwt(newJwt);
    6. 		for (Map.Entry entry : parseJwt.entrySet()) {
    7. 			System.out.println(entry.getKey() + "=" + entry.getValue());
    8. 		}
    9. 		Date d1 = parseJwt.getIssuedAt();
    10. 		Date d2 = parseJwt.getExpiration();
    11. 		System.out.println("令牌签发时间：" + sdf.format(d1));
    12. 		System.out.println("令牌过期时间：" + sdf.format(d2));
    13. 	}

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

    延长jwt的时间

    1. @Test
    2. 	public void test3() {// 复制jwt，并延时30分钟
    3. 		String oldJwt = "eyJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJ0Z3EiLCJleHAiOjE2OTcxOTYzMzQsImlhdCI6MTY5NzE5NDUzNCwiYWdlIjoxOCwianRpIjoiM2Q3NmU1NjkwNDQzNDRkMjgxZTBmZjZkYjRlYjYwNzciLCJ1c2VybmFtZSI6InpzcyJ9.s0PQQT8-qSIhJRja5rR7_mZfbGLk9ZXbI1RCOk0nCi4";
    4. 		String newJwt = JwtUtils.copyJwt(oldJwt, JwtUtils.JWT_WEB_TTL);
    5. 		System.out.println(newJwt);
    6. 		Claims parseJwt = JwtUtils.parseJwt(newJwt);
    7. 		for (Map.Entry entry : parseJwt.entrySet()) {
    8. 			System.out.println(entry.getKey() + "=" + entry.getValue());
    9. 		}
    10. 		Date d1 = parseJwt.getIssuedAt();
    11. 		Date d2 = parseJwt.getExpiration();
    12. 		System.out.println("令牌签发时间：" + sdf.format(d1));
    13. 		System.out.println("令牌过期时间：" + sdf.format(d2));
    14. 	}

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

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

    1.   @RequestMapping("/userLogin")
    2.     @ResponseBody
    3.     public JsonResponseBody userLogin(UserVo userVo, HttpServletResponse response) {
    4.         if (userVo.getUsername().equals("admin") && userVo.getPassword().equals("123")) {
    5. //            私有要求claim
    6.             Map json=new HashMap();
    7.             json.put("username", userVo.getUsername());
    8. //            生成JWT，并设置到response响应头中
    9.             String jwt=JwtUtils.createJwt(json, JwtUtils.JWT_WEB_TTL);
    10.             response.setHeader(JwtUtils.JWT_HEADER_KEY, jwt);
    11.             return new JsonResponseBody<>("用户登陆成功！", true, 0, null);
    12.         } else {
    13.             return new JsonResponseBody<>("用户名或密码错误！", false, 0, null);
    14.         }
    15.     }

    JwtFilter 

    1. package com.tgq.ssm.jwt;
    2.  
    3. import java.io.IOException;
    4. import java.util.regex.Matcher;
    5. import java.util.regex.Pattern;
    6.  
    7. import javax.servlet.Filter;
    8. import javax.servlet.FilterChain;
    9. import javax.servlet.FilterConfig;
    10. import javax.servlet.ServletException;
    11. import javax.servlet.ServletRequest;
    12. import javax.servlet.ServletResponse;
    13. import javax.servlet.http.HttpServletRequest;
    14. import javax.servlet.http.HttpServletResponse;
    15.  
    16. import io.jsonwebtoken.Claims;
    17.  
    18. /**
    19.  * * JWT验证过滤器，配置顺序 ：CorsFilter-->JwtFilter-->struts2中央控制器
    20.  * 
    21.  * @author tgq
    22.  *
    23.  */
    24.  
    25. public class JwtFilter implements Filter {
    26.  
    27. 	// 排除的URL，一般为登陆的URL(请改成自己登陆的URL)
    28. 	private static String EXCLUDE = "^/user/userLogin?.*$";
    29.  
    30. 	private static Pattern PATTERN = Pattern.compile(EXCLUDE);
    31.  
    32. 	private boolean OFF = true;// true关闭jwt令牌验证功能
    33.  
    34. 	@Override
    35. 	public void init(FilterConfig filterConfig) throws ServletException {
    36. 	}
    37.  
    38. 	@Override
    39. 	public void destroy() {
    40. 	}
    41.  
    42. 	@Override
    43. 	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
    44. 			throws IOException, ServletException {
    45. 		HttpServletRequest req = (HttpServletRequest) request;
    46. 		HttpServletResponse resp = (HttpServletResponse) response;
    47. 		//获取当前请求路径。只有登录的请求路径不进行校验之外，其他的URL请求路径必须进行JWT令牌校验
    48. 		//http://localhost:8080/ssh2/bookAction_queryBookPager.action
    49. 		//req.getServletPath()==/bookAction_queryBookPager.action
    50. 		String path = req.getServletPath();
    51. 		if (OFF || isExcludeUrl(path)) {// 登陆直接放行
    52. 				chain.doFilter(request, response);
    53. 				return;
    54. 		}
    55.  
    56. 		// 从客户端请求头中获得令牌并验证
    57. 		//token=头.载荷.签名
    58. 		String jwt = req.getHeader(JwtUtils.JWT_HEADER_KEY);
    59. 		Claims claims = this.validateJwtToken(jwt);
    60. 		//在这里请各位大哥大姐从JWT令牌中提取payload中的声明部分
    61. 		//从声明部分中获取私有声明
    62. 		//获取私有声明中的User对象 -> Modules
    63. 		Boolean flag=false;
    64. 		if (null == claims) {
    65. 			// resp.setCharacterEncoding("UTF-8");
    66. 			resp.sendError(403, "JWT令牌已过期或已失效");
    67. 			return;
    68. 		} else {
    69. 			
    70. 			//1.获取已经解析后的payload（私有声明）
    71. 			//2.从私有声明中当前用户所对应的权限集合List或者List
    72. 			//3.循环权限(Module[id,url])
    73. 			// OK,放行请求 chain.doFilter(request, response);
    74. 			// NO,发送错误信息的JSON
    75. 			// ObjectMapper mapper=new ObjectMapper()
    76. 			// mapper.writeValue(response.getOutputStream(),json)
    77. 			
    78. 			String newJwt = JwtUtils.copyJwt(jwt, JwtUtils.JWT_WEB_TTL);
    79. 			resp.setHeader(JwtUtils.JWT_HEADER_KEY, newJwt);
    80. 			chain.doFilter(request, response);
    81. 		}
    82. 	}
    83.  
    84. 	/**
    85. 	 * 验证jwt令牌，验证通过返回声明(包括公有和私有)，返回null则表示验证失败
    86. 	 */
    87. 	private Claims validateJwtToken(String jwt) {
    88. 		Claims claims = null;
    89. 		try {
    90. 			if (null != jwt) {
    91. 				//该解析方法会验证：1）是否过期 2）签名是否成功
    92. 				claims = JwtUtils.parseJwt(jwt);
    93. 			}
    94. 		} catch (Exception e) {
    95. 			e.printStackTrace();
    96. 		}
    97. 		return claims;
    98. 	}
    99.  
    100. 	/**
    101. 	 * 是否为排除的URL
    102. 	 * 
    103. 	 * @param path
    104. 	 * @return
    105. 	 */
    106. 	private boolean isExcludeUrl(String path) {
    107. 		Matcher matcher = PATTERN.matcher(path);
    108. 		return matcher.matches();
    109. 	}
    110.  
    111. 	// public static void main(String[] args) {
    112. 	// String path = "/sys/userAction_doLogin.action?username=zs&password=123";
    113. 	// Matcher matcher = PATTERN.matcher(path);
    114. 	// boolean b = matcher.matches();
    115. 	// System.out.println(b);
    116. 	// }
    117.  
    118. }

    运用之前我们就要问到我们的跨域问题了，我们要运用这个跨域问题。

    CorsFilter 

    1. package com.zking.ssm.util;
    2.  
    3. import java.io.IOException;
    4.  
    5. import javax.servlet.Filter;
    6. import javax.servlet.FilterChain;
    7. import javax.servlet.FilterConfig;
    8. import javax.servlet.ServletException;
    9. import javax.servlet.ServletRequest;
    10. import javax.servlet.ServletResponse;
    11. import javax.servlet.http.HttpServletRequest;
    12. import javax.servlet.http.HttpServletResponse;
    13.  
    14. /**
    15.  * 配置tomcat允许跨域访问
    16.  * 
    17.  * @author Administrator
    18.  *
    19.  */
    20. public class CorsFilter implements Filter {
    21. 	@Override
    22. 	public void init(FilterConfig filterConfig) throws ServletException {
    23. 	}
    24. 	@Override
    25. 	public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)
    26. 			throws IOException, ServletException {
    27. 		HttpServletResponse httpResponse = (HttpServletResponse) servletResponse;
    28. 		HttpServletRequest req = (HttpServletRequest) servletRequest;
    29. 		// Access-Control-Allow-Origin就是我们需要设置的域名
    30. 		// Access-Control-Allow-Headers跨域允许包含的头。
    31. 		// Access-Control-Allow-Methods是允许的请求方式
    32. 		httpResponse.setHeader("Access-Control-Allow-Origin", "*");// *,任何域名
    33. 		httpResponse.setHeader("Access-Control-Allow-Methods", "POST, GET, PUT, DELETE");
    34. 		
    35. 		//允许客户端发一个新的请求头jwt
    36. 		httpResponse.setHeader("Access-Control-Allow-Headers","responseType,Origin,X-Requested-With, Content-Type, Accept, jwt");
    37. 		//允许客户端处理一个新的响应头jwt
    38. 		httpResponse.setHeader("Access-Control-Expose-Headers", "jwt,Content-Disposition");
    39. 		
    40. 		//httpResponse.setHeader("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");
    41. 		//httpResponse.setHeader("Access-Control-Allow-Methods", "POST, GET, PUT, DELETE");
    42. 		
    43. 		// axios的ajax会发两次请求，第一次提交方式为：option，直接返回即可
    44. 		if ("OPTIONS".equals(req.getMethod())) {
    45. 			return;
    46. 		}
    47. 		filterChain.doFilter(servletRequest, servletResponse);
    48. 	}
    49. 	@Override
    50. 	public void destroy() {
    51.  
    52. 	}
    53. }

    state.js

    1. export default {
    2.   stateName:'王德法',
    3.   jwt:''
    4. }

    mutations.js

    1. export default {
    2.   // state == state.js文件中导出的对象；payload是vue文件传过来的参数
    3.   setName: (state, payload) => {
    4.     state.stateName = payload.stateName
    5.   },
    6.   setJwt: (state, payload) => {
    7.     state.jwt = payload.jwt
    8.   }
    9. }

    getters.js

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

    http.js

    1.  
    2. // 请求拦截器
    3. axios.interceptors.request.use(function (config) {
    4.   var jwt = window.ss.$store.getters.getJwt
    5.   if (jwt) {
    6.     config.headers['jwt'] = jwt
    7.   }
    8.   return config;
    9. }, function (error) {
    10.   return Promise.reject(error);
    11. });
    12.  
    13. // 响应拦截器
    14. axios.interceptors.response.use(function (response) {
    15.   let jwt = response.headers['jwt'];
    16.   if (jwt) {
    17.     //将响应头中的jwt串放入state.js中
    18.     window.ss.$store.commit('setJwt', {
    19.       jwt: jwt
    20.     })
    21.   }
    22.   return response;
    23. }, function (error) {
    24.   return Promise.reject(error);
    25. });

    记得在web.xml里面配置好

    2.   <filter>
    3.     <filter-name>corsFilterfilter-name>
    4.     <filter-class>com.zking.ssm.util.CorsFilterfilter-class>
    5.   filter>
    6.   <filter-mapping>
    7.     <filter-name>corsFilterfilter-name>
    8.     <url-pattern>/*url-pattern>
    9.   filter-mapping>
    10.  
    11.   
    12.   <filter>
    13.     <filter-name>jwtFilterfilter-name>
    14.     <filter-class>com.zking.ssm.jwt.JwtFilterfilter-class>
    15.   filter>
    16.   <filter-mapping>
    17.     <filter-name>jwtFilterfilter-name>
    18.     <url-pattern>/*url-pattern>
    19.   filter-mapping>

    main.js

    1. // The Vue build version to load with the `import` command
    2. // (runtime-only or standalone) has been set in webpack.base.conf with an alias.
    3. import Vue from 'vue'
    4. //开发环境下才会引入mockjs
    5. // process.env.MOCK && require('@/mock')
    6. // 新添加1
    7. import ElementUI from 'element-ui'
    8. // 新添加2，避免后期打包样式不同，要放在import App from './App';之前
    9. import 'element-ui/lib/theme-chalk/index.css'
    10.  
    11. import App from './App'
    12. import router from './router'
    13. import store from './store'
    14.  
    15. // 新添加3----实例进行一个挂载
    16. Vue.use(ElementUI)
    17. Vue.config.productionTip = false
    18.  
    19. import axios from '@/api/http'
    20. import VueAxios from 'vue-axios'
    21.  
    22. Vue.use(VueAxios, axios)
    23.  
    24. /* eslint-disable no-new */
    25. window.ss = new Vue({
    26.   el: '#app',
    27.   router,
    28.   store,
    29.   //定义变量
    30.   data() {
    31.     return {
    32.       Bus: new Vue()
    33.     }
    34.   },
    35.   components: {App},
    36.   template: ''
    37. })

    记得更改window.ss。

    直接运行有出现令牌出错，这就需要我们登录了。

  • 相关阅读:
    kubernetes配置资源管理
    【C#实战】控制台游戏 勇士斗恶龙(3)——营救公主以及结束界面
    tessafe.sys不兼容驱动程序怎么解决？
    Go语言的流程控制
    Comparator之用最少数量的箭引爆气球
    创建多维时间序列DataFrame并显示前(后)指定天数的数据的df.last()方法
    NPU上PyTorch模型训练问题案例
    023-普通内部类与静态内部类
    【人工智能入门之机器学习决策树的学习（一）】
    用java写一个二叉树翻转
  • 原文地址：https://blog.csdn.net/weixin_74383330/article/details/133787142