JWT 1 （基本认识、与springboot整合）

最新推荐文章于 2024-07-14 17:37:12 发布
最新推荐文章于 2024-07-14 17:37:12 发布
阅读量379 收藏
点赞数 1
分类专栏： java系列 文章标签： jwt spring mybatis java
@BeanInJ
本文链接：https://blog.csdn.net/a__int__/article/details/113125525
版权

文章目录

1、基本认识

jwt ： JSON Web Token， json形式的web令牌 。常用于前后端分离项目的安全验证。

jwt应用场景：
1、一次性验证：比如邮箱注册，返回给你的连接可能就是jwt
2、restful api 的无状态认证，可以代替session

jwt的token由三部分构成，将这三段信息文本用.链接一起就构成了Jwt字符串。
如下例：

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ

这三部分分别叫做：header、playload、signature

  • header ： 声明类型、加密算法
  • playload ：存放有效信息，如签发者、用户、签发时间等
  • signature ： 由前两部分组合然后加盐加密构成

2、生成token、解析

1、依赖

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

2、生成token

        Calendar instance = Calendar.getInstance();
        instance.add(Calendar.SECOND,200);                  // 200秒

        String token = JWT.create()
                .withClaim("userid", 12)                   // payload
                .withClaim("username", "zhang")
                .withExpiresAt(instance.getTime())         // 设置过期时间，200秒
                .sign(Algorithm.HMAC256("123ABCD!"));      // 密钥

        System.out.println(token);

如上代码输出内容

eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2MTE2Mjc0ODksInVzZXJpZCI6MTIsInVzZXJuYW1lIjoiemhhbmcifQ.JeEaSypQrT0Dxtix4ljS1LSvjdYoF8Q0zZ9_y3yajBA

3、根据令牌和签名解析数据

        // 创建验证对象
        JWTVerifier jwt_v = JWT.require(Algorithm.HMAC256("123ABCD!")).build();
        // 根据密钥获取 存有token数据的对象
        DecodedJWT verify = jwt_v.verify("eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2MTE2Mjc0ODksInVzZXJpZCI6MTIsInVzZXJuYW1lIjoiemhhbmcifQ.JeEaSypQrT0Dxtix4ljS1LSvjdYoF8Q0zZ9_y3yajBA");

		// 打印数据
        System.out.println(verify.getClaim("userid").asInt());
        System.out.println(verify.getClaim("username").asString());
        // 打印过期时间
        System.out.println(verify.getExpiresAt());

执行 根据令牌和签名解析数据 时如果出现以下内容表示令牌过期了
在这里插入图片描述
下面是各种异常对应的解释
在这里插入图片描述

3、与spring boot整合使用

3.1、准备使用场景（创建项目）

创建一个springboot项目
下面是要用到的依赖

	    <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.2</version>
        </dependency>
        <!--druid-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.19</version>
        </dependency>
        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--lombok-->
         <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>RELEASE</version>
            <scope>compile</scope>
        </dependency>

配置文件 application.properties

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?characterEncoding=UTF-8
spring.datasource.password=root
spring.datasource.username=root

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

logging.level.com.beaninj.dao=debug

新建数据库jwt、表user

CREATE DATABASE jwt
use jwt

DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
  `id` int NOT NULL,
  `name` varchar(255) DEFAULT NULL,
  `pwd` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;

INSERT INTO `user` VALUES ('1', 'zhang', '123');

在这里插入图片描述

下面是接下来要新建的内容的目录结构
在这里插入图片描述

新建实体类User.java

import lombok.Data;
import lombok.experimental.Accessors;

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

新建UserDao.java

import com.beaninj.springboot_jwt.entity.User;
import org.apache.ibatis.annotations.Mapper;

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

新建mapper.xml

<?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.beaninj.springboot_jwt.dao.UserDao">
    <select id="login" parameterType="com.beaninj.springboot_jwt.entity.User" resultType="com.beaninj.springboot_jwt.entity.User">
        select * from user where name=#{name} and pwd=#{pwd}
    </select>
</mapper>

新建UserService.java

