JWT使用详解

最新推荐文章于 2024-10-07 11:53:28 发布
最新推荐文章于 2024-10-07 11:53:28 发布
阅读量534 收藏 1
点赞数
分类专栏： spring boot Mybatis JWT 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45737165/article/details/126407174
版权
spring boot 同时被 3 个专栏收录
2 篇文章 0 订阅
订阅专栏
Mybatis
2 篇文章 0 订阅
订阅专栏
JWT
1 篇文章 0 订阅
订阅专栏

前言

Session认证

我们都知道，http协议本身是一种无状态的协议，而这就意味着如果用户向我们的应用提供了用户名和密码来进行用户认证，那么下一次请求时，用户还要再一次进行用户认证才行，因为根据http协议，我们并不能知道哪个用户发出的请求，所以为了让我们的应用程序能识别是哪个用户发出的请求，我们只能在服务器存储一份用户登陆的信息，这份登录信息会在响应式传递给浏览器，告诉其保存为cookie，以便下次请求是发送给我们的应用，这样我们的应用就能识别请求来自哪个用户了，这就是传统的基于session认证。

缺点：
扩展性：
Session的扩展性比较差，因为需要做多太机器数据共享
网络安全:
CSRF攻击：因为基于cookie来进行用户识别, cookie如果被截获，用户就会很容易受到跨站请求伪造的攻击。
跨平台：
在移动应用上 session 和 cookie 很难行通，你无法与移动终端共享服务器创建的 session 和 cookie。

JWT使用

首先加入maven依赖

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

后台生成token,我将这个封装成了三个方法，包括生成token，验证token，获取token中的信息，当然，第三个和第二个差不多可以只写第二个


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

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

/**
 * jwt封装
 *
 * */
public class JwtUtils {
    //创建一个常量作为签名
    private static final String SING = "ASID#2@$OSJ";
    //封装一个方法，参数为Map类型，传给payload
    public static String getToken(Map<String,String> map){
        Calendar instance = Calendar.getInstance(); //创建一个日期的对象
        instance.add(Calendar.DATE,7);  //设置过期时间为7天
        //创建jwt builder
        JWTCreator.Builder builder = JWT.create();
        //将map中的k,v传给payload
        map.forEach((k,v)->{
            builder.withClaim(k,v);
        });
        //withExpiresAt() 设置一个过期的时间，最后选择使用的算法进行加密，将签证丢进去
        String token = builder.withExpiresAt(instance.getTime()).sign(Algorithm.HMAC256(SING));
        //最后生成一个token，将token返回
        return token;
    }

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

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

JWT在Springboot中的使用

首先导入依赖,只是简单的用户验证最主要的还是理解token的使用

		<dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.2.2</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.75</version>
        </dependency>

创建一个数据库
在这里插入图片描述

对应的实体类

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private Integer id;
    private String username;
    private String password;
}

写一个简单的登录Mapper接口

import com.tjs.pojo.User;
import org.apache.ibatis.annotations.Mapper;

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

再写一个对应的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.tjs.mapper.UserMapper">
    <select id="login" parameterType="com.tjs.pojo.User" resultType="com.tjs.pojo.User">
        select * from user where username = #{username} and password = #{password}
    </select>
</mapper>

写一个service接口

import com.tjs.pojo.User;
import org.springframework.stereotype.Service;

@Service
public interface UserService {
    User login (User user);

}

写一个类来实现service

import com.tjs.mapper.UserMapper;
import com.tjs.pojo.User;
import com.tjs.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
@Transactional
public class UserServiceImpl implements UserService {
    @Autowired
    private UserMapper userMapper;
    @Override
    @Transactional(propagation = Propagation.SUPPORTS)
    public User login(User user) {
        User logins = userMapper.login(user);
        if (logins != null){
            return logins;
        }
        throw new RuntimeException("登录失败");
    }
}

写一个Controller


