devbox
羊村懒王
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Spring Boot集成JWT快速入门demo

作者：羊村懒王 | 2024-04-05 03:11:26

赞

踩

Spring Boot集成JWT快速入门demo

1.JWT是什么？

JWT，英文全称JSON Web Token：JSON网络令牌。为了在网络应用环境间传递声明而制定的一种基于JSON的开放标准(RFC 7519)。这个规范允许我们使用JWT在客户端和服务端之间传递安全可靠的信息。JWT是一个轻便的安全跨平台传输格式，定义了一个紧凑自包含的方式，用于通信双方之间作为 JSON 对象安全地传递信息。此信息可以通过数字签名进行验证和信任。

  • 紧凑：这个字符串简洁，数据量小，传输速度快，能通过URL参数、HTTP请求提交的数据以及HTTP Header的方式进行传递。

  • 自包含：负载中包含很多信息，比如用户的ID等。别人拿到这个字符串，就能拿到这些关键的业务信息，从而避免再通过数据库查询等方式得到它们。

JWT的结构 JWT由三段信息用.连接构成的字符串。

Header.Payload.Signature 例如：

eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJhdWQiOiIxIn0.ihOZFzg3ZGIbBMneRy-4RMqors1P3nuO-wRJnQtTzWQ

  • Header头部

承载两部分信息：token类型和采用的加密算法

  1. { 
  2.   "typ": "JWT",
  3.   "alg": "HS256"
  4. }

token类型：JWT 加密算法：HS256

  • Payload负载

存放有效信息的地方

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

  • Signature签名

对头部及负载内容进行签证。采用Header中声明的算法，接收三个参数：base64编码的Header、base64编码的Payload和密钥（secret）进行运算。密钥secret是保存在服务端的，服务端会根据这个密钥进行生成token和进行验证。

2.环境搭建

参考代码仓库里面的mysql模块，这里只贴出docker-compose.yml

  1. version: '3'
  2. services:
  3.   mysql:
  4.     image: registry.cn-hangzhou.aliyuncs.com/zhengqing/mysql:5.7
  5.     container_name: mysql_3306
  6.     restart: unless-stopped                                   
  7.     volumes:
  8.       - "./mysql/my.cnf:/etc/mysql/my.cnf"
  9.       - "./mysql/init-file.sql:/etc/mysql/init-file.sql"
  10.       - "./mysql/data:/var/lib/mysql"
  11. #      - "./mysql/conf.d:/etc/mysql/conf.d"
  12.       - "./mysql/log/mysql/error.log:/var/log/mysql/error.log"
  13.       - "./mysql/docker-entrypoint-initdb.d:/docker-entrypoint-initdb.d" # init sql script directory -- tips: it can be excute  when `/var/lib/mysql` is empty
  14.     environment:                        # set environment,equals docker run -e
  15.       TZ: Asia/Shanghai
  16.       LANG: en_US.UTF-8
  17.       MYSQL_ROOT_PASSWORD: root         # set root password
  18.       MYSQL_DATABASE: demo              # init database name
  19.     ports:                              # port mappping
  20.       - "3306:3306"

运行

docker-compose -f docker-compose.yml -p mysql5.7 up -d

初始化表

  1. DROP TABLE IF EXISTS `jwt_user`; 
  2. CREATE TABLE `jwt_user`(
  3.  `id` varchar(32) CHARACTER SET utf8 NOT NULL COMMENT '用户ID',
  4.  `username` varchar(100) CHARACTER SET utf8 NULL DEFAULT NULL COMMENT '登录账号',
  5.  `password` varchar(255) CHARACTER SET utf8 NULL DEFAULT NULL COMMENT '密码'
  6. )ENGINE = InnoDB CHARACTER SET = utf8 COMMENT = '用户表' ROW_FORMAT = Compact;
  7.  
  8.  
  9. INSERT INTO jwt_user VALUES('1','admin','123');

3.代码工程

实验目标：实现JWT的签发和验证

