1. JWT 简介

JSON Web Token（JWT） 是一个开放标准（RFC 7519），它定义了一种紧凑的、自包含的方式，用于作为 JSON 对象在各方之间安全地传输信息。该信息可以被验证和信任，因为它是数字签名的。

2. JWT 的应用场景

• 授权（Authorization）

  这是使用 JWT 的最常见方案。一旦用户登录，每个后续请求将包括 JWT，从而允许用户访问该令牌允许的路由、服务、资源。单点登录是当今广泛使用 JWT 的一项功能，因为它的开销很小并且可以在不同的域中轻松使用。

• 信息交换（Information Exchange）

  JWT 是在各方之间安全地传输信息的好方法。因为可以对 JWT 进行签名（例如使用公钥/私钥对），所以你可以确保发件人是谁。此外，由于签名是使用标头和有效负载计算的，因此你还可以验证内容是否遭到篡改。

3. JWT 和传统 Session 认证比较

3.1 基于传统的 Session 认证

认证方式：

由于 http 协议本身是一种无状态协议，因此意味着如果用户向后端提供了用户名和密码来进行用户认证，那么下一次请求时，用户还要再一次进行用户认证才行。因为根据 http 协议，后端并不知道具体是哪个用户发起的请求，所以为了让服务器识别是哪个用户发起的请求，服务器就会存储一份用户登录的信息，保存在 Session 中，并将 sessionId 返回给浏览器并保存到 cookie 中。这样当用户发起认证请求时就会带上 sessionId，以便于服务器识别该请求是哪个用户发出的。

暴露问题：

• 通过 session 是保存在服务器的内存中的，当认证的用户增多后，服务器的开销会明显增大。

• 由于认证的记录被保存在服务器的内存中，因此存储在当前服务器的用户只能在该服务器上发起请求，这样才能拿到授权资源，而在分布式应用上，这会限制负载均衡的能力，降低扩展性。

• 因为是基于 cookie 来进行用户识别的，如果 cookie 被截获，用户就会很容易受到跨站请求伪造的攻击。

3.2 基于 JWT 认证

认证流程：

1. 首先前端将用户名和密码发送到后端的接口。这个过程一般是 HTTP POST 请求，建议通过 SSL 加密的传输（https 协议），从而避免敏感信息被嗅探。
2. 后端核对用户名和密码成功后，将用户的 id 等其它信息作为 JWT Payload（负载），将其与头部分别进行 Base64 编码拼接后签名，形成一个 JWT（Token）。形成的 JWT 就是一个形同 header.payload.signature 的字符串。
3. 后端将 JWT 字符串作为登录成功的返回结果返回给前端，前端可以返回结果保存在 localStorage 或 sessionStorage 上，退出登录时前端删除保存的 JWT 即可。
4. 前端在每次请求时将 JWT 放入 HTTP Header 中的 Authorization 处。
5. 后端收到前端请求后会检查是否存在，如存在验证 JWT 的有效性。（检查签名是否正确、Token 是否过期、Token 的接收方是否为自己等）
6. 验证通过后后端使用 JWT 中包含的用户信息进行其它逻辑操作，返回相应结果。

JWT 优势：

• 简洁：可以通过 URL、POST 参数或者在 HTTP header 发送，因为数据量小，传输速度也很快。
• 自包含：负载中包含了所有用户所需要的信息，避免了多次查询数据库。
• 因为 Token 是以 JSON 加密的形式保存在客户端的，所以 JWT 是跨语言的，原则上任何 web 形式都支持。
• 不需要在服务端保存会话信息，特别适用于分布式微服务。

4. JWT 的结构

JWT 就是一个 token 字符串，结构为 xxx.yyy.zzz，它由下面三部分组成，中间用 . 号连接

• 标头 header
• 有效负载 payload
• 签名 signature

4.1 标头（header）

标头通常由两部分组成：令牌的类型（即 JWT）和所使用的签名算法（例如 HMAC SHA256 或 RSA）。标头本身是一个 json 对象，但在组成 JWT 时它会使用 Base64 进行编码去成为 JWT 的第一部分。

4.2 有效负载（payload）

令牌的第二部分是有效负载，其中包含声明。声明是关于实体（通常是用户）和其它数据的声明。声明包含三个部分：

• 标注中注册的声明（registered claims）

  声明	描述
  iss	JWT 签发者
  sub	JWT 所面向的用户
  aud	接收 JWT 的一方
  exp	JWT 的过期时间，这个过期时间必须大于签发时间
  nbf	定义在什么时间之前该 JWT 是不生效的
  iat	JWT 的签发时间
  jti	JWT 的唯一身份标识，主要用来作为一次性 token，从而回避重放攻击

