JWT详解
1. 介绍
JWT简称 JSON Web Token，也就是通过**JSON形式作为Web应用中的令牌**，用于各方之间安全地将信息作为JSON对象传输，在数据传输的过程中还可以完成数据加密、签名等相关处理。
2. 流程图
2.1 认证流程
首先，前端通过Web表单将自己的用户名和密码发送到后端的接口。这一过程一般是一个HTTP POST请求。建议的方式是通过SSL加密的传输（https协议），从而避免敏感信息被嗅探。
后端核对用户名和密码成功后，将用户的id等其他信息作为 JWT Payload（负载），将其与头部分别进行Base64编码拼接后签名，形成一个JWT(Token)。形成的JWT就是一个形同lll.mmm.sss的字符串。 token = head.payload.singurater
后端将JWT字符串作为登录成功的返回结果返回给前端。前端可以将返回的结果保存在localStorage或sessionStorage上，退出登录时前端删除保存的JWT即可。
前端在每次请求时将JWT放入HTTP Header中的Authorization位。(解决XSS和XSRF问题)
后端检查是否存在，如存在验证JWT的有效性
2.2 jwt优势
简洁(Compact): 可以通过URL，POST参数或者在HTTP header发送，因为数据量小，传输速度也很快
自包含(Self-contained)：负载中包含了所有用户所需要的信息，避免了多次查询数据库
因为Token是以JSON加密的形式保存在客户端的，所以JWT是跨语言的，原则上任何web形式都支持。
不需要在服务端保存会话信息，特别适用于分布式微服务。
3. JWT
3.1 header（表头）
标头通常由两部分组成：令牌的类型(即JWT)和所使用的签名算法，例如HMAC SHA256(默认)或RSA。它会使用Base64编码组成JWT结构的第一部分。
注意：Base64是一种编码，也就是说，它是可以被翻译回原来的样子的，它并不是一种加密过程。
3.2 Payload（载荷）
将能用到的用户信息放在 Payload中。官方建议不要放特别敏感的信息，例如密码。
3.3 Signature（签名信息）
签证由三部分组成，header和payload分别经base64Url(一种在base64上做了一点改变的编码)编码后由’.’连接,服务器生成秘钥（secret），连接之后的字符串在经header中声明的加密方式和秘钥加密，再用’.'和加密前的字符串连接。服务器验证token时只会验证第三部分。
header (base64Url) . payload (base64Url) . secret(header (base64Url)+payload (base64Url))
4. Session方式
session方法存储会有很大的缺点。
@RestController
@RequestMapping("test")
public class SessionController {
@PostMapping("login")
public String login(String userName, String password, HttpServletRequest request){
// 将用户名和密码拼接后设置在session作用域中
request.getSession().setAttribute("user", userName + password);
return "Login Success！";
}
}
5. Jwt实现
5.1 依赖
<!-- jwt的依赖包 -->
<dependency>
<groupId>com.auth0</groupId>
<artifactId>java-jwt</artifactId>
<version>3.4.0</version>
</dependency>
5.2 工具类
package com.liu.jwt.util;
import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTCreator;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.DecodedJWT;
import java.util.Calendar;
import java.util.Map;
/*
* jwt工具类
*/
public class JwtUtils {
// sign
private static final String SIGN = "token@lms";
// 生成token，header.payload.sign
public static String getToken(Map<String, String> map){
// 创建jwt builder对象
JWTCreator.Builder builder = JWT.create();
// 添加payload
map.forEach((k, v) -> {
builder.withClaim(k, v);
});
// 设置过期时间
Calendar calendar = Calendar.getInstance();
calendar.add(Calendar.DATE, 7);
// 设置过期时间和添加签名信息
String token = builder.withExpiresAt(calendar.getTime())
.sign(Algorithm.HMAC256(SIGN));
return token;
}
// 验证token的合法性
public static void verify(String token){
// 如果验证失败会直接抛出异常信息
JWT.require(Algorithm.HMAC256(SIGN)).build().verify(token);
}
// 获取token中的信息(也可以和上面部分的代码直接合并)
public static DecodedJWT getTokenInfo(String token){
DecodedJWT verify = JWT.require(Algorithm.HMAC256(SIGN)).build().verify(token);
return verify;
}
}
5.3 拦截器
package com.liu.jwt.interceptor;
import com.auth0.jwt.exceptions.AlgorithmMismatchException;
import com.auth0.jwt.exceptions.SignatureVerificationException;
import com.auth0.jwt.exceptions.TokenExpiredException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.liu.jwt.util.JwtUtils;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.HashMap;
/**
* jwt拦截器，执行token的验证工作（集的配置拦截器）
*/
public class JwtInterceptor implements HandlerInterceptor {
/**
* 在目标方法执行之前执行
* @param request
* @param response
* @param handler 目标方法
* @return true，代表放行， false，表示禁止放行
* @throws Exception
*/
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
HashMap<String, Object> map = new HashMap<>();
// 因为token存放在请求头中，
String token = request.getHeader("token");
// 验证token
try {
// 直接验证token是否正确，如果token不正确，会直接抛出异常信息被全局异常捕获
JwtUtils.verify(token);
// 验证通过，直接放行请求
return true;
} catch (SignatureVerificationException e){
map.put("msg", "无效签名");
} catch (TokenExpiredException e){
map.put("msg", "token已过期");
} catch (AlgorithmMismatchException e){
map.put("msg", "token算法不一致");
} catch (Exception e) {
map.put("msg", "token无效");
}
map.put("code", "500");
// 将map转为json数据信息
// 因为response底层也封装了json，也可以使用fastJson
String json = new ObjectMapper().writeValueAsString(map);
response.setContentType("application/json;charset=utf-8");
response.getWriter().println(json);
// 禁止放行请求
return false;
}
}
配置拦截器
package com.liu.jwt.config;
import com.liu.jwt.interceptor.JwtInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
public class InterceptorConfig implements WebMvcConfigurer {
// 配置拦截器
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(new JwtInterceptor())
// 拦截所有的请求信息
.addPathPatterns("/**")
// 只放行/login登录请求，
.excludePathPatterns("/login");
}
}
5.4 Controller
package com.liu.jwt.controller;
import com.auth0.jwt.exceptions.AlgorithmMismatchException;
import com.auth0.jwt.exceptions.SignatureVerificationException;
import com.auth0.jwt.exceptions.TokenExpiredException;
import com.auth0.jwt.interfaces.DecodedJWT;
import com.liu.jwt.entity.User;
import com.liu.jwt.service.UserService;
import com.liu.jwt.util.JwtUtils;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Map;
@RestController
public class UserController {
@Resource
private UserService userService;
/**
* 用户登录
* @param user
* @return
*/
@PostMapping("login")
public Map<String, Object> login(User user){
HashMap<String, Object> map = new HashMap<>();
System.out.println("user.getUsername() = " + user.getUsername());
System.out.println("user.getPassword() = " + user.getPassword());
try {
User userLogin = userService.login(user);
// 用户存放负载信息,从而调用jwt生成相应的token信息
HashMap<String, String> payload = new HashMap<>();
payload.put("id", userLogin.getId());
payload.put("username", userLogin.getUsername());
// 生成token信息
String token = JwtUtils.getToken(payload);
map.put("code", "200");
map.put("msg","登录成功");
map.put("token", token);
} catch (Exception e) {
map.put("code", "500");
map.put("msg", e.getMessage());
}
return map;
}
// 方式1：未使用拦截器，代码冗余
// 登录之后执行相应的业务逻辑
// @PostMapping("test")
public Map<String, Object> verify(String token){
HashMap<String, Object> map = new HashMap<>();
System.out.println("token = " + token);
// 验证token
try {
JwtUtils.verify(token);
// 获取token的返回值信息，类型为DecodedJWT
DecodedJWT tokenInfo = JwtUtils.getTokenInfo(token);
map.put("code", "200");
map.put("msg","请求成功");
return map;
} catch (SignatureVerificationException e){
map.put("msg", "无效签名");
} catch (TokenExpiredException e){
map.put("msg", "token已过期");
} catch (AlgorithmMismatchException e){
map.put("msg", "token算法不一致");
} catch (Exception e) {
map.put("msg", "token无效");
}
map.put("code", "500");
return map;
}
// 方式2：配置了拦截器（只有登录之后才能进行使用该方法）
@PostMapping("test")
public Map<String, Object> test(HttpServletRequest request){
HashMap<String, Object> map = new HashMap<>();
// 从请求头中获取token信息
String token = request.getHeader("token");
DecodedJWT tokenInfo = JwtUtils.getTokenInfo(token);
// 处理自己的业务逻辑
map.put("code", "200");
map.put("msg","请求成功");
String username = tokenInfo.getClaim("username").asString();
String id = tokenInfo.getClaim("id").asString();
map.put("username", username);
map.put("id", id);
return map;
}
}