pom.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <parent>
  6.         <artifactId>springboot-demo</artifactId>
  7.         <groupId>com.et</groupId>
  8.         <version>1.0-SNAPSHOT</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  11.  
  12.  
  13.     <artifactId>jwt</artifactId>
  14.  
  15.  
  16.     <properties>
  17.         <maven.compiler.source>8</maven.compiler.source>
  18.         <maven.compiler.target>8</maven.compiler.target>
  19.     </properties>
  20.     <dependencies>
  21.         <dependency>
  22.             <groupId>org.springframework.boot</groupId>
  23.             <artifactId>spring-boot-starter-web</artifactId>
  24.         </dependency>
  25.  
  26.  
  27.         <dependency>
  28.             <groupId>org.springframework.boot</groupId>
  29.             <artifactId>spring-boot-autoconfigure</artifactId>
  30.         </dependency>
  31.         <!--mysql-->
  32.         <dependency>
  33.             <groupId>mysql</groupId>
  34.             <artifactId>mysql-connector-java</artifactId>
  35.             <version>8.0.29</version>
  36.         </dependency>
  37.         <dependency>
  38.             <groupId>org.springframework.boot</groupId>
  39.             <artifactId>spring-boot-starter-jdbc</artifactId>
  40.         </dependency>
  41.         <dependency>
  42.             <groupId>com.baomidou</groupId>
  43.             <artifactId>mybatis-plus-boot-starter</artifactId>
  44.             <version>3.5.1</version>
  45.         </dependency>
  46.         <dependency>
  47.             <groupId>org.projectlombok</groupId>
  48.             <artifactId>lombok</artifactId>
  49.         </dependency>
  50.         <dependency>
  51.             <groupId>org.springframework.boot</groupId>
  52.             <artifactId>spring-boot-starter-test</artifactId>
  53.             <scope>test</scope>
  54.         </dependency>
  55.         <dependency>
  56.             <groupId>com.alibaba</groupId>
  57.             <artifactId>fastjson</artifactId>
  58.             <version>1.2.47</version>
  59.         </dependency>
  60.         <dependency>
  61.             <groupId>io.jsonwebtoken</groupId>
  62.             <artifactId>jjwt</artifactId>
  63.             <version>0.9.1</version>
  64.         </dependency>
  65.         <dependency>
  66.             <groupId>com.auth0</groupId>
  67.             <artifactId>java-jwt</artifactId>
  68.             <version>3.4.0</version>
  69.         </dependency>
  70.  
  71.  
  72.  
  73.  
  74.     </dependencies>
  75. </project>

application.yaml

  1. spring:
  2.   datasource:
  3.     driver-class-name: com.mysql.cj.jdbc.Driver
  4.     url: jdbc:mysql://localhost:3306/demo?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT
  5.     username: root
  6.     password: root
  7.  
  8.  
  9. server:
  10.   port: 8088

Jwt生成

  1. package com.et.jwt.service;
  2.  
  3.  
  4. import com.auth0.jwt.JWT;
  5. import com.auth0.jwt.algorithms.Algorithm;
  6.  
  7.  
  8. import com.et.jwt.entity.User;
  9. import org.springframework.stereotype.Service;
  10.  
  11.  
  12. import java.time.Instant;
  13. import java.time.LocalDateTime;
  14. import java.time.ZoneId;
  15. import java.util.Date;
  16.  
  17.  
  18.  
  19.  
  20. @Service("TokenService")
  21.  
  22.  
  23. public class TokenService {
  24.     long  outHours=1;
  25.     public String getToken(User user) {
  26.         Instant instant = LocalDateTime.now().plusHours(outHours).atZone(ZoneId.systemDefault()).toInstant();
  27.         Date expire = Date.from(instant);
  28.         String token="";
  29.         // save information  to token ,such as: user id and Expires time
  30.         token= JWT.create()
  31.                 .withAudience(user.getId())
  32.                 .withExpiresAt(expire)
  33.                 .sign(Algorithm.HMAC256(user.getPassword()));
  34.         // use HMAC256 to generate token,key is user's password
  35.         return token;
  36.     }
  37. }

