SpringBoot 整合 JWT 实战（基于jwt）

原创 已于 2022-04-10 19:27:39 修改 · 893 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #后端 #分布式 #网络安全

于 2022-04-08 22:11:56 首次发布
本文档详细介绍了如何在SpringBoot项目中整合JWT（JSON Web Token）进行用户身份验证和授权。首先创建了用户表并导入相关依赖，接着配置了数据库连接、mybatis-plus以及JWT的相关参数。然后定义了User实体类、UserMapper接口、UserService及其实现类，实现了用户登录功能。通过Postman测试登录接口，成功后生成JWT token。之后创建JWT拦截器处理token验证，避免重复代码。最后配置拦截器，使特定接口需要token验证。整个流程展示了JWT在SpringBoot应用中的完整应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

SpringBoot 整合 JWT 实战（基于jwt）

0、环境搭建：

  1. 新建数据库表

    SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user`  (
  `user_id` int(11) NOT NULL,
  `user_name` varchar(30) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `password` varchar(40) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `real_name` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `phone` char(11) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `email` varchar(30) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `gender` enum('0','1') CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `create_time` datetime NULL DEFAULT NULL,
  `modify_time` datetime NULL DEFAULT NULL,
  `enable` tinyint(1) UNSIGNED ZEROFILL NULL DEFAULT NULL,
  PRIMARY KEY (`user_id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES (1, 'root', '123456', '吴禹凡', '18358659682', '341419199@qq.xom', '0', '2021-09-20 23:20:07', NULL, 1);

SET FOREIGN_KEY_CHECKS = 1;

  2. 导入依赖：

    <!--  jwt -->
<dependency>
    <groupId>com.auth0</groupId>
    <artifactId>java-jwt</artifactId>
    <version>3.18.2</version>
</dependency>
<!-- druid -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.2.6</version>
</dependency>
<!-- mysql-connector-java -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>
<!-- mybatis-plus -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.4.3.3</version>
</dependency>
<!-- lombok -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>

  3. 配置 application.yml 配置文件

    server:
  port: 8080

spring:
  datasource:
    username: root
    password: root
    url: jdbc:mysql://localhost:3306/mybatis?useSSL=false&characterEncoding=utf8&serverTimezone=Asia/Shanghai
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource

logging:
  level:
    root: info
    cn.edu.hziee: debug

mybatis-plus:
  configuration:
    mapUnderscoreToCamelCase: true
  type-aliases-package: cn.edu.hziee.pojo
  
jwt:
  # JWT 存储的请求头
  tokenHeader: Authorization
  # JWT 加密解密使用的密钥
  secretKey: "!QAzxZ@12^3#asd.$01.0.."
  # JWT 的过期时长（60*60*24*7）
  expiration: 2235200
  # 负载开头
  tokenHead: Bearer

  4. 在 pojo 包下新建实体类

    LoginUser：用户验证登录用的实体类

    package cn.edu.hziee.pojo;


import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;

@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("user")
public class UserLogin {

    private Integer id;
    private String name;
    private String pwd;
}

  5. 在 mapper 包下新建 UserMapper 接口

    package cn.edu.hziee.mapper;

import cn.edu.hziee.bean.UserLogin;
import cn.edu.hziee.pojo.User;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;

public interface UserMapper extends BaseMapper<UserLogin> {

}

  6. 在 service 包下新建 UserService

    package cn.edu.hziee.service;

import cn.edu.hziee.bean.UserLogin;
import cn.edu.hziee.pojo.User;
import com.baomidou.mybatisplus.extension.service.IService;

import java.util.List;

public interface UserService extends IService<UserLogin> {
    List<User> getUserByGender(String gender, int current, int sine);

    UserLogin login(String name, String pwd);

}

  7. UserServiceImpl

    package cn.edu.hziee.service.impl;

import cn.edu.hziee.bean.UserLogin;
import cn.edu.hziee.mapper.UserMapper;
import cn.edu.hziee.pojo.User;
import cn.edu.hziee.service.UserService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, UserLogin> implements UserService {

    @Autowired
    UserMapper userMapper;

    @Override
    public UserLogin login(String name, String pwd) {
        QueryWrapper<UserLogin> wrapper = new QueryWrapper();
        wrapper.eq("name",name);
        UserLogin user = userMapper.selectOne(wrapper);
        if (user != null){
            return user;
        }
        throw new RuntimeException("登陆失败~~~");
    }

}

  8. UserController

    package cn.edu.hziee.controller;

