springboot整合JWT

最新推荐文章于 2025-04-01 08:15:00 发布
最新推荐文章于 2025-04-01 08:15:00 发布
阅读量181 收藏
点赞数
分类专栏： 安全框架系列 文章标签： java spring maven
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_41928421/article/details/121516083
版权

有关JWT的详解可上网查资料，其主要就是用来生成token，举个例子，访问接口需要先进行登录认证，认证通过才能进行访问。也就是先通过用户名和密码登录，后台查询是否存在该用户，若存在则生成token返回，当访问其他接口时携带token请求，后台验证token，验证成功则可以访问，验证失败则禁止访问。

下面为使用JWT生成token以及验证token的简单测试代码：

生成token：

 @Test
    public void jwtTest() {
        //设置从现在开始10秒后
        Calendar instance = Calendar.getInstance();
        instance.add(Calendar.SECOND,90);
        //生成令牌
        String token = JWT.create()
                .withClaim("username","张三") //设置自定义用户名
                .withExpiresAt(instance.getTime())  //设置过期时间
                .sign(Algorithm.HMAC256("token*!us%#Eu"));  //设置签名 尽量复杂
        //输出令牌
        System.out.println(token);

运行结果：

eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2Mzc3Mzg0NTksInVzZXJuYW1lIjoi5byg5LiJIn0.yjomlApRc9lVb8CI0Nn6kh5GUCeCHfDQDZOvBn6e31A

验证token：

@Test
    public void JwtVerifyTest() {
        //生成token时所使用的签名
        JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256("token*!us%#Eu")).build();
        //验证生成的token
        DecodedJWT decodedJWT = jwtVerifier.verify("eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2Mzc3Mzg0NTksInVzZXJuYW1lIjoi5byg5LiJIn0.yjomlApRc9lVb8CI0Nn6kh5GUCeCHfDQDZOvBn6e31A");
        System.out.println("用户名：" + decodedJWT.getClaim("username").asString());//存的什么类型取就用什么类型
        System.out.println("过期时间：" + decodedJWT.getExpiresAt());
    }

运行结果：

用户名：张三
过期时间：Wed Nov 24 15:20:59 CST 2021
======================================================================

======================================================================

下面使用Springboot+JWT来实现用户想要访问某些业务接口需要先登录、获取token、验证token，验证通过才可以访问。

工程目录：

pom.xml配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.0.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>org.example</groupId>
    <artifactId>java_test</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--引入mybatis-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.3</version>
        </dependency>

        <!--引入jwt-->
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.10.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>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>



</project>

resource下的application.properties配置文件：

server.port=8989
server.servlet.context-path=/jwt_demo

spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/pcprtest?serverTimezone=Asia/Shanghai&useSSL=true
spring.datasource.username=root
spring.datasource.password=12345

mybatis.type-aliases-package=com.test.entity
mybatis.mapper-locations=classpath:mapper/*.xml

logging.level.com.test.dao=debug

 由于本次针对实现token获取及验证流程，所涉及的代码十分简单，在此省略entity、dao、mapper的代码。

JWT工具类：

package com.test.utils;

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTCreator;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.DecodedJWT;

import java.util.Calendar;
import java.util.Map;

public class JWTUtils {

    private static String TOKEN = "token*!us%#Eu";

    /**
     * 生成token
     * @param map
     * @return
     */
    public static String getToken(Map<String,String> map) {
        JWTCreator.Builder builder = JWT.create();
        //这里采用lambda表达式
        //遍历map，设置负载（payload）
        map.forEach((k,v) -> builder.withClaim(k,v));
        Calendar instance = Calendar.getInstance();
        instance.add(Calendar.SECOND,90);
        builder.withExpiresAt(instance.getTime());
        return builder.sign(Algorithm.HMAC256(TOKEN));
    }

    /**
     * 验证token
     * @param token
     */
    public static void verify(String token) {
        JWT.require(Algorithm.HMAC256(TOKEN)).build().verify(token);
    }

    /**
     * 获取token中的负载信息（payload）
     * @param token
     * @return
     */
    public static DecodedJWT getTokenInfo(String token) {
        return JWT.require(Algorithm.HMAC256(TOKEN)).build().verify(token);
    }
}