• 公共的声明（public claims）

  公共的声明可以添加任何信息，一般添加用户的相关信息或其它业务需要的必要信息。但不建议添加敏感信息，因为该部分在客户端可以被解码。

• 私有的声明（private claims）

  私有声明是提供者和消费者共同定义的声明，一般不建议存放敏感信息

对 payload 进行 Base64 编码后就成为了 JWT 的第二个部分。

信息安全问题：

由于 Base64 是一种编码，是可逆的，因此在 JWT 的负载里面不应该加入任何敏感的数据（例如密码）。因此 JWT 适合用于向 Web 应用传递一些非敏感信息。常被用于设计用户认证和授权系统，以及实现 Web 应用的单点登录。

4.3 签名（signature）

令牌的最后一部分签名是对上面两部分数据进行签名，通过指定的算法生成哈希，以确保数据不会被篡改。首先需要指定一个密码（secret）。该密码仅仅保存在服务器中，并且不能向用户公开。然后使用标头中指定的签名算法（默认情况下为HMAC SHA256）根据以下公式生成签名。

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

在计算出签名后，header、payload 和 signature 三个部分组合成一个字符串，每个部分用 . 分隔，就构成了一个完整的 JWT。

签名的作用：

最后一步签名的过程，实际上是对头部以及负载内容进行签名，防止内容被篡改。如果有人对头部以及负载的内容解码后进行篡改，在进行编码后加上之前的签名组合形成新的 JWT，那么服务器会在接收到该 JWT 后会判断新的头部和负载形成的签名与新的 JWT 上附带的签名是否一致，而结果肯定是不一样的。

Base64URL 算法：

Base64URL 算法和 Base64 算法类似。作为令牌的 JWT 可以放在 URL 中（例如 api.example/?token=xxx）。Base64 中用的三个字符 +、/、= 由于在 URL 中有特殊含义，因此如果 JWT 需要使用在 URL 中就不适合。而 Base64URL 对它们做了替换，将 = 去掉，用 - 代替 +，用 _ 代替 /，因此就避免了这个问题。

5. JWT 使用方式

使用 JWT 最主要就是掌握生成令牌、验证令牌和获取令牌中的信息。接下来将介绍如何在 Java 中使用 JWT。

1. 引入依赖

   <dependency>
       <groupId>com.auth0groupId>
       <artifactId>java-jwtartifactId>
       <version>3.4.0version>
   dependency>
   1
   2
   3
   4
   5

2. 生成 token

   HashMap<String, Object> map = new HashMap<>(); // 用于设置 header 信息
   
   Calendar instance = Calendar.getInstance(); // 获取当前的日历
   instance.add(Calendar.DATE, 7); // 设置日历为当前的 7 天后
   Date date = instance.getTime(); // 将日历转化为 Date
   
   // 创建 token
   JWTCreator.Builder builder = JWT.create();
   String token = builder.withHeader(map) // header
       .withClaim("userId", 2001) // payload
       .withClaim("username", "小明")
       .withExpiresAt(date) // 设置过期时间
       .sign(Algorithm.HMAC256("!@#SDA$!@#"));// signature
   
   System.out.println(token);
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15

   

   • JWT.create() 用来创建一个 JWT 构造器，用于进行编码前对 JWT 的数据设置。返回值为 JWTCreator.Builder。
   • JWTCreator.Builder 的 withHeader() 方法用于设置 JWT 的 header 部分，有一个参数为 HashMap，用于设置 typ 和 alg 的。可以不主动设置，因为在签名的部分，默认会将 typ 设置为 “JWT”，将 alg 设置为指定的加密算法。
   • JWTCreator.Builder 的 withClaim() 方法用于设置 JWT 的 payload 部分，有两个参数，第一个参数为字符串类型的 name，第二个参数为 Boolean/Integer/Long/Double/String/Date 类型的 value。
   • JWTCreator.Builder 的 withExpiresAt(Date) 方法用于设置 JWT 的过期时间，参数为 Date。
   • JWTCreator.Builder 的 sign(Algorithm) 方法用于设置 JWT 的 signature 部分并返回最终形成的 JWT 字符串，参数可以为 Algorithm 类的指定算法，例如 Algorithm.HMAC256()，该算法的参数就为指定的密钥。JWTCreator.Builder.sign(Algorithm) 最终会调用 JWTCreator.sign() 方法将 header、payload 和 signature 进行 Base64URL 编码形成 JWT 字符串。