import com.beaninj.springboot_jwt.entity.User;

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

新建UserServiceImpl.java

import com.beaninj.springboot_jwt.dao.UserDao;
import com.beaninj.springboot_jwt.entity.User;
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
@Transactional
public class UserServiceImpl implements UserService{
    @Autowired
    private UserDao userDao;

    @Override
    @Transactional(propagation = Propagation.SUPPORTS)
    public User login(User user) {
        User user1 = userDao.login(user);
        if(user1!=null) return user1;
        throw new RuntimeException("登录失败");
    }
}

新建UserController.java

import com.beaninj.springboot_jwt.entity.User;
import com.beaninj.springboot_jwt.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

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

@RestController
@Slf4j
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 user1 = userService.login(user);
            map.put("state","true");
            map.put("msg","认证成功");
        } catch (Exception e) {
            map.put("state","false");
            map.put("msg",e.getMessage());
        }
        return map;

    }
}

运行、测试http://localhost:8080/login?name=zhang&pwd=123
在这里插入图片描述

3.2、引入jwt

第一步：加入jwt对应依赖，及其他可能用到的依赖

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

第二步：封装一个jwt的token生成、验证的工具类。
新建工具类JWTUtils.java

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 {
    // 生成环境下这个SING是非常严格的，要保密，不能让别人知道
    private static final String SING = "xu!It'sASecret";

    /*
     * 生成token
     * @返回值 token
     **/
    public static String getToken(Map<String, String> map) {

        Calendar instance = Calendar.getInstance();
        instance.add(Calendar.DATE, 7);                  // 过期时间7天

        // 创建builder
        JWTCreator.Builder builder = JWT.create();
        // 将数据遍历放进去      下面那个代码也可以写成这个样 map.forEach((k,v)->{builder.withClaim(k,v);});
        map.forEach(builder::withClaim);
        // 设置过期时间7天
        builder.withExpiresAt(instance.getTime());
        // 设置密钥,并返回
        return builder.sign(Algorithm.HMAC256(SING));
    }

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

    /*
     * 获取token信息
     **/
    public static DecodedJWT getTokenInfo(String token) {
        return JWT.require(Algorithm.HMAC256(SING)).build().verify(token);
    }
}

接下来在controller里面使用这个工具类
生成token方法的使用

在这里插入图片描述
验证token
在这里插入图片描述
UserController.java到目前完整代码

import com.auth0.jwt.interfaces.DecodedJWT;
import com.beaninj.springboot_jwt.entity.User;
import com.beaninj.springboot_jwt.service.UserService;
import com.beaninj.springboot_jwt.util.JWTUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

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

@RestController
@Slf4j
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 user1 = userService.login(user);
            Map<String,String> payload = new HashMap<>();
            payload.put("id",user1.getId()+"");
            payload.put("name",user1.getName());
            String token = JWTUtils.getToken(payload);

            map.put("state","true");
            map.put("msg","认证成功");
            map.put("token",token);
        } catch (Exception e) {
            map.put("state","false");
            map.put("msg",e.getMessage());
        }
        return map;
    }

    @PostMapping("test")
    public Map<String,Object> tset(String token){
        Map<String,Object> map=new HashMap<>();

        log.info("当前token为：[{}]",token);
        try {
            DecodedJWT tokenInfo = JWTUtils.getTokenInfo(token);
            map.put("state","true");
            map.put("msg","请求成功");
            return map;
        } catch (Exception e) {
            // 这里面抛出与JWT相关的异常有：令牌过期、签名不一致、算法不匹配、token无效等
            e.printStackTrace();
        }
        map.put("state","false");
        map.put("msg","认证失败");
        return map;
    }
}

运行项目，测试
先生成token
在这里插入图片描述
再验证token

在这里插入图片描述

3.3、利拦截器方式结合jwt

到目前为止，我们发现如果每个接口都去添加jwt相关验证代码，会很冗余，于是我们用拦截器的方式进行jwt验证。

新建接口包、类JWTInterceptors.java

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

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

/*
 * jwt拦截器
 * 实现spring提供的拦截器接口
 **/