UserService接口：

package com.test.service;

import com.test.entity.UserEntity;

public interface UserService {
    UserEntity login(UserEntity user);
}

 UserServiceImpl实现类：

package com.test.service.impl;

import com.test.dao.UserDao;
import com.test.entity.UserEntity;
import com.test.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Service("userService")
@Transactional
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    @Override
    @Transactional(propagation = Propagation.SUPPORTS)
    public UserEntity login(UserEntity user) {
        //根据接收的用户名和密码查询数据库
        UserEntity userEntity = userDao.login(user);
        if (userEntity != null) {
            return userEntity;
        }
        throw new RuntimeException("登录失败--");
    }
}

ControllerTest类：

package com.test.controller;

import com.auth0.jwt.exceptions.AlgorithmMismatchException;
import com.auth0.jwt.exceptions.SignatureVerificationException;
import com.auth0.jwt.exceptions.TokenExpiredException;
import com.test.entity.UserEntity;
import com.test.service.UserService;
import com.test.utils.JWTUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

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

@RestController
@PostMapping("/user")
@Slf4j
public class ControllerTest {

    @Autowired
    UserService userService;

    @RequestMapping("/login")
    public Map<String,Object> login(@RequestBody UserEntity user) {
        Map<String,Object> result = new HashMap<>();
        log.info("用户名：[{}]",user.getUsername());
        log.info("密码：[{}]",user.getPassword());
        try {
            UserEntity userEntity = userService.login(user);
            Map<String,String> payloadMap = new HashMap<>();
            payloadMap.put("id",userEntity.getId().toString());
            payloadMap.put("username",userEntity.getUsername());
            String token = JWTUtils.getToken(payloadMap);
            result.put("state",true);
            result.put("msg","登陆成功~");
            result.put("token",token);
        } catch (Exception e) {
            result.put("state",false);
            result.put("msg",e.getMessage());
        }
        return result;
    }

    @PostMapping("/verify")
    public Map<String,Object> verify(@RequestParam("token") String token) {
        Map<String,Object> map = new HashMap<>();
        try {
            JWTUtils.verify(token);
            map.put("state",true);
            map.put("msg","验证通过~~");
        } catch (TokenExpiredException e) {
            map.put("state",false);
            map.put("msg","token已过期！");
        } catch (SignatureVerificationException e) {
            map.put("state",false);
            map.put("msg","签名错误！");
        } catch (AlgorithmMismatchException e) {
            map.put("state",false);
            map.put("msg","算法不匹配！");
        } catch (Exception e) {
            e.printStackTrace();
            map.put("state",false);
            map.put("msg","无效token！");
        }
        return map;
    }

}

Postman调用登录接口进行测试：

输入错误的用户名和密码：

输入正确的用户名和密码：

下面来测试token验证接口：

token过期

错误的token

有效的token

 那么又有问题了，如果这么设计，每个接口都需要加上token验证流程，产生代码冗余。因此我们采用拦截器来实现需求。

 自定义拦截器JWTInterceptor类：

package com.test.interceptor;

import com.auth0.jwt.exceptions.AlgorithmMismatchException;
import com.auth0.jwt.exceptions.SignatureVerificationException;
import com.auth0.jwt.exceptions.TokenExpiredException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.test.utils.JWTUtils;
import org.springframework.web.servlet.HandlerInterceptor;

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