3. 根据令牌和签名解析数据

   // 要验证的 token
   String token = "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2NTkzNDgwMjAsInVzZXJJZCI6MjAwMSwidXNlcm5hbWUiOiLlsI_mmI4ifQ.5Kmd5QLqgEYkAUh5m2Y22UPjlsH2jrrdSb11XurV7cQ"; // 要验证的 token
   
   // 创建 JWT 验证对象
   JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256("!@#SDA$!@#")).build();
   DecodedJWT decodedJWT = jwtVerifier.verify(token);
   
   System.out.println(decodedJWT.getClaim("userId").asInt()); // 获取声明的 userId
   System.out.println(decodedJWT.getClaim("username").asString()); // 获取声明的 username
   System.out.println(decodedJWT.getExpiresAt()); // 获取过期时间
   
   System.out.println(decodedJWT.getHeaderClaim("typ").asString()); // 获取标头的 tpy
   System.out.println(decodedJWT.getHeaderClaim("alg").asString()); // 获取标头的 alg
   
   System.out.println(decodedJWT.getType()); // 获取标头的 tpy
   System.out.println(decodedJWT.getAlgorithm()); // 获取标头的 alg
   
   System.out.println(decodedJWT.getHeader()); // 获取编码后的 header
   System.out.println(decodedJWT.getPayload()); // 获取编码后的 payload
   System.out.println(decodedJWT.getSignature()); // 获取编码后的 signature
   System.out.println(decodedJWT.getToken()); // 获取编码后的 token
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21

   

   • JWT.require(Alogrithm).builder() 方法用于创建 JWT 验证对象，返回值为 JWTVerifier。其中 Alogrithm 使用的加密算法和密钥要和创建该 token 时使用的一致，不然会报异常。
   • JWTVerifier 的 verify(token) 方法能够用于验证 token，如果不符合则会报出异常，如果正确则会返回解码后的 token。
   • DecodeJWT 的 getClaim() 方法能够获取指定的声明参数，但获取的是引用值，还要通过 asInt/asLong/asDouble/asString/asBoolean/asDate 方法将引用值转换为对应类型的真实值。
   • DecodeJWT 的 getExpiresAt() 方法能够获取 token 的过期时间。
   • DecodeJWT 的 getType() 方法能够获取标头的 typ。
   • DecodeJWT 的 getAlgorithm() 方法能够获取标头的 alg。

以上就是最基本的 Java 结合 JWT 的操作。

常见的异常信息：

6. 封装 JWT 工具类

public class JWTUtils {

    private static final String SECRET = "#$#fdas!%";

    /**
     * 生成 token
     */
    public static String getToken(HashMap<String, String> map){
        Calendar instance = Calendar.getInstance();
        instance.add(Calendar.DATE, 7); // 默认7天过期

        // 创建 JTW builder
        JWTCreator.Builder builder = JWT.create();
        // payload
        map.forEach((k, v)->{
            builder.withClaim(k, v);
        });

        // 指定令牌过期时间
        builder.withExpiresAt(instance.getTime());

        // 签名
        String token = builder.sign(Algorithm.HMAC256(SECRET));
        return token;
    }

    /**
     * 验证并获取 token 信息
     */
    public static DecodedJWT verify(String token){

        JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256(SECRET)).build();
        DecodedJWT decodedJWT = jwtVerifier.verify(token);
        return decodedJWT;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

7. 拦截器验证 token

当需要验证 token 时，每个方法都要接收 token 参数，并对接收的 token 进行验证，则会导致代码冗余，不够灵活。

为了解决这个问题，则需要使用拦截器进行优化。步骤如下：

1. 在 interceptors 包下创建 JWTInterceptor 类，并进行如下配置：

   public class JWTInterceptor implements HandlerInterceptor {
   
       @Override
       public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
           HashMap<String, Object> map = new HashMap<>();
           // 获取请求头中的的 token
           String token = request.getHeader("token");
   
           try {
               DecodedJWT decodedJWT = JWTUtils.verify(token); // 验证令牌
               return true; // 放行请求
           } catch (SignatureVerificationException e) {
               e.printStackTrace();
               map.put("msg", "无效签名！");
           } catch (TokenExpiredException e) {
               e.printStackTrace();
               map.put("msg", "token 过期！");
           } catch (AlgorithmMismatchException e) {
               e.printStackTrace();
               map.put("msg", "token 算法不一致！");
           } catch (Exception e) {
               e.printStackTrace();
               map.put("msg", "token 无效！");
           }
           map.put("state", false); // 设置状态码
           // 将 map 转为 json
           String json = new ObjectMapper().writeValueAsString(map);
           response.setContentType("application/json;charset=utf-8");
           response.getWriter().print(json);
           return false;
       }
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32

2. 在 config 包下创建 InterceptorConfig 类，并进行如下配置：

   @Configuration
   public class InterceptorConfig implements WebMvcConfigurer {
       @Override
       public void addInterceptors(InterceptorRegistry registry) {
           registry.addInterceptor(new JWTInterceptor())
                   .addPathPatterns("") // 拦截的路径
                   .excludePathPatterns(""); // 放行的路径
       }
   }
   
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10