【SpringBoot】SpringBoot + JWT+ Mybatis 整合

谁践踏了优雅 2023-10-01 17:20 9阅读 0赞

现需要完成以下需求：

> 用户执行登录接口之后，需要生成一个 token 返回给前端。之后，前端在请求头中携带着 token 去请求其它的后台接口。

完成这个需求之前，咱们先来了解下什么是 JWT 吧。

### 1. 了解 JWT ###

#### 1.1 JWT 的介绍 ####

JWT 简介：

**JWT 全称 Json Web Token**。它是 RFC 7519 中定义的，用于安全地将信息作为 Json 对象进行传输的一种形式。JWT 中存储的信息是经过“数字签名”的，因此可以被信任和理解。可以使用 HMAC 算法或使用 RSA/ECDSA 的公用/专用 密钥对 JWT 进行签名。

JWT 作用：

JWT 有以下两个作用：

1.  认证：一旦用户登录，后面每个请求都会包含 JWT，从而允许用户访问该令牌所允许的路由、服务和资源。单点登录是当今广泛使用 JWT 的一项功能，因为它的开销很小。
2.  信息交换：JWT 是能够安全传输信息的一种方式。通过使用公钥/私钥对 JWT 进行签名认证。此外，由于签名是使用 head 和 payload 计算的，因此你还可以验证内容是否遭到篡改。

#### 1.2 JWT 的结构 ####

JWT 主要由三部分组成，每个部分用 . 进行分割，各个部分分别是：

*  标头 Header
 *  有效载荷 Payload
 *  签名 Signature

因此，JWT 通常是：`xxx.yyyy.zzzzz`

例如：

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9
    .
    eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ
    .
    SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

##### 1.2.1 标头 Header #####

Header是 JWT 的标头，包括两部分信息：

*  令牌的类型：JWT
 *  加密算法：HMAC SHA256 或 RSA

如 JWT 的默认标头为：

{
        
        "alg": "HS256",  // 算法
        "typ": "JWT"     // 类型
    }

然后将 Header 进行 **base64 编码**，就构成了 JWT 第一部分：

eyJhbGciOiAiSFMyNTYiLCAidHlwIjogIkpXVCJ9

--------------------

Base64

在 Java 中，就可以实现 Base64 编码。如下：

这是对 JWT 的默认标头进行 Base64 编码、解码：

public class Test {
        
        public static void main(String[] args) throws Exception{
        
            Base64.Encoder encoder = Base64.getEncoder();
            Base64.Decoder decoder = Base64.getDecoder();
    
            String header = "{\"alg\": \"HS256\", \"typ\": \"JWT\"}";
            byte[] headerBytes = header.getBytes();
            // 编码
            String encodeHeader = encoder.encodeToString(headerBytes);
            System.out.println(encodeHeader);
            // 解码
            byte[] decode = decoder.decode(encodeHeader);
            System.out.println(new String(decode, "UTF-8"));
        }
    }

##### 1.2.2 有效载荷 Payload #####

Payload 中包含一个声明。声明是有关实体（通常是用户）和其他数据的声明。同样地，它会使用 base64 编码构成了 JWT 第二部分 。共有三种类型的声明：registered、public 和 private 声明

1、registered 声明

registered 声明：包含一组建议使用的预定义声明，主要包括：

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

2、public 声明

public 声明：公共的声明，可以添加任何的信息，一般添加用户的相关信息或其他业务需要的必要信息，但不建议添加敏感信息，因为该部分在客户端可解密。

3、private 声明

private 声明：自定义声明，旨在在同意使用它们的各方之间共享信息，既不是注册声明也不是公共声明。

如：

{
        
        "sub": "1234567890",
        "name": "John Doe",
        "iat": 1516239022
    }

*  name：自定义字段
 *  sub/iat：标准声明

然后将 Payload进行 **base64编码** 构成了第二部分：

eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ

##### 1.2.3 签名 Signature #####

Signature表示签证信息，它包含三个部分：

*  header (base64后的)
 *  payload (base64后的)
 *  secret

