Springboot集成JWT token实现权限验证

已于 2024-04-20 23:48:04 修改
阅读量1.6k 收藏 25
点赞数 20
文章标签： spring boot 后端 java jwt token
于 2024-04-14 20:32:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/abfwaaf/article/details/137728904
版权

1.后端 

1.1.导入依赖

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

1.2.编写jwt的拦截器

这个类实现一个HandlerInterceptor接口，这个类主要完成以下几个任务：

  • 从请求头里获取token，没有获取到就抛异常(注意：请求头里原本是没有token的，这个需要我们自己在前端添加一个token)
  • 解码token并从token里获取用户ID，没有获取到就抛异常，表明token里没有数据(注意：这个用户ID是自己在前端添加token时存储的)
  • 通过用户密码来生成一个验证器，解析token(JWT一般含有三个部分，头部，荷载，签名，解析过程中jwtVerifier会检验这三部分能不能正常分离，以及来用验证器来验证签名，以及检查token的过期时间)这一步也是最重要的一步！
package com.kuang.common;

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.JWTDecodeException;
import com.auth0.jwt.exceptions.JWTVerificationException;
import com.kuang.exception.ServiceException;
import com.kuang.mapper.UserMapper;
import com.kuang.pojo.User;
import io.micrometer.common.util.StringUtils;
import jakarta.annotation.Resource;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerInterceptor;

public class JwtInterceptor implements HandlerInterceptor {

    @Resource
    private UserMapper userMapper;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {


        //从请求头Header里接收传来的参数token
        String headerToken = request.getHeader("token");
        //如果传来的token为空，则从url参数中来接收传来的token
        if(StringUtils.isBlank(headerToken)){
            headerToken = request.getParameter("token");
            //如果url里的token为空，则抛异常
        }
        if (StringUtils.isBlank(headerToken)){
            throw new ServiceException("401","请登录");
        }

        //从token中获取userId
        //JWT.decode(headerToken) 解码JTW Token
        String userId;
        try {
            userId = JWT.decode(headerToken).getAudience().get(0);
        } catch (JWTDecodeException e) {
            throw new ServiceException("401","请登录");
        }
        //根据userId查询数据库
        //userId是String类型，这里要转换成int类型
        User user = userMapper.selectUserById(Integer.parseInt(userId));
        //user为空，则抛异常
        if (user == null){
            throw new ServiceException("401","请登录");
        }
        //通过用户密码加密之后生成一个验证器
        JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256(user.getPassword())).build();
        try {
            //验证token
            jwtVerifier.verify(headerToken);
        } catch (JWTVerificationException e) {
            throw new ServiceException("401","请登录");
        }
        return true;
    }
}

1.3.编写token的工具类

在这个类中有以下几点任务：

  • 生成token，并且将用户ID放在token的荷载(Payload)中当作受众声明(Audience)，以及设置token的过期时间，把用户密码当作密钥，然后给token加一个签名，只有添加了签名，这个token才能被使用，而我们设置的这个密钥就是来验证签名的钥匙
package com.kuang.utils;

import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import com.kuang.mapper.UserMapper;
import com.kuang.pojo.User;
import io.micrometer.common.util.StringUtils;
import jakarta.annotation.PostConstruct;
import jakarta.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
import java.util.Calendar;
import java.util.Date;

@Component
public class TokenUtils {

    private static UserMapper staticUserMapper;

    @Autowired
    UserMapper userMapper;

    @PostConstruct
    public void setUserService(){
        staticUserMapper = userMapper;
    }

    /**
     * 创建token
     * @param userId
     * @param sign
     * @return
     */
    public static String createToken(String userId,String sign){

        // 获取当前时间
        Date currentDate = new Date();

        // 创建Calendar实例
        Calendar calendar = Calendar.getInstance();

        // 设置Calendar的时间为currentDate
        calendar.setTime(currentDate);

        // 向前偏移两个小时
        calendar.add(Calendar.HOUR_OF_DAY, 2);

        // 获取偏移后的时间
        Date offsetDate = calendar.getTime();

        return JWT.create().withAudience(userId)//将userId保存到token里
                .withExpiresAt(offsetDate)      //2小时候token过期
                .sign(Algorithm.HMAC256(sign)); //将password作为token密钥

    }