import com.auth0.jwt.interfaces.DecodedJWT;
import com.tjs.pojo.User;
import com.tjs.service.UserService;
import com.tjs.utils.JwtUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
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;
    @PostMapping("/user/login")
    public Map<String,Object> login(User user){
        log.info("用户名：[{}]",user.getUsername());
        log.info("密码：[{}]",user.getPassword());
        Map<String,Object> map = new HashMap();
        try {
            User login = userService.login(user);
            Map<String,String> payload = new HashMap<>();
            payload.put("userid","1");
            payload.put("username",user.getUsername());
            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;
    }
    //在放问接口之前会进入拦截器（InterceptorConfig），将token验证封装到拦截器中可以简化接口代码冗余问题
    @PostMapping("/test/token")
    public Map<String,Object> verifyToken(HttpServletRequest request){
        Map<String,Object> map = new HashMap<>();
        /**
         * 在处理业务逻辑的时候需要用到userId或者用户名，可以使用HttpServletRequest 下的request.getHeader的
         * 方法来获取token
         * 然后使用JWT的工具包中verify的方法进行验证
         * 验证之后的对象可以调用getClaim方法获取生成token时存入的用户信息
         *
         * */
        String token = request.getHeader("token");
        DecodedJWT verify = JwtUtils.verify(token);
        String username = verify.getClaim("username").asString();
        log.info("username:[{}]",username);
        map.put("state",true);
        map.put("msg","认证成功");
        return map;

    }
}

我将登陆时生成token，访问数据时验证token写到了拦截器中，这样可以大大简化接口方法里的代码冗余问题，当然一些分布式项目可以将验证写道网关里，而一些小的微服务可以直接封装到拦截器中。


import com.alibaba.fastjson.JSONObject;
import com.auth0.jwt.exceptions.AlgorithmMismatchException;
import com.auth0.jwt.exceptions.SignatureVerificationException;
import com.auth0.jwt.exceptions.TokenExpiredException;
import com.tjs.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 JwtInterceptor implements HandlerInterceptor {
    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 (AlgorithmMismatchException e){
            map.put("msg","token算法不一致");
        }catch (TokenExpiredException e){
            map.put("msg","token过期");
        }catch (SignatureVerificationException e){
            map.put("msg","签名无效");
        }catch (Exception e){
            map.put("msg","token无效");
        }
        map.put("state",false);
        /**这里我使用的是fastjson
         * 也可以直接使用jackson
         * String json = new ObjectMapper().writeValueAsString(map);
         *
         * */
        JSONObject json = new JSONObject(map); //将map转换成json
        response.setContentType("application/json;charset=UTF-8"); //指定json格式
        response.getWriter().println(json); //将json写入
        return false;
    }
}

然后可以创建一个config包，创建一个类实现WebMavConfigurer
重写addInterceptors(InterceptorRegistry registry)（添加一个拦截器）
使用@Configuration注解表明这是一个配置类


import com.tjs.interceptor.JwtInterceptor;
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 {
    //写一个拦截器，将token验证封装到拦截器中
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new JwtInterceptor())
                .excludePathPatterns("/user/**")   //放行接口地址，用户请求都放行
                .addPathPatterns("/test/**");       //拦截接口地址，其他接口受保护
    }
}

在application.yml中写入配置

server:
  port: 端口
spring:
  datasource:
    username: 你的数据库用户名
    password: 你的数据库密码
    url: jdbc:mysql://localhost:3306/jwt
    driver-class-name: com.mysql.cj.jdbc.Driver
