JWT是什么：

JSON Web Token（JWT）是一个开放标准（RFC 7519），它定义了一种紧凑且独立的方式，用于在各方之间作为JSON对象安全地传输信息。
Ø 官方网址：https://jwt.io/
Ø 调试页面：https://jwt.io/
Ø 学习文档：https://jwt.io/introduction/

用途：

Ø 授权：这是我们使用JWT最广泛的应用场景。一次用户登录，后续请求将会包含JWT，对于那些合法的token，允许用户连接路由，服务和资源。目前JWT广泛应用在SSO（Single Sign On）(单点登录)上。因为他们开销很小并且可以在不同领域轻松使用。
Ø 信息交换：JSON Web Token是一种在各方面之间安全信息传输的好的方式 因为JWT可以签名 - 例如，使用公钥/私钥对 - 您可以确定发件人是他们所说的人。 此外，由于使用标头和有效负载计算签名，您还可以验证内容是否未被篡改。

组成：

一个JWT由三部分组成，各部分以点分隔：

Header(头部）——-base64编码的Json字符串
Payload(载荷）—-base64编码的Json字符串
Signature(签名)—-使用指定算法，通过Header和Playload加盐计算的字符串

一个JWT看起来像下面这样：

xxxxx.yyyyy.zzzzz

image.png

header

此部分有两部分组成：
Ø 一部分是token的类型，目前只能是JWT
Ø 另一部分是签名算法，比如HMAC 、 SHA256 、 RSA
示例：

{
“alg”:”HS256”,
“typ”:”JWT”
}

base64编码命令：

echo -n ‘{“alg”:”HS256”,”typ”:”JWT”}’ | base64
或者
echo -n “{\“alg\“:\“HS256\“,\“typ\“:\“JWT\“}” | base64

Payload

token的第二部分是payload（有效负载），其中包含claims（声明）。Claims是关于一个实体（通常是用户）和其他数据类型的声明。
claims有三种类型：registered,public,and private claims。

Ø Registered（已注册的声明）：这些是一组预定义声明，不是强制性的，但建议使用，以提供一组有用的，可互操作的声明。 其中一些是：iss（发行人），exp（到期时间），sub（主题），aud（观众）and others。（请注意，声明名称只有三个字符，因为JWT意味着紧凑。）
Ø Public(公开声明)：这些可以由使用JWT的人随意定义。 但为避免冲突，应在IANA JSON Web Token Registry中定义它们，或者将其定义为包含防冲突命名空间的URI。
Ø private (私人声明)：这些声明是为了在同意使用它们的各方之间共享信息而创建的，并且既不是注册声明也不是公开声明。

Signature

要创建签名部分，您需要使用base64编码后的header，base64编码后的payload，a secret，标头中指定的算法，并对其进行签名。
示例：

HMACSHA256(
base64UrlEncode(header) + “.” +
base64UrlEncode(payload),
secret)

Base64和Base64Url 的区别

Base64Url在Base64的基础上进行以下处理：

  1. 去除了尾部填充的“=”
  2. 把“+”替换成“-”
  3. 斜线“/”替换成下划线“_”

Spring-boot集成

导入依赖：

  1. <dependency>
  2.   <groupId>com.auth0</groupId>
  3.   <artifactId>java-jwt</artifactId>
  4.   <version>4.0.0</version>
  5. </dependency>

编写JwtUtil：

  1. @Component
  2.     @Slf4j
  3.     public class JwtUtil {
  4.         /**
  5. * 创建token
  6. * @return
  7. */
  8.         public String createToken() {
  9.             // token 密钥
  10.             String secret = "123456";
  11.             //签名算法
  12.             Algorithm algorithm = Algorithm.HMAC256(secret);
  14.             // 头部信息
  15.             Map<String, Object> map = new HashMap<>();
  16.             //JWT 的签名算法
  17.             map.put("alg", "HS256");
  18.             //token的类型
  19.             map.put("typ", "JWT");
  20.             //获取当前时间
  21.             long currentTime = System.currentTimeMillis();// + 30 * 60 * 1000;
  22.             //获取当前日期
  23.             Date nowDate = new Date(currentTime);
  24.             //当前时间加上30分钟
  25.             Date expireDate = new Date(currentTime + 30 * 60 * 1000);// 半小时过期
  26.             //创建token
  27.             String token = JWT.create()
  28.                 .withHeader(map)// 设置头部信息 Header
  29.                 .withIssuer("Thomas")//设置 载荷 签名是有谁生成 例如 服务器
  30.                 .withSubject("this is test token")//设置 载荷 签名的主题
  31.                 // .withNotBefore(new Date())//设置 载荷 定义在什么时间之前，该jwt都是不可用的.
  32.                 .withAudience("APP")//设置 载荷 签名的观众 也可以理解谁接受签名的
  33.                 .withIssuedAt(nowDate) //设置 载荷 生成签名的时间
  34.                 .withExpiresAt(expireDate)//设置 载荷 签名过期的时间
  35.                 .sign(algorithm);//签名 Signature
  36.             log.info("生成的JWT 为："+token);
  37.             return token;
  38.         }
  40.         /**
  41. * 校验token
  42. * @param token
  43. * @throws UnsupportedEncodingException
  44. */
  45.         public void verifyToken(String token) throws UnsupportedEncodingException {
  46.             // token 密钥
  47.             String secret = "123456";
  48.             Algorithm algorithm = Algorithm.HMAC256(secret);
  49.             JWTVerifier verifier = JWT.require(algorithm).withIssuer("Thomas").build(); // Reusable verifier instance
  50.             try {
  51.                 DecodedJWT jwt = verifier.verify(token);
  53.                 String subject = jwt.getSubject();
  54.                 List<String> audience = jwt.getAudience();
  55.                 Map<String, Claim> claims = jwt.getClaims();
  56.                 for (Map.Entry<String, Claim> entry : claims.entrySet()) {
  57.                     String key = entry.getKey();
  58.                     Claim claim = entry.getValue();
  59.                     System.out.println("key:" + key + " value:" + claim.asString());
  60.                 }
  61.                 //            Claim claim = claims.get("loginName");
  62.                 //
  63.                 //            System.out.println(claim.asString());
  64.                 //            System.out.println(subject);
  65.                 //            System.out.println(audience.get(0));
  66.             }catch(Exception ex){
  67.                 System.out.println("验证失败！！");
  68.             }
  70.         }
  72.         public String createTokenWithChineseClaim() {
  73.             long currentTime = System.currentTimeMillis();// + 30 * 60 * 1000;
  74.             Date nowDate = new Date(currentTime);
  75.             Date expireDate = new Date(currentTime+ 30 * 60 * 1000);// 半小时过期
  76.             Map<String, Object> map = new HashMap<String, Object>();
  77.             map.put("alg", "HS256");
  78.             map.put("typ", "JWT");
  80.             Algorithm algorithm = Algorithm.HMAC256("secret");
  81.             String token = JWT.create().withHeader(map)
  82.                 /* 设置 载荷 Payload */
  83.                 .withClaim("loginName", "zhuoqianmingyue").withClaim("userName", "张三").withClaim("deptName", "技术部")
  84.                 .withIssuer("SERVICE")// 签名是有谁生成 例如 服务器
  85.                 .withSubject("this is test token")// 签名的主题
  86.                 // .withNotBefore(new Date())//定义在什么时间之前，该jwt都是不可用的
  87.                 .withAudience("APP")// 签名的观众 也可以理解谁接受签名的
  88.                 .withIssuedAt(nowDate) // 生成签名的时间
  89.                 .withExpiresAt(expireDate)// 签名过期的时间
  90.                 /* 签名 Signature */
  91.                 .sign(algorithm);
  92.                 return token;
  93.                 }
  95.                 //    public String createTokenWithChineseClaim2() throws UnsupportedEncodingException {
  96.                 //
  97.                 //        long currentTime = System.currentTimeMillis();// + 30 * 60 * 1000;
  98.                 //
  99.                 //        Date nowDate = new Date(currentTime);
  100.                 //
  101.                 //
  102.                 //        Date expireDate = new Date(currentTime+ 30 * 60 * 1000);// 半小时过期
  103.                 //        //生产头部信息
  104.                 //        Map<String, Object> map = new HashMap<String, Object>();
  105.                 //        map.put("alg", "HS256");
  106.                 //        map.put("typ", "JWT");
  107.                 //
  108.                 //        Member member = new Member();
  109.                 //        member.setMemberAccount("admin");
  110.                 //        member.setMemberName("张三");
  111.                 //
  112.                 //        Gson gson = new Gson();
  113.                 //
  114.                 //
  115.                 //        String userJson = gson.toJson(member);
  116.                 //
  117.                 //
  118.                 //        String userJsonBase64 = BaseEncoding.base64().encode(userJson.getBytes());
  119.                 //
  120.                 //        Algorithm algorithm = Algorithm.HMAC256("secret");
  121.                 //        String token = JWT.create().withHeader(map)
  122.                 //
  123.                 //                .withClaim("loginName", "zhuoqianmingyue").withClaim("user", userJsonBase64).withIssuer("SERVICE")// 签名是有谁生成
  124.                 //                .withSubject("this is test token")// 签名的主题
  125.                 //                // .withNotBefore(new Date())//该jwt都是不可用的时间
  126.                 //                .withAudience("APP")// 签名的观众 也可以理解谁接受签名的
  127.                 //                .withIssuedAt(nowDate) // 生成签名的时间
  128.                 //                .withExpiresAt(expireDate)// 签名过期的时间
  129.                 //                .sign(algorithm);//签名 Signature
  130.                 //
  131.                 //        return token;
  132.                 //
  133.                 //    }
  134.                 }

编写测试类：

  1. @SpringBootTest
  2.     @RunWith(SpringRunner.class)
  3.     public class JwtUtilTest {
  5.         @Resource
  6.         private JwtUtil jwtUtil;
  8.         @Test
  9.         public void createToken() {
  10.             jwtUtil.createToken();
  11.         }
  13.         @Test
  14.         public void verifyToken() {
  15.             String token="eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJ0aGlzIGlzIHRlc3QgdG9rZW4iLCJhdWQiOiJBUFAiLCJpc3MiOiJUaG9tYXMiLCJleHAiOjE2MTkwNzM5NTAsImlhdCI6MTYxOTA3MjE1MH0.7Os9SyBdsFbEgMZoG6ZwOlqqgx0qpbk36B2AOKKixXY";
  16.             try {
  17.                 jwtUtil.verifyToken(token);
  18.             } catch (UnsupportedEncodingException e) {
  19.                 e.printStackTrace();
  20.             }
  21.         }
  22.     }