比如我们需要 HMAC SHA256 算法进行签名:

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

签名用于验证消息在此过程中没有更改，并且对于使用私钥进行签名的令牌，它还可以验证 JWT 的发送者的真实身份

### 2. 使用 JWT ###

引入依赖：

这里是使用的 SpringBoot 的测试类。这里可以跟我不一样哈，把这两个方法换成 main 就行。

public class AppTest {
        
    
        // 密钥（复杂）
        private static final String SECRET = "1qazXSW2";
    
        @Test
        public void createToken() {
        
            Map<String, Object> map = new HashMap<>();
            Calendar expireTime = Calendar.getInstance();
            expireTime.add(Calendar.SECOND, 2000);
    
            String token = JWT.create()
                    // Header(使用默认数据，故map没有值。也可省略此行代码)
                    .withHeader(map)
                    // Payload
                    .withClaim("userId", 666)
                    .withClaim("username", "zzc")
                    // 过期时间
                    .withExpiresAt(expireTime.getTime())
                    // Signature
                    .sign(Algorithm.HMAC256(SECRET));
            System.out.println(token);
        }
    
        @Test
        public void verifyToken() {
        
            JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256(SECRET)).build();
            String token = "";
            DecodedJWT decodedJWT = jwtVerifier.verify(token);
    		// 获取 token 中的信息
            System.out.println(decodedJWT.getClaim("userId").asInt());
            System.out.println(decodedJWT.getClaim("username").asString());
        }
    }

说明：

1.  `createToken()`：生成 token 的方法。由于 token 的第二部分 `Payload` 是可以存放信息的。所以，这里，我把 `userId`、`username` 放入 token 中。后期，可以根据 token 进行获取相应的值。
2.  `verifyToken()`：验证 token 的方法。`DecodedJWT decodedJWT = jwtVerifier.verify(token);` 如果 token 验证失败，则这行代码会抛出异常；否则，就会执行成功，继续往下执行。然后，就可以获取 token 中的信息 `decodedJWT.getClaim("username").asString()`。

### 3. SpringBoot 集成 JWT ###

【开发环境】

*  IDEA-2020.2
 *  SpringBoot-2.5.5
 *  MAVEN-3.5.3
 *  Mybatis
 *  Mysql

【项目结构图】  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAc2NvNTI4Mg_size_16_color_FFFFFF_t_70_g_se_x_16]  
1、引入依赖

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <dependency>
        <groupId>com.auth0</groupId>
        <artifactId>java-jwt</artifactId>
        <version>3.4.0</version>
    </dependency>
    
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.0.0</version>
    </dependency>
    
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.38</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>

2、添加 `application.yml` 配置