public class JWTIntercepter implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String token = request.getHeader("token");
        Map<String,Object> map = new HashMap<>();
        try {
            JWTUtils.verify(token);
            map.put("state",true);
            map.put("msg","验证通过~~");
            return true;
        } catch (TokenExpiredException e) {
            map.put("state",false);
            map.put("msg","token已过期！");
        } catch (SignatureVerificationException e) {
            map.put("state",false);
            map.put("msg","签名错误！");
        } catch (AlgorithmMismatchException e) {
            map.put("state",false);
            map.put("msg","算法不匹配！");
        } catch (Exception e) {
            e.printStackTrace();
            map.put("state",false);
            map.put("msg","无效token！");
        }
        String json = new ObjectMapper().writeValueAsString(map);
        response.setContentType("application/json;charset=UTF-8");
        response.getWriter().println(json);
        return false;
    }
}

 

 拦截器配置类InterceptorConfig：

package com.test.config;

import com.test.interceptor.JWTIntercepter;
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 {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new JWTIntercepter())
                .excludePathPatterns("/user/**")    //  放行/User/**的请求路径
                .addPathPatterns("/**"); //  拦截除了/user/**的所有请求路径
    }
}

添加其他的业务Controller类：

package com.test.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

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

@RestController
@RequestMapping("/business")
public class BusinessController {

    @RequestMapping("/test1")
    public Map<String,Object> businessOne() {
        Map<String,Object> map = new HashMap<>();
        map.put("msg","业务接口1");
        map.put("state",true);
        return map;
    }
    @RequestMapping("/test2")
    public Map<String,Object> businessTwo() {
        Map<String,Object> map = new HashMap<>();
        map.put("msg","业务接口2");
        map.put("state",true);
        return map;
    }
    @RequestMapping("/test3")
    public Map<String,Object> businessThree() {
        Map<String,Object> map = new HashMap<>();
        map.put("msg","业务接口3");
        map.put("state",true);
        return map;
    }
}

 

下面来进行测试：

不登录直接调用业务接口

登录后获取token，之后将token放入请求头中调用业务接口

 至此，Springboot+JWT实现token获取验证的流程就实现了~~~

 