public class JWTInterceptors implements HandlerInterceptor {
    // 实现preHandle方法（预先拦截方法）
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 直接在http请求头中拿token
        String token = request.getHeader("token");
        // 用来传递 请求后 返回的消息
        Map<String,Object> map=new HashMap<>();
        // 验证令牌
        try {
            JWTUtils.getTokenInfo(token);
            return true;
        }catch (SignatureVerificationException e) {
            map.put("msg","签名无效");
        }catch (TokenExpiredException e) {
            map.put("msg","token过期");
        } catch (AlgorithmMismatchException e) {
            map.put("msg","token算法不一致");
        }catch (Exception e) {
            e.printStackTrace();
            map.put("msg","其他异常");
        }
        map.put("state","false");
        // 将map转为json
        String json = new ObjectMapper().writeValueAsString(map);
        // 给前端响应转为json后的map
        response.setContentType("application/json;charset=UTF-8");
        response.getWriter().println(json);
        return false;
    }
}

新建一个InterceptorConfig.java (用来将拦截器配置进spring)

import com.beaninj.springboot_jwt.interceptors.JWTInterceptors;
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 JWTInterceptors())
                .addPathPatterns("/**")                        // 拦截所有路径
                .excludePathPatterns("/user/**");              // 排除拦截user下面的路径
    }
}

UserController里面就不用验证token了
下面是修改后的代码

import com.auth0.jwt.interfaces.DecodedJWT;
import com.beaninj.springboot_jwt.entity.User;
import com.beaninj.springboot_jwt.service.UserService;
import com.beaninj.springboot_jwt.util.JWTUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

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