spring:
      datasource:
        url: jdbc:mysql://localhost:3306/zzc?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
        password: root
        username: root
        driver-class-name: com.mysql.jdbc.Driver
    
    mybatis:
      type-aliases-package: com.zzc.entity # 实体类别名
      mapper-locations: classpath:mapper/*.xml # mapper 配置文件(必要)
      configuration:
        map-underscore-to-camel-case: true # 驼峰命名

3、添加 JWT 工具类

将生成 token 方法、验证 token 方法抽象成一个工具类：

public class JwtUtil {
        
    
        private static final String SECRET = "1qazXSW2";
    
        // 生成 Token
        public static String createToken(Map<String, String> paramMap) {
        
            Map<String, Object> headMap = new HashMap<>();
            Calendar expireTime = Calendar.getInstance();
            // 过期时间默认是 7 天
            expireTime.add(Calendar.DATE, 7);
    
            JWTCreator.Builder builder = JWT.create();
            // Header(使用默认数据，故map没有值，可以省略)
            builder.withHeader(headMap);
            // Payload
            paramMap.forEach((key, value) -> {
        
                builder.withClaim(key, value);
            });
            // 过期时间
            String token = builder.withExpiresAt(expireTime.getTime())
                    // Signature
                    .sign(Algorithm.HMAC256(SECRET));
            return token;
        }
    
        // 验证token合法性
        public static void verify(String token) {
        
            JWT.require(Algorithm.HMAC256(SECRET)).build().verify(token);
        }
    
        // 获取token信息
        public static DecodedJWT getTokenInfo(String token) {
        
            return JWT.require(Algorithm.HMAC256(SECRET)).build().verify(token);
        }
    
    }

4、添加 Controller 类

这个 Controller 类中有两个接口：

@Slf4j
    @RestController
    @RequestMapping("/user")
    public class UserController {
        
    
        @Autowired
        private UserService userService;
    
        @GetMapping("/login")
        public Map<String, Object> login(User user) {
        
            log.info("用户名：【{}】", user.getName());
            log.info("密码：【{}】", user.getPwd());
            Map<String, Object> map = new HashMap<>();
            try {
        
                User u = userService.login(user);
    
                // 生成 token
                Map<String, String> payload = new HashMap<>();
                payload.put("id", u.getId());
                payload.put("name", u.getName());
                String token = JwtUtil.createToken(payload);
    
                map.put("status", true);
                map.put("msg", "认证成功");
                map.put("token", token);
            } catch (Exception e) {
        
                map.put("status", false);
                map.put("msg", e.getMessage());
            }
            return map;
        }
    
        @PostMapping("/testToken")
        public Map<String, Object> testToken(String token) {
        
            log.info("当前登录token：【{}】", token);
            Map<String, Object> map = new HashMap<>();
            try {
        
                JwtUtil.verify(token);
                map.put("status", true);
                map.put("msg", "请求成功");
                return map;
            } catch (SignatureVerificationException e) {
        
                log.error("【请求失败】：{}", e.getMessage());
                map.put("msg", "无效签名");
            } catch (TokenExpiredException e) {
        
                log.error("【请求失败】：{}", e.getMessage());
                map.put("msg", "token过期");
            } catch (AlgorithmMismatchException e) {
        
                log.error("【请求失败】：{}", e.getMessage());
                map.put("msg", "token算法不一致");
            } catch (Exception e) {
        
                log.error("【请求失败】：{}", e.getMessage());
                map.put("msg", "token无效");
            }
            map.put("status", false);
            return map;
        }
    }

说明：

1.  `login()`：用户登录成功后，通过 JWT 生成一个 token，然后，token 中存入了用户的 `id`、`name`，然后，直接将 token 返回给前端
2.  `testToken()`：请求此接口时，需要在请求头中携带 token `JwtUtil.verify(token);`，否则，就会报错。

5、添加 UserServiceImpl 类

UserService 接口省略

@Service
    public class UserServiceImpl implements UserService {
        
    
        @Autowired
        private UserMapper userMapper;
    
        @Override
        public User login(User user) {
        
            User u = userMapper.login(user);
            if (null != u) {
        
                return u;
            }
            throw new RuntimeException("认证失败");
        }
    }

6、添加 UserMapper 接口

public interface UserMapper {
        
        User login(User user);
    }

与之对应的 UserMapper.xml 文件：

<!DOCTYPE mapper
            PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.zzc.mapper.UserMapper">
    
        <select id="login" parameterType="User" resultType="User">
            SELECT
                id,name,pwd
            FROM TAB_USER
            WHERE 1=1
            AND name = #{name}
            AND pwd = #{pwd}
        </select>
    
    </mapper>

通过用户名和密码查询用户信息。

7、运行代码

7-1、调用登录接口

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAc2NvNTI4Mg_size_20_color_FFFFFF_t_70_g_se_x_16]  
认证成功后，返回了一个 token。前端可以将这个 token 进行保存，然后携带在请求头中。

7-2、调用其它接口

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAc2NvNTI4Mg_size_20_color_FFFFFF_t_70_g_se_x_16 1]  
请求中没有携带 token，则会请求失败 “token 无效”。

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAc2NvNTI4Mg_size_20_color_FFFFFF_t_70_g_se_x_16 2]  
请求中携带了 token，则会请求成功 。

8、优化代码

通常，一个项目中是有非常多的后台接口的，难道每一个后台接口都需要写那么多冗余的代码来校验 token 吗？

显然，不是这样滴！

这个时候我们想到了拦截器 Interceptor。如下：

8-1、添加一个拦截器

@Slf4j
    public class JwtInterceptor implements HandlerInterceptor {
        
    
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        
            Map<String, Object> map = new HashMap<>();
            String token = request.getHeader("token");
            try {
        
                JwtUtil.verify(token);
                // 放行
                return true;
            } catch (SignatureVerificationException e) {
        
                log.error("【请求失败】：{}", e.getMessage());
                map.put("msg", "无效签名");
            } catch (TokenExpiredException e) {
        
                log.error("【请求失败】：{}", e.getMessage());
                map.put("msg", "token过期");
            } catch (AlgorithmMismatchException e) {
        
                log.error("【请求失败】：{}", e.getMessage());
                map.put("msg", "token算法不一致");
            } catch (Exception e) {
        
                log.error("【请求失败】：{}", e.getMessage());
                map.put("msg", "token无效");
            }
            // 将错误消息返回给前台
            map.put("status", false);
            // 将Map转化为json字符串
            String errorResult = new ObjectMapper().writeValueAsString(map);
            response.setContentType("application/json;charset=UTF-8");
            response.getWriter().println(errorResult);
            return false;
        }
    
    }

注意：从请求头中获取 token

若 token 校验失败，则将失败信息返回给前台。

8-2、添加一个拦截器配置类

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

说明：

*  上述配置：`/user/testToken2` 的 url 进行拦截；`/user/login` 不进行拦截。

8-3-1、新增一个接口

public class UserController {
        
    
        @Autowired
        private UserService userService;
    	
    	// ...
    
        @PostMapping("/testToken2")
        public Map<String, Object> testToken2(HttpServletRequest request) {
        
            // 处理自己的业务逻辑
            String token = request.getHeader("token");
            DecodedJWT tokenInfo = JwtUtil.getTokenInfo(token);
            log.info("用户ID：【{}】", tokenInfo.getClaim("id").asString());
            log.info("用户名：【{}】", tokenInfo.getClaim("name").asString());
            Map<String, Object> map = new HashMap<>();
            map.put("status", true);
            map.put("msg", "请求成功");
            return map;
        }
    
    }

8-3-2、测试这个接口  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAc2NvNTI4Mg_size_20_color_FFFFFF_t_70_g_se_x_16 3]  
若 **请求头** 中不携带 token，则请求失败

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAc2NvNTI4Mg_size_20_color_FFFFFF_t_70_g_se_x_16 4]  
若 **请求头** 中携带 token，则请求成功

好了，SpringBoot + JWT 就到这了。

--------------------

[源码地址][Link 1]

[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAc2NvNTI4Mg_size_16_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/173ec085da1c452f8d026ee4293c6def.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAc2NvNTI4Mg==,size_16,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAc2NvNTI4Mg_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/d014132f9e6e4e10812c804583f8aaae.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAc2NvNTI4Mg==,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAc2NvNTI4Mg_size_20_color_FFFFFF_t_70_g_se_x_16 1]: https://img-blog.csdnimg.cn/1908f98f064c469f96d9c67879133345.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAc2NvNTI4Mg==,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAc2NvNTI4Mg_size_20_color_FFFFFF_t_70_g_se_x_16 2]: https://img-blog.csdnimg.cn/2b28eb24c2584227b9fc7683da052165.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAc2NvNTI4Mg==,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAc2NvNTI4Mg_size_20_color_FFFFFF_t_70_g_se_x_16 3]: https://img-blog.csdnimg.cn/4e34250844cc4089b44df756975d61c4.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAc2NvNTI4Mg==,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAc2NvNTI4Mg_size_20_color_FFFFFF_t_70_g_se_x_16 4]: https://img-blog.csdnimg.cn/4bdde6a98b59473a8926de647f505744.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAc2NvNTI4Mg==,size_20,color_FFFFFF,t_70,g_se,x_16
[Link 1]: https://gitee.com/sco5282/middleware.git