import cn.edu.hziee.bean.UserLogin;
import cn.edu.hziee.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.HashMap;
import java.util.Map;

@Controller
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;
    @ResponseBody
    @PostMapping("/login")
    public Map<String, Object> login(String name, String pwd) {
        Map<String, Object> map = new HashMap<>();
        try {
            UserLogin userLogin = userService.login(name, pwd);
            map.put("state", true);
            map.put("msg", "认证成功");
        } catch (Exception e) {
            map.put("state", false);
            map.put("msg", e.getMessage());
        }
        return map;
    }

}

  9. 启动类

    package cn.edu.hziee;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("cn.edu.hziee.mapper")
public class MainApplication {
    public static void main(String[] args) {
        SpringApplication.run(MainApplication.class,args);

    }
}

  10. 使用 Postman 进行环境的测试
    PostMan测试环境

    {
    "msg": "认证成功",
    "state": true
}

7.1、生成 token 令牌

LoginController

package cn.edu.hziee.controller;

import cn.edu.hziee.bean.UserLogin;
import cn.edu.hziee.config.JWTUtil;
import cn.edu.hziee.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.HashMap;
import java.util.Map;

@Controller
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;
    @Autowired
    private JWTUtil jwtUtil;
    @ResponseBody
    @PostMapping("/login")
    public Map<String, Object> login(String name, String pwd) {
        Map<String, Object> map = new HashMap<>();
        try {
            UserLogin userLogin = userService.login(name, pwd);
            Map<String,Object> payload = new HashMap<>();
            payload.put("id",userLogin.getId());
            payload.put("name",userLogin.getName());
            String token = jwtUtil.generateToken(payload);
            map.put("token",token);
            map.put("state", true);
            map.put("msg", "认证成功");
        } catch (Exception e) {
            System.out.println("11111");
            map.put("state", false);
            map.put("msg", e.getMessage());
        }
        return map;
    }

}

用接口 Postman 进行接口测试
在这里插入图片描述

{
    "msg": "认证成功",
    "state": true,
    "token": "eyJUeXBlIjoiSnd0IiwidHlwIjoiSldUIiwiYWxnIjoiSFMyNTYifQ.eyJjcmVhdGVUaW1lIjoxNjMzMTU4ODE0LCJuYW1lIjoi5p2O5ZubIiwiaWQiOjIsImV4cCI6MTYzNTM5NDAxNH0.baFHLoiQluXLk1Zpy3STSEK0uVkwkj2T-RoqOdKARPc"
}

7.2、验证 token 令牌

@ResponseBody
@RequestMapping("tomain")
public Map<String, Object> toMain(String token){
    Map<String, Object> map = new HashMap<>();
    try{
        DecodedJWT verify = jwtUtil.verify(token);
        map.put("state", true);
        map.put("msg", "请求成功");
        return map;
    } catch (InvalidClaimException e){
        map.put("msg", "失效的payload异常");
        e.printStackTrace();
    } catch (JWTDecodeException e){
        map.put("msg", "JWT解码异常");
        e.printStackTrace();
    }catch (SignatureVerificationException e){
        map.put("msg", "签名不一致");
        e.printStackTrace();
    }catch (TokenExpiredException e){
        map.put("msg", "令牌过期异常");
        e.printStackTrace();
    }catch (AlgorithmMismatchException e){
        map.put("msg", "算法不匹配异常");
        e.printStackTrace();
    }catch (Exception e){
        map.put("msg", "token无效");
        e.printStackTrace();
    }
    map.put("state", false);
    return map;
}

用接口 Postman 进行接口测试
在这里插入图片描述

{
    "msg": "请求成功",
    "state": true
}

在每个需要 token 验证的接口加上以上代码，会造成大量的代码冗余

7.3、JWT 拦截器

  1. 在 Interceptors 包下新建一个 InterceptorProperties 类（用于存储 application.yml 中的配置参数）

    package cn.edu.hziee.Interceptors;

import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
@Data
public class InterceptorProperties {
    @Value("${jwt.secretKey}")
    private String secretKey;
    @Value("${jwt.expiration}")
    private Long expiration;
}

  2. JWTInterceptor

    package cn.edu.hziee.Interceptors;