    /**
     * 获取当前登录的用户信息
     * @return
     */
    public static User getCurrentUser(){

        //获取当前请求的HttpServletRequest对象，这样就能在下面访问请求头、参数等
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder
                .getRequestAttributes())
                .getRequest();

        try {
            //从请求头里获取token
            String token = request.getHeader("token");
            //如果token不为空，则从Audience中获取第一个数据(是用户的id)
            if (StringUtils.isNotBlank(token)){
                String userId = JWT.decode(token).getAudience().get(0);
                return staticUserMapper.selectUserById(Integer.parseInt(userId));
            }
        } catch (Exception e) {
            return null;
        }
        return null;
    }



}

 1.4.扩展springmvc的拦截器

这个类继承WebMvcConfigurationSupport类，主要任务有以下几点：

  • 将在第二步编写的jwt的拦截器注入到spring容器中，并将其添加到spring的拦截器中
  • 设置拦截路径

当用户访问下面设置好的拦截路径时，就会触发我们自己编写的jwt的拦截器，然后进入校验过程(就是第二步中的那一套流程)

package com.kuang.common;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;

@Configuration
public class InterceptorConfig extends WebMvcConfigurationSupport {
    @Override
    protected void addInterceptors(InterceptorRegistry registry) {
        //配置jwt的拦截器规则,拦截所以请求，除了/user/login,/user/register,/file/upload
        registry.addInterceptor(jwtInterceptor())
                .addPathPatterns("/**")
                .excludePathPatterns("/user/login","/user/register","/file/upload");
        super.addInterceptors(registry);
    }


    @Bean
    public JwtInterceptor jwtInterceptor(){
        return new JwtInterceptor();
    }
}

 1.5.将后端生成的token返回给前端

一般会在用户登录时，将token返回给前端，下面这个类就是实现登录功能的service层的实现类

service层： 

 @Override
    public User selectUserByUsername(User user) {

        User user1 = userMapper.selectUserByUsername(user);
        //生成token,userId用来放在token里，password用来生成token的验证器，来验证token
        String token = TokenUtils.createToken(String.valueOf(user1.getId()), user1.getPassword());
        user1.setToken(token);
        return user1;
    }

controller层： 

    //登陆功能
    @PostMapping("/login")
    public Result login(@RequestBody User user, HttpServletRequest request){
        User user1 = userService.selectUserByUsername(user);

        if (!user.getPassword().equals(user1.getPassword())){
            return Result.error("用户名或密码不正确");
        }
        //将id存入session
        //request.getSession().setAttribute("userId",user1.getId());

        //将含有token的user对象返回给前端
        return Result.success(user1);
    }

2.前端

2.1.导入request.js文件 

这里添加一个通用的request.js文件，这个文件用于以下几点：

  • 可以在请求发送前对请求做一些处理
  • 可以在接口响应后统一处理结果
  • 对请求路径前面的http：localhost做了封装，以便不用每次都写上
  • 对返回的数据做了封装，原本要访问后端返回的数据要这样写res.data.data，封装了之后可以简化为res.data

import axios from 'axios'
import router from "@/router";

const request = axios.create({
    baseURL: 'http://localhost:8082',  // 注意！！ 这里是全局统一加上了 '/api' 前缀，也就是说所有接口都会加上'/api'前缀在，页面里面写接口的时候就不要加 '/api'了，否则会出现2个'/api'，类似 '/api/api/user'这样的报错，切记！！！
    timeout: 5000
})