@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("密码：[{}]",user.getPwd());

        Map<String,Object> map=new HashMap<>();
        try {
            User user1 = userService.login(user);
            Map<String,String> payload = new HashMap<>();
            payload.put("id",user1.getId()+"");
            payload.put("name",user1.getName());
            String token = JWTUtils.getToken(payload);

            map.put("state","true");
            map.put("msg","认证成功");
            map.put("token",token);
        } catch (Exception e) {
            map.put("state","false");
            map.put("msg",e.getMessage());
        }
        return map;
    }

    @PostMapping("test")
    public Map<String,Object> tset(){
        // 这里面就不用验证token了，因为拦截器已经在这之前已经处理了
        Map<String,Object> map=new HashMap<>();
        map.put("state","true");
        map.put("msg","请求成功");
        return map;
    }
    @PostMapping("test1")
    public Map<String,Object> tset1(HttpServletRequest request){
        // 如果需要获取token里面的信息，这里也可以拿到
        String token = request.getHeader("token");
        DecodedJWT tokenInfo = JWTUtils.getTokenInfo(token);
        System.out.println(tokenInfo.getClaim("id").asString());
        System.out.println(tokenInfo.getClaim("name").asString());

        Map<String,Object> map=new HashMap<>();
        map.put("state","true");
        map.put("msg","请求成功");
        return map;
    }
}
BeanInJ
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot JWT
fantasyfzg的博客
11-30 183
token
SpringBoot整合Shiro+JWT
05-15
在本文中，我们将深入探讨如何将SpringBoot与Apache Shiro及JSON Web Tokens（JWT）进行集成，以构建一个安全的用户认证系统。首先，我们来理解这三个关键组件： 1. **SpringBoot**：SpringBoot是Spring框架的一个...
springboot-JWT
FA的博客
07-23 103
JWT原理 单点登录
Springboot与JWT
最新发布
游王子的博客
07-14 1075
JWT简称JSON Web Token，也就是通过JSON形式作为Web应用中的令牌，用于在各方之间安全地将信息作为JSON对象传输。在数据传输过程中还可以完成数据加密、签名等相关处理。
Springboot：JWT
沉迷写代码的程序猿的博客
03-22 4071
文章目录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
JWT学习&JWT和SpringBoot的整合
热门推荐
m0_51340928的博客
10-08 1万+
一篇文章教你学会JWT，JJwt，以及和SpringBoot的整合
SpringBoot中使用JWT
cxzhq2002的杂记
11-04 1656
JWT是什么我就不说了，这里只说名SpringBoot中怎么用。 首先在pom中天际依赖 1 <dependency> 2 <groupId>org.bitbucket.b_c</groupId> 3 <artifactId>jose4j</artifactId> 4 <version>0.6.5</version> 5 </dependency> 这里我用
Springboot整合JWT,Swagger.zip
07-12
SpringBoot整合JWT与Swagger是现代Web开发中两个重要的技术组件，它们可以极大地提升应用程序的效率和易用性。JWT（Json Web Token）用于安全地在客户端和服务器之间传输信息，而Swagger则是用于构建RESTful API的...
springboot整合JWT
11-26
SpringBoot整合JWT...以上就是SpringBoot整合JWT的基本流程。理解并实施这些步骤将帮助你构建一个安全、高效的身份验证系统，保护你的Web应用免受未授权访问。同时，注意定期更新JWT库和依赖，以保持系统的安全性。
springboot整合security与jwt
08-05
这篇内容将详细介绍如何在SpringBoot 2.0项目中整合Spring Security和JWT，并利用Redis作为Token的存储，同时引入Swagger-UI以提供API的文档和测试功能。 首先，我们需要在SpringBoot项目中添加相关的依赖。在`pom....
SpringBoot整合JWT
10-09
下面我们将详细解说 JWT 的组成、使用方法以及与 SpringBoot 的整合。 一、JWT 介绍 JWT 是一种基于 JSON 的令牌，用于认证和授权。JWT 由三部分组成：头信息（header）、消息体（payload）和签名（signature）。 ...
SPRINGBOOT+JWT
07-16
最新springboot+jwt校验案例，完整代码，下载即用，最新springboot+jwt校验案例，完整代码，下载即用，
springboot实现JWT
weixin_41849346的博客
09-08 275
pom.xml <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <!-- JWT依赖 -->
Spring Boot + jwt
weixin_63831348的博客
06-20 1979
Spring Boot + jwt
springboot+jwt
while(life)++；
05-06 369
流程： 1.用户访问login接口，验证用户身份信息，并生成token绑定用户信息，token返回前端 2.前端把token存入request header中访问后端接口即可成功，否则提示无权访问 代码部分： 1.JwtUtil类 （生成token，校验token等） /* * * @Author qy * <p> JWT工具类 </p> * @Param * @Return */ public class JwtUtil { // Token过期时间30分钟
springboot集成JWT
weixin_67958017的博客
02-02 4191
JWT是JSON Web Token的缩写，是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准((RFC 7519)。JWT本身没有定义任何技术实现，它只是定义了一种基于Token的会话管理的规则，涵盖Token需要包含的标准内容和Token的生成过程，特别适用于分布式站点的单点登录(SSO) 场景。JSON Web Token是目前最流行的跨域认证解决方案,，适合。
SpringBoot集成Jwt
Xu_Ren的博客
05-07 252
JWT 简介 Json Web Token（JWT），是为了在网络应用环境之间传递声明而执行的一种基于JSON的开放标准（RFC7519），该 token 被设计为紧凑且安全的，特别适用于分布式站点的单点登录（SSO）场景。JWT的声明一般被用来在身份提供者和服务提供者之间传递被认证的用户身份信息，以便于从资源服务器获取资源，也可以增加一些额外的其他业务逻辑所必须声明信息，该token也可以直接被...
Spring Boot 实现 JWT
云胡
06-21 7682
Web 网站离不开用户认证，这边我们不用 ，而直接使用 。JWT 的背景知识可以看阮一峰老师的这篇文章: JSON Web Token 入门教程JWT 由三个部分组成：在 中添加 配置信息。 2.2 新建 JwtUtil 工具类 新建 目录，在 目录下新建 。将当前 注入到 容器中。，匹配 配置文件的前缀，然后将配置文件里面的数据加载到当前类。 2.3 用户登录创建 token 2.3 拦截器验证 token 如何自定义拦截器可以看我的这篇: Spring Boot 2 配置登录拦截。 三、参考资料
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值