初始JWT原理及实战

通俗讲JWT

JWT简称JSON Web Token，也就是通过JSON形式作为Web应用中的令牌，用于在各方之间安全地将信息作为JSON对象传输，在数据传输过程中还可以完成数据加密、签名等相关处理

JWT能做什么

授权

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

信息交换

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

为什么是JWT

基于传统的session认证

认证方式

我们知道，http协议本身是一种无状态的协议（连接请求和连接中断），而这就意味着如果用户像我们的应用提供了用户名和密码进行用户认证，那么下一次请求的时候用户还要再进行一次用户认证才行，因为根据http协议，我们并不直到是哪个用户发出的请求，所以为了让我们的应用能够识别是哪个用户发出的请求，我们只能在服务器存储一份用户登陆的信息，这份登录信息会在响应时传递给浏览器，告诉其保存为cookie，以便下次请求时发送给我们的应用，这样我们的应用就能够识别来自哪个用户了，这就是传统的基于session认证

认证流程

暴露问题

每个用户经过我们的应用认证以后，我们的应用都要在服务端做一次记录，以方便用户下次识别的鉴别，通常而言session都是保存在内存中，而随着认证用户的增大，服务端的开销会明显增大
用户认证以后，服务端做认证记录，如果认证的记录被保存在内存中的话，这意味着用户下次请求还必须请求在这台服务器上，这样才能拿到授权的资源，这样在分布式的应用上，相应的限制了负载均衡器的能力，这也就意味着限制了应用的扩展能力
因为是基于cookie来进行用户识别的，cookie如果被截获，用户就会很容易受到跨站请求伪造的攻击
在前后端分离系统中就更加痛苦了：也就是说前后端分离在应用解耦后增加了部署的复杂性，通常用户一次请求就要转发多次，如果用session每次携带sessionid到服务器，服务器还要查询用户信息，同时如果用户很多，这些信息存储到服务器内存中，给服务器增加负担，还有就是CSRF（跨站伪造请求攻击）session是基于cookie进行用户识别的，cookie如果被截获，用户就很容易受到攻击，而且sessionid是一个特征值，表达的信息不够丰富，不容易扩展，而且如果你后端应用是多节点部署，那么就需要实现session共享不方便集群

基于JWT认证

认证流程

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

JWT优势

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

JWT结构

令牌组成

标头（Header）
有效载荷（Payload）
签名（Signature）

Header

Payload

令牌的第二部分是有效负载也就是自平衡，其中包含声明，声明是有关实体（通常是用户）和其他数据的声明

Signature

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

HS256(Base64（header） + "." + Base64（payload)，secret)

使用JWT

导入依赖

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

令牌的获取

 @Test
 void test1() {
     HashMap<String, Object> map = new HashMap<>();
     Calendar instance = Calendar.getInstance();
     instance.add(Calendar.MINUTE, 3);
     String token = JWT.create()
         .withHeader(map) //header有一个默认值 eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9
         .withClaim("userid", 21)
         .withClaim("username", "ccy") //payload负载用户信息和认证
         .withExpiresAt(instance.getTime()) //一般都会指定过期时间
         .sign(Algorithm.HMAC256("ccywmbc"));// 签名加密，密钥是万万不能让别人知道的
     System.out.println(token);
 }

令牌的验证

 @Test
 void test2() {
     //创建验证对象
     JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256("ccywmbc")).build();
     //对象解码
     DecodedJWT verify = jwtVerifier.verify("eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2NDAwNjc4MjAsInVzZXJpZCI6MjEsInVzZXJuYW1lIjoiY2N5In0.-1A6rf33Bp87twFzeExzCIbRnmipaH5cgMAtBx21nz8");
     System.out.println(verify.getClaim("userid").asInt());
     System.out.println(verify.getClaim("username").asString());
 }

为了解耦我们需要工具类来帮助我们每次验证token

封装JWT工具类

 public class JWTUtils {
     //签名加密，密钥是万万不能让别人知道的
     private static String SECRET = "www.ccywmbc.top";
 
     /**
      * 生成Token  Header.payload.signature
      *
      * @param map map中含有用户信息
      * @return 返回令牌
      */
     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 instance = Calendar.getInstance();
         //默认7天过期
         instance.add(Calendar.DATE, 7);
         //设置过期时间
         builder.withExpiresAt(instance.getTime());
         //生成Token
         String token = builder.sign(Algorithm.HMAC256(SECRET));
         return token;
     }
 
     /**
      * 验证token合法性
      *
      * @param token token
      * @return 返回用户信息
      */
     public static DecodedJWT verify(String token) {
         //如果有任何验证异常，此处都会抛出异常
         DecodedJWT decodedJWT = JWT.require(Algorithm.HMAC256(SECRET)).build().verify(token);
         return decodedJWT;
     }
 }

Spring Boot整合JWT

导入依赖

 <!--jwt-->
 <dependency>
     <groupId>com.auth0</groupId>
     <artifactId>java-jwt</artifactId>
     <version>3.10.3</version>
 </dependency>
 
 <!--mybatis-->
 <dependency>
     <groupId>org.mybatis.spring.boot</groupId>
     <artifactId>mybatis-spring-boot-starter</artifactId>
     <version>2.1.3</version>
 </dependency>
 
 <!--mysql-->
 <dependency>
     <groupId>mysql</groupId>
     <artifactId>mysql-connector-java</artifactId>
     <version>5.1.49</version>
 </dependency>
 
 <!--druid-->
 <dependency>
     <groupId>com.alibaba</groupId>
     <artifactId>druid</artifactId>
     <version>1.1.23</version>
 </dependency>
 
 <!--lombok-->
 <dependency>
     <groupId>org.projectlombok</groupId>
     <artifactId>lombok</artifactId>
     <optional>true</optional>
 </dependency>
 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-web</artifactId>
 </dependency>