jwt验证

  1. package com.et.jwt.interceptor;
  2.  
  3.  
  4. import com.auth0.jwt.JWT;
  5. import com.auth0.jwt.JWTVerifier;
  6. import com.auth0.jwt.algorithms.Algorithm;
  7. import com.auth0.jwt.exceptions.JWTDecodeException;
  8. import com.auth0.jwt.exceptions.JWTVerificationException;
  9.  
  10.  
  11. import com.et.jwt.annotation.PassToken;
  12. import com.et.jwt.annotation.UserLoginToken;
  13. import com.et.jwt.entity.User;
  14. import com.et.jwt.service.UserService;
  15. import org.springframework.beans.factory.annotation.Autowired;
  16. import org.springframework.web.method.HandlerMethod;
  17. import org.springframework.web.servlet.HandlerInterceptor;
  18. import org.springframework.web.servlet.ModelAndView;
  19.  
  20.  
  21. import javax.servlet.http.HttpServletRequest;
  22. import javax.servlet.http.HttpServletResponse;
  23. import java.lang.reflect.Method;
  24. import java.util.Date;
  25.  
  26.  
  27.  
  28.  
  29. public class AuthenticationInterceptor implements HandlerInterceptor {
  30.     @Autowired
  31.     UserService userService;
  32.     @Override
  33.     public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object object) throws Exception {
  34.         //  get token  from http header
  35.         String token = httpServletRequest.getHeader("token");
  36.         if(!(object instanceof HandlerMethod)){
  37.             return true;
  38.         }
  39.         HandlerMethod handlerMethod=(HandlerMethod)object;
  40.         Method method=handlerMethod.getMethod();
  41.         //check is included @passtoken annotation? jump if have
  42.         if (method.isAnnotationPresent(PassToken.class)) {
  43.             PassToken passToken = method.getAnnotation(PassToken.class);
  44.             if (passToken.required()) {
  45.                 return true;
  46.             }
  47.         }
  48.         //check is included @UserLoginToken ?
  49.         if (method.isAnnotationPresent(UserLoginToken.class)) {
  50.             UserLoginToken userLoginToken = method.getAnnotation(UserLoginToken.class);
  51.             if (userLoginToken.required()) {
  52.                 // excute verify
  53.                 if (token == null) {
  54.                     throw new RuntimeException("token invalid，please login again");
  55.                 }
  56.                 // get  user id  from  token
  57.                 String userId;
  58.                 try {
  59.                     userId = JWT.decode(token).getAudience().get(0);
  60.                 } catch (JWTDecodeException j) {
  61.                     throw new RuntimeException("401");
  62.                 }
  63.                 User user = userService.findUserById(userId);
  64.                 if (user == null) {
  65.                     throw new RuntimeException("user is not exist，please login again");
  66.                 }
  67.                 // verify token
  68.                 JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256(user.getPassword())).build();
  69.                 try {
  70.                     jwtVerifier.verify(token);
  71.                     if (JWT.decode(token).getExpiresAt().before(new Date())) {
  72.                         throw new RuntimeException("token Expires");
  73.                     }
  74.  
  75.  
  76.                 } catch (JWTVerificationException e) {
  77.                     throw new RuntimeException("401");
  78.                 }
  79.  
  80.  
  81.                 return true;
  82.             }
  83.         }
  84.         return true;
  85.     }
  86.  
  87.  
  88.     @Override
  89.     public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
  90.  
  91.  
  92.     }
  93.     @Override
  94.     public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
  95.  
  96.  
  97.     }
  98. }

以上只是一些关键代码，所有代码请参见下面代码仓库

代码仓库

  • https://github.com/Harries/springboot-demo

4.测试

  • 启动Spring Boot应用

  • 登录系统

    http://localhost:8088/api/login?username=admin&password=123

  1. {
  2.  "user": {
  3.  "username": "admin",
  4.  "password": "123",
  5.  "id": "1"
  6.  },
  7.  "token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJhdWQiOiIxIn0.ihOZFzg3ZGIbBMneRy-4RMqors1P3nuO-wRJnQtTzWQ"
  8. }

  • 在header里面设置 token，访问

    http://localhost:8088/api/getMessage

24c66ffc012d08e554225b4dbc16e092.png

5.引用

  • https://www.v2ex.com/t/817906

  • http://www.liuhaihua.cn/archives/710374.html

  • https://github.com/ChuaWi/SpringBoot-JWT/tree/master

6.Questions

这里留2个问题给读者

  1. 过期了如何刷新token呢？保证过期时候重新登录，而不是后台自动刷新，一直不过期？

  2. 如果要实现强制下线用户功能，该如何实现呢？

声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号