// request 拦截器
// 可以自请求发送前对请求做一些处理
// 比如统一加token，对请求参数统一加密
request.interceptors.request.use(config => {
    config.headers['Content-Type'] = 'application/json;charset=utf-8';
    //在请求头里添加一个token
    let user = JSON.parse(localStorage.getItem("user") || '{}')
    config.headers['token'] = user.token;  // 设置请求头
    return config
}, error => {
    return Promise.reject(error)
});

// response 拦截器
// 可以在接口响应后统一处理结果
request.interceptors.response.use(
    response => {
        let res = response.data;
        // 如果是返回的文件
        if (response.config.responseType === 'blob') {
            return res
        }
        // 兼容服务端返回的字符串数据
        if (typeof res === 'string') {
            res = res ? JSON.parse(res) : res
        }
        if (res.code === '401'){
            router.push('/login')
        }
        return res;
    },
    error => {
        console.log('err' + error) // for debug
        return Promise.reject(error)
    }
)


export default request

在上面的文件里，我们着重看这几行代码，在前端发送请求时，在请求头里添加一个token，并且从localStorage中获取在登录时存储的用户信息，用来存储在token中，具体程序如下：

在接口响应后，统一处理结果中的如下程序，如果用户没有token，后端就会返回401的错误，在这里就会处理401错误，进行页面跳转

导入这个文件之后，我们可以在main.js文件中注册这个文件的全局对象

2.2.采用request.js文件里提供的请求方式

 这里只提供一个例子，其他的地方都是一样的

3.流程图分析

下面的流程图涉及了后端以下几个类：

  • JwtInterceptor：1.2中的jwt的拦截器
  • TokenUtils：1.3中的token的工具类
  • InterceptorConfig：1.4中的springmvc的扩展类
  • LoginController：处理用户登录的controller方法，这个方法用来返回给前端token
  • selectUserController：在登录之后，处理前端发过来的查询用户的请求

解释上面的过程，用户在登陆之前还没有token，登录之后，通过调用TokenUtils来生成token，并且返回给前端，至此，该用户就有了token，在之后的请求中首先会被Interceptor-Config类拦截下来，然后进入JwtInterceptor类进行token的校验，成功后才会进入controller层，否则就会抛出401的异常(这里的异常是自己手动设置的)，然后就会返回给前端，前端就会发生页面跳转，跳转到login页面