配置文件信息

 server.port=8989
 spring.application.name=jwt
 
 spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
 spring.datasource.driver-class-name=com.mysql.jdbc.Driver
 spring.datasource.url=jdbc:mysql://localhost:3306/jwt?useUnicode=true&characterEncoding=utf8&useSSL=true&serverTimezone=UTC&useSSL=false
 spring.datasource.username=root
 spring.datasource.password=250259
 
 mybatis.type-aliases-package=com.example.entity
 mybatis.mapper-locations=classpath:com/example/mapper/*.xml
 
 logging.level.com.chilly.dao=debug

User类

 @Data
 @Accessors(chain = true)
 public class User {
     private String id;
     private String name;
     private String password;
 }

Dao层

 @Mapper
 public interface UserDAO {
     User login(User user);
 }

Service层

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDAO userDAO;

    @Override
    public User login(User user) {
        User userDB = userDAO.login(user);
        if (userDB != null) {
            return userDB;
        }
        throw new RuntimeException("查无此人");
    }
}

Mapper文件

 <?xml version="1.0" encoding="UTF-8" ?>
 <!DOCTYPE mapper
         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 <mapper namespace="com.example.dao.UserDAO">
     <select id="login" parameterType="User" resultType="User">
         select *
         from user
         where name = #{name}
           and password = #{password}
     </select>
 </mapper>

用户登录成功后客户端将会保存一段token用户每次请求都需要带上这段token

 @RestController
 @Slf4j
 public class UserController {
 
     @Autowired
     private UserService userService;
 
     @GetMapping("/user/login")
     public Map<String, Object> login(User user) {
         log.info("用户名：{}", user.getName());
         log.info("password: {}", user.getPassword());
         Map<String, Object> map = new HashMap<>();
         try {
             User userDB = userService.login(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) {
             e.printStackTrace();
             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.verify(token);
         String id = verify.getClaim("id").asString();
         String name = verify.getClaim("name").asString();
         log.info("用户id：{}", id);
         log.info("用户名: {}", name);
         //TODO 业务逻辑
         Map<String, Object> map = new HashMap<>();
         map.put("state", true);
         map.put("msg", "请求成功");
         return map;
     }
 }

拦截器

 @Slf4j
 public class JWTInterceptor implements HandlerInterceptor {
     @Override
     public boolean preHandle(HttpServletRequest request,
                              HttpServletResponse response,
                              Object handler) throws Exception {
         //获取请求头中的令牌
         String token = request.getHeader("token");
         log.info("当前token为：{}", token);
         Map<String, Object> map = new HashMap<>();
         try {
             JWTUtils.verify(token);
             return true;
         } catch (SignatureVerificationException e) {
             e.printStackTrace();
             map.put("msg", "签名不一致");
         } catch (TokenExpiredException e) {
             e.printStackTrace();
             map.put("msg", "令牌过期");
         } catch (AlgorithmMismatchException e) {
             e.printStackTrace();
             map.put("msg", "算法不匹配");
         } catch (InvalidClaimException e) {
             e.printStackTrace();
             map.put("msg", "失效的payload");
         } 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().println(json);
         return false;
     }
 }

配置拦截器

 public class InterceptorConfig implements WebMvcConfigurer {
     @Override
     public void addInterceptors(InterceptorRegistry registry) {
         registry.addInterceptor(new JWTInterceptor())
                 .addPathPatterns("/user/test")
                 .excludePathPatterns("/user/login");
     }
 }

项目目录

正常登录

错误登录

用户每次执行业务代码的时候都头部都需要带上token

Refresh Token

refresh token 是专用于刷新 access token 的 token。

Access Token 的有效期比较短，当 Acesss Token 由于过期而失效时，使用 Refresh Token 就可以获取到新的 Token，如果 Refresh Token 也失效了，用户就只能重新登录了。Refresh Token 及过期时间是存储在服务器的数据库中，只有在申请新的 Acesss Token 时才会验证，不会对业务接口响应时间造成影响，也不需要向 Session 一样一直保持在内存中以应对大量的请求。

__EOF__

本文作者：双双
本文链接：https://www.cnblogs.com/ccywmbc/p/16367031.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！

posted @ 2022-06-11 22:33 雙雙阅读(103) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· JUC进阶

· RabbitMQ从入门到放弃

· 学习JWT

· [java]-JWT-什么是JWT-JWT整合sprigboot

· Jwt使用笔记

阅读排行：
· 无需6万激活码！GitHub神秘组织3小时极速复刻Manus，手把手教你使用OpenManus搭建本
· Manus爆火，是硬核还是营销？
· 终于写完轮子一部分：tcp代理了，记录一下
· 别再用vector＜bool＞了！Google高级工程师：这可能是STL最大的设计失误
· 单元测试从入门到精通

公告

初始JWT原理及实战

发表于 2022-06-11 22:33阅读：103评论：0推荐：0

JWT

关注

跳至底部

昵称：雙雙
园龄： 2年9个月
粉丝： 2
关注： 0

+加关注

随笔档案

阅读排行榜

评论排行榜

1. Ajax小记(1)

ccywmbc

初始JWT原理及实战

通俗讲JWT

JWT能做什么

为什么是JWT

基于传统的session认证

认证方式

认证流程

暴露问题

基于JWT认证

认证流程

JWT优势

JWT结构

令牌组成

Header

Payload

Signature

使用JWT

封装JWT工具类

Spring Boot整合JWT

Refresh Token

公告

双双

初始JWT原理及实战

搜索

常用链接

我的标签

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论