mybatis:
  mapper-locations: classpath:mybatis/mapper/*.xml
  type-aliases-package: com.tjs.pojo

开始启动

启动之后访问对应的接口然后会返回一个token在这里插入图片描述
当访问数据接口的时候需要将token放到header中然后请求，这样就可以实现使用JWT单点登录了，这里的token我在JwtUtils工具包中设置的7天，也可以根据具体业务需求设置时长。
在这里插入图片描述

结语

今天的分享就到这儿了，希望各位小伙伴可以给点个赞哦，下次再见！

茶 夏
关注
专栏目录
SpringBoot集成JWT实现权限认证
Java碎碎念
11-04 829
点击上方“Java碎碎念”,关注公众号优质文章,第一时间送达本文目录 一、JWT认证流程二、SpringBoot整合JWT三、测试一、JWT认证流程 JWT认证流程认证流程如下：用户使用账号和密码发出post请求；服务器使用私钥创建一个jwt；服务器返回这个jwt给浏览器；浏览器将该jwt串在请求头中像服务器发送请求；服务器验证该jwt；返回响应的资源给浏览器。二、SpringBoot整合JWT ...
JWT详解
热门推荐
baobao的博客
07-07 27万+
本文从本人博客搬运，原文格式更加美观，可以移步原文阅读：JWT详解 JWT简介 1.什么是JWT 在介绍JWT之前，我们先来回顾一下利用token进行用户身份验证的流程： 客户端使用用户名和密码请求登录 服务端收到请求，验证用户名和密码 验证成功后，服务端会签发一个token，再把这个token返回给客户端 客户端收到token后可以把它存储起来，比如放到cookie中 客户端每次向服务端请求资源时需要携带服务端签发的token，可以在cookie或者header中携带 服务端收到请求，然后去验证客户端请
SpringBoot - 集成Auth0 JWT
Maggieq8324的博客
08-19 5093
目录前言 说说JWT，先说下互联网服务常见的两种用户认证方式：session认证与Token认证 session认证 传统的Session认证的大体流程可以表示为用户提供用户名和密码登录后由服务器存储一份用户登录信息并传递给浏览器保存为Cookie，并在下次请求中根据Cookie来识别用户，但这种方式缺陷明显： - Session都是保存在内存中，随着认证用户的增多，服务端的开销明显增大 - 保存在内存中的Session限制了分布式的应用 - Cookie容易被截获伪造
Java JWT实现与应用详解
最新发布
weixin_42593549的博客
10-07 1418
本文还有配套的精品资源，点击获取 简介：JWT是一种安全的、紧凑的、自包含的信息传输标准，适用于Java和Android的身份验证和授权。本文深入解析了JWT的组成部分，包括头部、负载和签名，并通过 jjwt 开源库展示如何在Java中创建、解析和验证JWT。重点介绍了JWT在Java和Android中的具体实现，以及开发者应如何利用这些技术构建安全的应用程序...
使用auth0.jwt创建和解析token，登录和请求验证处理
m0_73952463的博客
07-28 460
简单的创建和解析一个token
使用AuthJwt签名认证Jwt
city1993的博客
11-20 3069
jwt auth0 auth-jwt rsa hsa des https
jwt token使用autho0-jwt框架使用(二)
平凡之路无尽路的博客
09-10 4346
转载：http://www.leftso.com/blog/221.html 转在学习分享，还有其他不错博文，可供学习。 一、前言 Java编程中使用jwt,首先你必须了解jwt是什么，长什么样子。如果你不了解可以先去本站另外一篇博客什么是JWT？ 二、Java编程中jwt框架选择 在Java编程中,实现jwt标准的有很多框架，本博客采用的框架是auth0的java-jwt版本为3.2...
JWT简单使用
weixin_45794641的博客
11-05 3271
JWT简单使用 目录JWT简单使用一、概述1.JWT是什么2.JWT能做什么？3.为什么要使用JWT？二、JWT结构1.Header2.payLoad3.signature三、使用JWT1.JWT代码2.JWT的工具类封装3.SpringBoot整合JWT 一、概述 1.JWT是什么 ​ JWT全称是JSON Web Token，通过JSON形式作为Web应用中的令牌，用于在各方之间安全地将信息作为JSON对象传输，在数据传输过程中还可以完成数据加密、签名等相关处理。 2.JWT能做什么？ 授权 ​
Django Rest Framework JWT 使用详解与原理剖析
"本文主要讲解了Django Rest Framework中JWT（JSON Web Token）的使用方法，包括JWT的基本概念、组成部分以及在Django REST框架下的实际应用。" 在Django Rest Framework中，JWT常用于实现安全的身份验证和授权，...
基于JWT.NET的使用(详解)
08-28
"基于JWT.NET的使用详解" 1. 什么是JWT？ JWT全称是Json Web Token，是一种用于双方之间传递安全信息的简洁的、URL安全的表述性声明规范。JWT作为一个开放的标准（RFC 7519），定义了一种简洁的，自包含的方法用于...
thinkphp框架使用JWTtoken的方法详解
01-03
本文实例讲述了thinkphp框架使用JWTtoken的方法。分享给大家供大家参考，具体如下： 简介 一：JWT介绍：全称JSON Web Token，基于JSON的开放标准((RFC 7519) ，以token的方式代替传统的Cookie-Session模式，用于各...
Node express项目（1）JWT验证
qq_39404437的博客
03-28 1698
node项目+jwt
JWT身份验证原理简单讲解与nodejs简单实现
AKGWSB 's blog
08-14 9427
目录前言JWT简单介绍node中使用JWT安装jsonwebtoken包签发token验证token 前言 上一篇【基于token的持久化登录讲解及其实现】讲到token的机制，以及token的2大特性，即：只有服务器能够签发token，服务器可以验证token是否由自己签发。 可是上一篇博客编写的时候，对token的理解还不够深入，上一篇博客的token是最最最基本的token验证，而现在互联网应用的登录验证普遍使用JWT，即 JSON WEB TOKEN 的规范化验证，所以今天来学习一蛤，并且学习如何在
关于jwt令牌使用的详细总结
xuyi5566的博客
11-23 162
一：导入jwt工具类，该类的代码固定，可重复利用//加密和解密使用的key//接收业务数据,生成token并返回.withClaim("claims", claims)/*将自定义的有效信息加入*/.withExpiresAt(new Date(System.currentTimeMillis() + 1000 * 60 * 60 * 12))/*生成令牌的有效时间*//*加密的数学算法*///接收token,验证token,并返回业务数据.build().asMap();
Java实现Token登录验证(基于JWT的token认证实现)
shuux666的博客
03-12 2万+
文章目录 一、JWT是什么？ 二、使用步骤 1.项目结构 2.相关依赖 3.数据库 4.相关代码 三、测试结果 一、JWT是什么？ 在介绍JWT之前，我们先来回顾一下利用token进行用户身份验证的流程： 1、客户端使用用户名和密码请求登录 2、服务端收到请求，验证用户名和密码 3、验证成功后，服务端会签发一个token，再把这个token返回给客户端 4、客户端收到token后可以把它存储起来，比如放到cookie中 5、客户端每次向服务端请求资源时需要携带服务端签发的token，可以在co
JWT——token单点登录认证逻辑实现
qq_35071164的博客
01-28 2207
一、什么是单点登录 JSON WebToken JSON Web Token (JWT)是一个开放标准(RFC 7519)，它定义了一种紧凑的、自包含的方式，用于作为JSON对象在各方之间安全地传输信息。该信息可以被验证和信任，因为它是数字签名的。 1.1 什么时候你应该用JSON Web Token 下列场景中使用JSON Web Token是很有用的： Authorization (授权) : 这是使用JWT的最常见场景。一旦用户登录，后续每个请求都将包含JWT，允许用户访问该令牌允许的路由、.
JWT使用简介
少年小子的博客
02-01 5617
本文主要简单介绍了什么是JWT和在JavaEE环境下如何使用JWT，简述JWT技术能够为Web开发带来什么样的帮助。
使用JWT完成前后端请求发送的数据校验
qq_43647376的博客
08-17 1186
一切配置好后，使用postman发送请求。有此工具类就可调用接口生成token。在浏览器修改错误token同理。#### 配置请求头。
SpringBoot第一次使用auth0的JWT
世 间 尤 物，不 敢 妄 取
03-02 3948
依赖 <dependency> <groupId>com.auth0</groupId> <artifactId>java-jwt</artifactId> <version>3.4.0</version> </dependency> 工具类（含包） package ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值