两仪式quq
关注
【SpringBoot】44、SpringBoot中整合JWT实现Token验证（整合篇）
Asurplus
02-28 21万+
什么是JWT？ Json web token (JWT)，是为了在网络应用环境间传递声明而执行的一种基于 JSON 的开放标准（(RFC 7519)，该 token 被设计为紧凑且安全的，特别适用于分布式站点的单点登录（SSO）场景。JWT 的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服务器获取资源，也可以增加一些额外的其它业务逻辑所必须的声明信息，该token也可直接被用于认证，也可被加密。 为什么需要JWT? 当我们开发前后端分离项目时，要求我们对用户会话状态要进行一
SpringBoot继承JWT token实现权限的验证（从头开始）
aabbbccc6788123的博客
05-27 2648
在开发后端接口时，数据的直接暴露可能会导致安全问题。为了应对这种情况，我们需要在访问接口时进行拦截验证，以确保只有经过身份验证的用户才能访问数据。为实现这一目的，我们需要编写一个拦截器，用于检查每次请求中是否携带有效的token（即身份验证令牌）。只有当用户携带有效token时，才能进行数据访问操作；否则，将对请求进行拦截并禁止访问敏感数据。通过编写拦截器实现身份验证，我们能够提高系统的安全性并保护数据免受未经授权的访问。这种做法有助于规避潜在的安全风险，有效保障系统的信息安全。
SpringBoot实战：Spring Boot接入Security权限认证服务
weixin_40845163的博客
09-15 371
引言 Spring Security是一个功能强大且高度可定制的身份验证和访问控制的框架，提供了完善的认证机制和方法级的授权功能，是一个非常优秀的权限管理框架。其核心是一组过滤器链，不同的功能经由不同的过滤器。本文将通过一个案例将Spring Security整合到SpringBoot中，要实现的功能就是在认证服务器上登录，然后获取Token，再访问资源服务器中的资源。 一、基本介绍 登...
springboot 集成jwt 加密token
qq_39044972的博客
06-09 194
springboot 集成jwt 加密token
【JavaWeb】SpringBoot整合JWT认证机制实现接口鉴权
最新发布
精益求精
10-14 756
最开始 我们登陆的时候，是将 对象存到session当中，每次请求的时候，取session中是否存在该对象进而判断是否通过认证。 然后是 token+redis 的方式，将seesionID 作为 token，存储到redis中（token:user），并设置过期时间，同时将 token 通过响应传回给 浏览器，存储到 localstory，每次请求的时候把token放到请求的header中，查询redis一致的话，通过认证。 jwt使用 hamc算法，或使用rsa公钥进行签名
Springboot整合JWT实现权限校验
qq_40694396的博客
09-05 1162
springboot整合jwt实现权限验证
深入解析Spring Boot中的JWT令牌校验：安全身份验证与授权实践
良月柒
04-30 1621
JWT是一种基于JSON的开放标准（RFC 7519），用于在用户和服务器之间安全地传输信息。它由三部分组成：头部（Header）、载荷（Payload）和签名（Signature）。头部通常包含令牌的类型（JWT）和使用的加密算法，载荷包含要传输的信息（如用户ID、角色等），签名用于验证令牌的真实性。通过本文的介绍，我们深入了解了Spring Boot中JWT令牌校验的实现方法及其相关的技术细节。JWT令牌是一种安全传输信息的开放标准，通过在用户和服务器之间传递被声明的对象来安全地传输信息。
SpringBoot Vue使用Jwt实现简单的权限管理
qq_634380940的博客
07-26 535
SpringBoot Vue使用Jwt实现简单的权限管理
SpringBoot集成JWT实现权限认证
flyingdream123的专栏
05-11 974
一、JWT认证流程 二、SpringBoot整合JWT 三、测试 一、JWT认证流程 认证流程如下： 用户使用账号和密码发出post请求； 服务器使用私钥创建一个jwt； 服务器返回这个jwt给浏览器； 浏览器将该jwt串在请求头中像服务器发送请求； 服务器验证该jwt； 返回响应的资源给浏览器。 二、SpringBoot整合JWT 新建一个spring boot项目spring-boot-jwt，按照下面步骤操作。 pom.x
SpringBoot整合JWT实现token验证
藤井大叔的博客
08-09 1580
JWT介绍什么是JWTJWT的应用场景JWT结构头有效载荷签名工作原理JWT使用引入依赖生成tokentoken验证封装工具类 介绍 jwt官网:https://jwt.io/ 什么是JWT 如上是官网的介绍，这里我说一下大概的意思 JWT，拆分来理解就是JSON Web Token的意思，是一种开放标准。 它定义了一种紧凑并、包含的方式。 以JSON格式的形式在各方面安全的传输信息 因为它由数字签名，所以可以对其进行验证与信任 jwt可以使用秘密(使用HMAC算法)签名，也可以使用RSA或ECDSA
springboot通过jwt实现token验证
m0_50207524的博客
08-25 817
throw new ServiceException("请登录", "401");import com/*** @date 2024年07月28日 22:13} }/*** @date 2024年07月28日 22:13} }/*** @date 2024年07月28日 22:13} }R;import org/*** @date 2024年07月28日 22:13} }/**
基于springBoot+springSecurity+jwt实现前后端分离用户权限认证
12-09
主要基于前后端分离情况下用户权限认证, 当用户登录认证成功后，每个用户会获取到自己的token，在请求其他接口时只需携带token即可,后端会通过token来识别用户身份。springSecurity也有很多种权限认证方式，本项目主要实现基于接口授权，也就是说通过注解给controller赋予权限，用户只有拥有某个接口的权限才能成功访问这个接口，从而实现不同用户拥有不同访问权限;
SpringBoot集成JWT实现token验证-源码
10-02
总结来说，Spring Boot集成JWT实现token验证的过程包括引入依赖、配置Spring Security、创建自定义过滤器以及编写Token生成和验证逻辑。这种方式不仅提高了安全性，还减少了服务器的负担，因为不再需要管理用户的...
springboot集成jwt
01-25
**SpringBoot集成JWT详解** SpringBoot是一个轻量级的Java框架，它简化了Spring应用程序的创建和部署。JWT（Json Web Token）则是一种用于在各方之间安全地传输信息的开放标准，广泛应用于身份验证和授权场景。在...
Springboot + JWT 的 Token 登录验证
伏颜的博客
07-14 909
学习自博客：lukeewin
Spring-Boot实现jwt加密
zhzxd的博客
06-08 727
1、减轻服务端压力。2、查询效率比token高。3、不容易被客户端篡改数据。1、如果一旦生成好一个jwt之后，后期是否可以销毁2、Jwt playload数据多，占据服务器端带宽资源jwt不是很安全，playload中不能存放敏感的信息，必要须加密。
JWT 使用 授权 认证
weixin_51689532的博客
09-11 620
JWT 使用 授权 认证
spring boot + jwt加密
qq_33842795的博客
12-24 256
maven <dependency> <groupId>cn.hutool</groupId> <artifactId>hutool-all</artifactId> <version>4.6.1</version> </dependency> <dependency&gt...
springboot shiro jwt实现认证和授权
myli92的博客
03-16 2596
1.shiro，jwt，oauth2.0是什么？ Shiro：权限框架，可在C/S下运行。 shiro是一套权限管理框架，包括认证、授权等，在使用时直接写相应的接口（小而简单的Shiro就足够） jwt：是一个鉴权生成加密token的一个名称。 oauth2.0 :一种权限实现标准，是一种安全的授权框架，提供了一套详细的授权机制。用户或应用可以通过公开的或私有的设置，使用第三方认证和授权。 Shiro 有三大核心组件，即 Subject、SecurityManager 和 Realm。 2.依赖引
jwt实现token登录验证
04-28
JWT（JSON Web Token）是一种基于 JSON 的开放标准（RFC 7519），用于在各方之间安全地将声明作为 JSON 对象传输。JWT通常用于身份验证和授权。JWT由三部分组成：头部、载荷和签名。 在使用 JWT 进行身份验证时，服务器会在用户登录成功后生成一个 JWT，并将其发送给客户端。客户端将 JWT 存储在本地，每次向服务器发送请求时，都需要在请求头中携带该 JWT。服务器在接收到请求后，会验证该 JWT 的有效性，并根据 JWT 中的信息进行相应的处理。 JWT 的优点是可以减轻服务器的压力，因为服务器不需要在每次请求时都去查询数据库进行身份验证。同时，由于 JWT 中已经包含了足够的信息，服务器可以快速地进行权限验证和授权。 如果要实现 JWT 的登录验证，可以按照以下步骤进行： 1. 用户在登录成功后，服务器生成一个 JWT，并将其发送给客户端。 2. 客户端将 JWT 存储在本地，例如在 LocalStorage 或者 Cookie 中。 3. 客户端在向服务器发送请求时，需要在请求头中携带该 JWT。 4. 服务器在接收到请求后，需要验证该 JWT 的有效性。服务器可以根据 JWT 的头部信息，结合自己的密钥对 JWT 进行解密，验证 JWT 的签名是否正确。 5. 如果 JWT 验证通过，则说明当前用户已经登录。服务器可以根据 JWT 中的信息，进行相应的权限验证和授权。 需要注意的是，JWT 中的信息是可以被解密的，因此在 JWT 中不应该存储敏感信息，例如用户的密码等。如果需要存储敏感信息，可以考虑使用加密算法对其进行加密。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值