SpringBoot-JWT教程

1. 什么是JWT https://jwt.io/introduction/

   JSON Web令牌（JWT）是一个开放标准（[RFC 7519](https://tools.ietf.org/html/rfc7519)），它定义了一种紧凑而独立的方法，用于在各方之间安全地将信息作为JSON对象传输。由于此信息是经过数字签名的，因此可以被验证和信任。可以使用秘密（使用**HMAC**算法）或使用**RSA**或**ECDSA**的公钥/私钥对对JWT进行**签名**。

通俗解释：

JW简称为Json WebToken,也就是通过json形式作为web应用中的令牌，用于在各方安全的将信息作为json对象传输，在数据传输过程中还可以完成数据加密、签名等相关处理。

2. JWT能做什么

1.授权

这是jwt的常见方案，一旦用户登录，每个后续请求都包括jwt,从而允许用户访问该令牌允许的路由，服务和资源

2.信息交换

3. 为什么是JWT

4. JWT的结构

1.令牌组成

1.表头（Header）
2.有效载荷（Playload）
3.签名(Signature)
通常显示为 xxxx.xxxxx.xxxx Header.Playload.Signature

2.标头 Header

标头通常由两部分组成：令牌的类型（即JWT）和所使用的签名算法，例如HMAC SHA256或RSA。
例如：

{
  "alg": "HS256",
  "typ": "JWT"
}

然后，此JSON被Base64Url编码以形成JWT的第一部分。
注意：Base64是一种编码，也就是说，它是可以被翻译为原来的样子，并不是一种加密过程

3.有效载荷Playload

令牌的第二部分是有效负载，其中包含声明。声明是有关实体（通常是用户）和其他数据的声明
有三种声明: registered, public, private .同样的它是使用Base64编码组成的JWT结构的第二部分

{
  "sub": "1234567890",
  "name": "John Doe",
  "admin": true
}

4.签名 Signature

前两段都是使用base64进行编码的，即前端可以解开知道里面的信息，Signature需要使用编码后的header和playload以及我们提供的一个密钥，然后使用header中指定的签名算法（HS256）进行签名，签名的作用是保证JWT没有被篡改过
如

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

5.签名的目的

最后一步签名的过程，实际是对头部以及负载内容进行签名，防止内容被篡改，如果有人对头部以及负载内容解码之后进行修改，在进行编码，最后加上之前的签名组合形成新的JWT的话，那么服务端会判断出新的头部和负载形成的签名和JWT附带上的签名是不一样的，如果要对新的头部与负载进行签名，在不知道服务器加密时用的密钥的话，得出来的签名也是不一样的

6.信息安全问题

Base64是一种编码，是可逆的，那么信息不就被暴露了吗？

5. 使用JWT

1.引入依赖

<dependency>
    <groupId>com.auth0</groupId>
    <artifactId>java-jwt</artifactId>
    <version>3.12.0</version>
</dependency>

2.创建token

  @Test
  void contextLoads() {
    HashMap<String,Object> map = new HashMap<>();
    Calendar cal = Calendar.getInstance();
    // 令牌的获取
    cal.add(Calendar.SECOND,5);
    String token = JWT.create()
        .withHeader(map) // header
        .withExpiresAt(cal.getTime()) // 设置过期时间 90s
        .withClaim("userId",2342234)  //playload 自定义用户名
        .withClaim("username","bampu") // playload
        .sign(Algorithm.HMAC256("23fs@#asc"));    // signture 设置签名密钥
    System.out.println(token);
  }

生成结果：
eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2MDkwNTk0OTgsInVzZXJJZCI6MjM0MjIzNCwidXNlcm5hbWUiOiJiYW1wdSJ9.EQx_lXMIPlymtNY7sq1IOe4DgmkKeKS5UznNi1BS4vQ

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

  @Test
  public void test(){
    // 创建验证对象
    JWTVerifier jwtVerifier =  JWT.require(Algorithm.HMAC256("23fs@#asc")).build();
    DecodedJWT vertify = jwtVerifier.verify("eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2MDkwNTk0OTgsInVzZXJJZCI6MjM0MjIzNCwidXNlcm5hbWUiOiJiYW1wdSJ9.EQx_lXMIPlymtNY7sq1IOe4DgmkKeKS5UznNi1BS4vQ");
    System.out.println("过期时间:"+vertify.getExpiresAt());
    System.out.println(vertify.getClaim("userId").asInt());
    System.out.println(vertify.getClaim("username").asString());
  }

4.常见异常信息

TokenExpiredException 令牌过期异常
SignatureVerificationException 签名不一致异常
AlgorithmMismatchException 算法不匹配异常
InvalidClaimException 失效的playload异常

5. Springboot整合jwt

1.封装jwt工具类

public class JwtUtils {
  private static final String SALT = "j1w4t5@321!";
  /**
   * 生成token
   * header.playload.signature
   * @param map 传入 playload
   * @return 返回token
   */
  public static String getToken(Map<String, String> map) {
    JWTCreator.Builder builder = JWT.create();
    map.forEach((k, v) -> {
      builder.withClaim(k, v);
    });
    Calendar calendar = Calendar.getInstance();
    calendar.add(Calendar.DATE, 7 ); // 默认七天过期
    builder.withExpiresAt(calendar.getTime());
    return builder.sign(Algorithm.HMAC256(SALT));
  }
  /**
   * 验证token
   * @param token token
   */
  public static void verify(String token){
    JWT.require(Algorithm.HMAC256(SALT)).build().verify(token);
  }
  /**
   * 获取token中的playload
   * @param token token
   * @return
   */
  public static DecodedJWT getToken(String token){
    return JWT.require(Algorithm.HMAC256(SALT)).build().verify(token);
  }
}

2.创建实体

public class User {
  private Integer id;
  private String name;
  private String password;
}

3.dao与service实现

@Service
public class UserService {
  @Autowired
  UserDao userDao;
  public User getUser(User user){
    User userDB = userDao.login(user);
    if (userDB != null) {
      return userDB;
    }
    throw new RuntimeException("认证失败");
  }
}

4.controller实现

@RestController
@RequestMapping
public class UserController {
  private static final Logger logger = LoggerFactory.getLogger(UserController.class);
  @Autowired
  private UserService userService;
  @PostMapping("/user/login")
  public Map<String, Object> login(User user) {
    Map<String, Object> map = new HashMap<>();
    try {
      User userDB = userService.getUser(user);
      Map<String, String> payload = new HashMap<>();
      payload.put("id", userDB.getId() + "");
      payload.put("name", userDB.getName());
      String token = JwtUtils.getToken(payload);
      map.put("state", true);
      map.put("msg", "登录成功");
      map.put("token", token);
      return map;
    } catch (Exception e) {
      logger.error("登录失败", e);
      map.put("state", false);
      map.put("msg", e.getMessage());
      map.put("token", "");
    }
    return map;
  }
  @PostMapping("/user/test")
  public Map<String, Object> test(HttpServletRequest request) {
    String token = request.getHeader("token");
    DecodedJWT verify = JwtUtils.getToken(token);
    String id = verify.getClaim("id").asString();
    String name = verify.getClaim("name").asString();
    logger.info("用户id：[{}]", id);
    logger.info("用户名: [{}]", name);
    //TODO 业务逻辑
    Map<String, Object> map = new HashMap<>();
    map.put("state", true);
    map.put("msg", "请求成功");
    return map;
  }
}

5.登录成功

6.获取数据

上述问题每次都要传递token数据，每个方法都需要验证token,代码冗余不够灵活，优化？

使用拦截器优化、springCloud 网关

jwt拦截器实现

package cn.com.beyond.springbootjwt.interceptors;
import cn.com.beyond.springbootjwt.util.JwtUtils;
import com.auth0.jwt.exceptions.AlgorithmMismatchException;
import com.auth0.jwt.exceptions.InvalidClaimException;
import com.auth0.jwt.exceptions.SignatureVerificationException;
import com.auth0.jwt.exceptions.TokenExpiredException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.HashMap;
import java.util.Map;
/**
 * jwt 拦截器
 * @author beyond
 * @since 2020/12/27
 */
public class JWTInterceptor implements HandlerInterceptor {
  private static final Logger logger = LoggerFactory.getLogger(JWTInterceptor.class);
  @Override
  public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    //获取请求头中的令牌
    String token = request.getHeader("token");
    logger.info("当前token为：[{}]", token);
    Map<String, Object> map = new HashMap<>();
    try {
      JwtUtils.verify(token);
      return true;
    } catch (SignatureVerificationException e) {
      logger.error("签名不一致", e);
      map.put("msg", "签名不一致");
    } catch (TokenExpiredException e) {
      logger.error("令牌过期", e);
      map.put("msg", "令牌过期");
    } catch (AlgorithmMismatchException e) {
      logger.error("算法不匹配", e);
      map.put("msg", "算法不匹配");
    } catch (InvalidClaimException e) {
      logger.error("失效的payload", e);
      map.put("msg", "失效的payload");
    } catch (Exception e) {
      logger.error("token无效", e);
      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().println(json);
    return false;
  }
}

拦截器配置

/**
 * 拦截器配置
 * @author beyond
 * @since 2020/12/27
 */
@Configuration
public class InterceptorConfig implements WebMvcConfigurer {
  @Override
  public void addInterceptors(InterceptorRegistry registry) {
    registry.addInterceptor(new JWTInterceptor())
        .addPathPatterns("/**")  // 所有需要认证的请求
        .excludePathPatterns("/user/login") // 不需要认证的请求
    ;
  }
}

https://juejin.cn/post/7090677150646272036