SPRINGBOOT+JWT
07-16
最新springboot+jwt校验案例，完整代码，下载即用，最新springboot+jwt校验案例，完整代码，下载即用，
xmljava系统源码-JWT-DEMO:SpringBoot整合JWT完成权限验证功能示例
06-06
SpringBoot整合JWT完成权限验证功能示例 JWT官网：  JWT(Java版)的github地址: 什么是JWT Json Web Token（JWT）：JSON网络令牌，是为了在网络应用环境间传递声明而制定的一种基于JSON的开放标准（(RFC 7519)。JWT...
【SpringBoot整合JWT】
蛋饼吧的博客
05-18 9687
1.认证方式我们知道，http协议本身是一种无状态的协议，而这就意味着如果用户向我们的应用提供了用户名和密码来进行用户认证，那么下一次请求时，用户还要再一次进行用户认证才行，因为根据http协议，我们并不能知道是哪个用户发出的请求，所以为了让我们的应用能识别是哪个用户发出的请求，我们只能在服务器存储一份用户登录的信息，这份登录信息会在响应时传递给浏览器，告诉其保存为cookie,以便下次请求时发送给我们的应用，这样我们的应用就能识别请求来自哪个用户了,这就是传统的基于session认证。
Spring Boot整合JWT详解
最新发布
weixin_52578852的博客
04-01 824
JWT(JSON Web Token)是一种开放标准(RFC 7519)，用于在各方之间安全地传输信息作为JSON对象。它由三部分组成：Header(头部)、Payload(负载)和Signature(签名)。.addClaims(claims) // 添加自定义声明.compact();
Springboot +JWT
FlyAway的博客
09-07 5092
本文主要是springboot 集成 JWT来实现登录权限保护. 先简单介绍一下JWT： JSON Web Token（JWT）是一个开放的标准（RFC 7519），它定义了一个紧凑且自包含的方式，用于在各方之间以JSON对象安全地传输信息。这些信息可以通过数字签名进行验证和信任。可以使用秘密（使用HMAC算法）或使用RSA的公钥/私钥对来对JWT进行签名。 具体的JWT介绍可以查看官网：h...
Springboot+JWT
while(life)++；
10-21 553
JWT（JSON WEB TOKEN）是一种标准，用来在前后端或者系统间以JSON对象安全的传输信息，该信息是可以被验证和信任的，因为它是数字签名的。可以使用HMAC或RSA或ECDSA的公钥/私钥进行签名。
Spring Boot + jwt
weixin_63831348的博客
06-20 3822
Spring Boot + jwt
SpringBoot整合JWT
10-09
SpringBoot 整合 JWT 认证机制 在本篇文章中，我们将详细介绍如何使用 SpringBoot 和 JWT（JSON Web Token）来实现认证机制。JWT是一种基于 JSON 的令牌，用于认证和授权。下面我们将详细解说 JWT 的组成、使用方法...
Springboot整合JWT,Swagger.zip
07-12
SpringBoot整合JWT与Swagger是现代Web开发中两个重要的技术组件，它们可以极大地提升应用程序的效率和易用性。JWT（Json Web Token）用于安全地在客户端和服务器之间传输信息，而Swagger则是用于构建RESTful API的...
springboot+jwt
while(life)++；
05-06 426
流程： 1.用户访问login接口，验证用户身份信息，并生成token绑定用户信息，token返回前端 2.前端把token存入request header中访问后端接口即可成功，否则提示无权访问 代码部分： 1.JwtUtil类 （生成token，校验token等） /* * * @Author qy * <p> JWT工具类 </p> * @Param * @Return */ public class JwtUtil { // Token过期时间30分钟
Spring-SpringBootSecurity-JWT
02-16
Spring-SpringBootSecurity-JWT
Springboot：JWT
沉迷写代码的程序猿的博客
03-22 4329
文章目录Springboot：JWT一、JWT简介1、JWT的优势2、JWT的结构2.1、标头（Header）2.2、有效负荷（Payload）2.3、签名（Signature）二、SpringBoot整合JWT Springboot：JWT 一、JWT简介 JWT，是指JSON Web Token，也就指通过JSON形式作为Web应用中的令牌，用于在各方之间安全地将信息作为JSON对象传输。在数据传输过程中还可以完成数据加密、签名等相关处理。 1、JWT的优势 在JavaWeb阶段，经常使用ses
使用SpringBoot + JWT
SongSir001的博客
01-21 761
文章目录简介JWT的格式怎样使用token？JWT 实战加入Maven jwt 依赖在application.proterties中加入配置JwtHelper工具类JWT过滤器JwtFilter配置JWT在Controller中使用JWT辅助工具类JsonResult 作者：固安李庆海 链接：https://www.jianshu.com/p/620a9b15a619 来源：简书 著作权归作者所有...
springboot集成Jwt
bb159632478的博客
11-10 302
一. 前言 目前web开发前后端已经算非常的普及了。前后端分离要求我们对用户会话状态要进行一个无状态处理。我们都知道通常管理用户会话是session。用户每次从服务器认证成功后，服务器会发送一个sessionid给用户，session是保存在服务端 的，服务器通过session辨别用户，然后做权限认证等。那如何才知道用户的session是哪个？这时候cookie就出场了，浏览器第一次与服务器建立连接的时候，服务器会生成一个sessionid返回浏览器，浏览器把这个sessionid存储到cookie当中，
SpringBoot集成JWT（极简版）
热门推荐
程序员青戈
09-30 1万+
话不多说，直接上代码。
springboot集成JWT
weixin_67958017的博客
02-02 4336
JWT是JSON Web Token的缩写，是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准((RFC 7519)。JWT本身没有定义任何技术实现，它只是定义了一种基于Token的会话管理的规则，涵盖Token需要包含的标准内容和Token的生成过程，特别适用于分布式站点的单点登录(SSO) 场景。JSON Web Token是目前最流行的跨域认证解决方案,，适合。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值