import cn.edu.hziee.bean.UserLogin;
import cn.edu.hziee.config.JWTUtil;
import com.auth0.jwt.exceptions.*;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.Data;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.HashMap;
import java.util.Map;

@Data
@Component
public class JWTInterceptor implements HandlerInterceptor {

    private InterceptorProperties interceptorProperties;
    private static JWTUtil jwtUtil;

    @Autowired
    private void setJWTUtil(JWTUtil jwtUtil){
        JWTInterceptor.jwtUtil = jwtUtil;
    }
    public JWTInterceptor(InterceptorProperties interceptorProperties) {
        this.interceptorProperties = interceptorProperties;
    }
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String token = request.getHeader("token");
        Map<String, Object> map = new HashMap<>();
        try{
            String secretKey = interceptorProperties.getSecretKey();
            jwtUtil.verify(token);
            return true;
        } catch (InvalidClaimException e){
            map.put("msg", "失效的payload异常");
            e.printStackTrace();
        } catch (JWTDecodeException e){
            map.put("msg", "JWT解码异常");
            e.printStackTrace();
        }catch (SignatureVerificationException e){
            map.put("msg", "签名不一致");
            e.printStackTrace();
        }catch (TokenExpiredException e){
            map.put("msg", "令牌过期异常");
            e.printStackTrace();
        }catch (AlgorithmMismatchException e){
            map.put("msg", "算法不匹配异常");
            e.printStackTrace();
        }catch (Exception e){
            map.put("msg", "token无效");
            e.printStackTrace();
        }
        map.put("state", false);
        String json = new ObjectMapper().writeValueAsString(map);
        response.setContentType("application/json;charset=UTF-8");
        response.getWriter().println(json);
        return false;
    }
}

  3. InterceptorConfig

    package cn.edu.hziee.config;

import cn.edu.hziee.Interceptors.InterceptorProperties;
import cn.edu.hziee.Interceptors.JWTInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
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 {

    @Autowired
    private InterceptorProperties interceptorProperties;
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new JWTInterceptor(interceptorProperties))
                .addPathPatterns("/user/tomain")
                .excludePathPatterns("/user/login");
    }
}

  4. 用接口 Postman 进行接口测试

在这里插入图片描述

token 由前端存储在 localStorage 中

上一篇：JWT实现及工具类编写（使用jwt）

SpringBoot整合JWT实战：从零构建无状态认证系统，详解Token生成、验证与安全最佳实践
专注Java开发与国产数据库技术分享，涵盖达梦DM8/OceanBase/GaussDB核心原理与实战，兼及DeepSeek大模型部署、YOLOv11训练等AI技术，为开发者提供从基础到进阶的技术干货。
06-08 1231
JWT在SpringBoot中的实现与应用 摘要：本文介绍了JWT(JSON Web Token)的基本概念、与Session机制的对比，以及SpringBoot项目中JWT的整合实现。JWT由Header、Payload和Signature三部分组成，具有无状态、跨域支持等优势。文章详细展示了如何在SpringBoot项目中配置JWT环境，封装JWT工具类来实现Token的生成、解析和验证功能，包括密钥管理、自定义声明、签名验证等核心操作。通过对比表格和生活化比喻，帮助读者理解JWT与传统Session的
SpringBoot集成JWT
SHENG_Z的博客
06-06 615
介绍SpringBoot集成JWT步骤及注意事项，干货满满
JWT
m0_46487331的博客
12-14 1017
Author：Allen_Huang Version：1.0.0 一. JWT简介 什么是JWT？ JWT(JSON Web Token)是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准。 它将用户信息加密到token里，服务器不保存任何用户信息。服务器通过使用保存的密钥验证token的正确性，只要正确即通过验证；应用场景如用户登录。JWT详细讲解请见 github：https://github.com/jwtk/jjwt 为什么使用JWT？ 随着技术的发展，分布式web应用的普.
SpringBoot整合JWT实战
wang1253的博客
07-06 484
jwt介绍就不多说了，下面通过代码演示开发过程中jwt的使用。 （1）在pom.xml中引入对应的jar <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt</artifactId> <version>0.7.0</version> </dependency> （2）引入jwt工具类：to...
SpringBoot+JWT实战（附源码）
优快云_KONGlX的博客
07-04 420
.markdown-body { line-height: 1.75; font-weight: 400; font-size: 16px; overflow-x: hidden; color: rgba(51, 51, 51, 1) } .markdown-body h1, .markdown-body h2, .markdown-body h3, .markdown-body h4, .ma...
SpringBoot整合JWT实战指南
JWT实战 在SpringBoot中实现JWT，首先需要在pom.xml中添加jjwt依赖，版本为0.9.1： ```xml <groupId>io.jsonwebtoken <artifactId>jjwt <version>0.9.1 ``` 然后，在application.properties中配置JWT的相关属性...
SpringBoot整合JWT + Shiro
weixin_43920711的博客
10-28 7398
一、什么是Shiro Shiro是apache旗下一个开源框架，它将软件系统的安全认证相关的功能抽取出来，实现用户身份认证，权限授权、加密、会话管理等功能，组成了一个通用的安全认证框架。 三个核心组件：Subject, SecurityManager 和 Realms 三大核心组件： Subject：主体 主体，代表了当前的“用户”，这个用户不一定是一个具体的人，与当前应用交互的任何东西都是主体，如第三方进程、网络爬虫、机器人等，Subject是一个抽象概念，所有的Subject都绑定到Securi
SpringBoot 整合 JWT 实现 Token 登录验证的简单实现
weixin_46410481的博客
11-19 1737
SpringBoot 整合 JWT 实现 Token 登录验证的实现 在实现案例之前，要先去理解 JWT 的概念 以及 它与传统方式的区别和优点。 1、什么是 JWT？ JSON WEB TOKEN （JWT）,是为了在网络应用环境间传递声明而执行的一种基于 JSON 的开放标准（RFC 7519），该 TOKEN 被设计为紧凑且安全的，特别适用于分布式站点的单点登录（SSO）场景。JWT的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服务器获取资源，也可以增加一些额外的其他
SpringBoot整合JWT登录验证实战教程
"SpringBoot使用JWT实现登录验证的方法示例" 本文将深入探讨如何在SpringBoot应用中利用JWT（JSON Web Token）进行登录验证。JWT是一种广泛采用的身份验证和授权机制，它允许安全地在客户端和服务器之间传递信息，...
SpringBoot整合JWT
10-09
详细解说并进行代码实例，运用springBoot结合JWT来进行认证。
jwt，springboot整合
06-03
jwt，springboot整合，jwt，springboot整合，jwt，springboot整合，jwt，springboot整合
Springboot集成jwt
chen的博客
03-16 961
导入依赖 <!--jwt--> <dependency> <groupId>com.auth0</groupId> <artifactId>java-jwt</artifactId> <version>3.10.3</version> </dependency> 编写jwt工具类 TokenUt
springboot集成JWT
weixin_67958017的博客
02-02 4372
JWT是JSON Web Token的缩写，是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准((RFC 7519)。JWT本身没有定义任何技术实现，它只是定义了一种基于Token的会话管理的规则，涵盖Token需要包含的标准内容和Token的生成过程，特别适用于分布式站点的单点登录(SSO) 场景。JSON Web Token是目前最流行的跨域认证解决方案,，适合。
SpringBoot集成jwt
stars__river的博客
06-26 771
jwt的简单使用
史上最全面的基于JWT token登陆验证
SuperBins的博客
07-18 3680
介绍JWT 1、什么是JWT：JWT（Json web token）, 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准（(RFC 7519)。 2、JWT的组成： jwt由header（头部），playload（载荷）、signature（签名三部分组成） 头部部分header { “alg”: “HS256”, “typ”: “JWT” } alg描述的是签名算法。默认值是HS...
springboot 集成JWT
weixin_55384994的博客
03-13 304
jwt的请求流程 用户使用账号和面发出post请求； 服务器使用私钥创建一个jwt； 服务器返回这个jwt给浏览器； 浏览器将该jwt串在请求头中像服务器发送请求； 服务器验证该jwt； 返回响应的资源给浏览器。 优点 简洁(Compact):可以通过URL，POST参数或者在HTTP header发送，因为数据量小，传输速度也很快 自包含(Self-contained)：负载中包含了所有用户所需要的信息，避免了多次查询数据库 因为Token是以JSON加密的形式保存在客户端的，所以J..
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

bit-apk-code

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值