SpringBoot集成JWT token实现权限验证

最新推荐文章于 2024-01-17 10:51:38 发布
最新推荐文章于 2024-01-17 10:51:38 发布
阅读量987 收藏 2
点赞数 1
文章标签： spring boot java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63077733/article/details/132606981
版权

JWT=JSON Web Token

1. JWT的组成

JWT==Header,Payload,Signature==>abc.def.xyz

地址：JSON Web Tokens - jwt.er

1.1 Header

Header:标头。

两个组成部分：令牌的类型（JWT）和所使用的签名算法，经过Base64 Url编码后形成的JWT的第一部分。

{
    "type":"JWT",
    "alg":"HS256"
}

1.2 Payload

Payload---有效负载。存放用户自定义消息

注意点：是以明文的形式进行展示，以Base64进行编码。

{
    “sub":"123",
    "name":"jon",
    "admin":true
}

1.3 Signature

signature--签名。使用标头的算法和私钥对第一部分和第二部分进行加密，通过Base64 Url编码后形成JWT的第三部分。

var encodeString =base64UrlEncode(header)+"."+base64UrlEncode(payload);
var signature=HMACSHA356(encodeString,secret);

2.JWT的基本使用

1.导入pom JWT依赖

JDK1.8以下的加入JWT依赖即可

        <!--JWT-->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.1</version>
        </dependency>

JDK1.8以上的加上其他

        <!--JWT-->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.1</version>
        </dependency>
        <dependency>
            <groupId>javax.xml.bind</groupId>
            <artifactId>jaxb-api</artifactId>
            <version>2.3.0</version>
        </dependency>
        <dependency>
            <groupId>com.sun.xml.bind</groupId>
            <artifactId>jaxb-impl</artifactId>
            <version>2.3.0</version>
        </dependency>
        <dependency>
            <groupId>com.sun.xml.bind</groupId>
            <artifactId>jaxb-core</artifactId>
            <version>2.3.0</version>
        </dependency>

2.创建JWT

    //毫秒
    private long time=1000*60*60*24;
    //签名
    private String signature="admin";

    /*JWT加密*/
    @Test
    public void jwt(){
        //构建JWT对象:Jwts.builder()
        JwtBuilder jwtBuilder = Jwts.builder();
        String jwtToken = jwtBuilder
                //header：头部
                .setHeaderParam("typ", "JWT")
                .setHeaderParam("alg", "HS256")
                //payload：载荷
                .claim("username", "tom")
                .claim("role", "admin")
                .setSubject("admin-test")
                //有效时间===>一天=当前时间+24小时
                //获得当前的系统时间：System.currentTimeMillis()
                .setExpiration(new Date(System.currentTimeMillis() + time))
                //设置id字段
                .setId(UUID.randomUUID().toString())
                //signature：签名
                //注意点：这个签名算法要与前面的算法一致
                //设置加密算法和签名
                .signWith(SignatureAlgorithm.HS256, signature)
                //将前面3个重要信息拼接起来，使用”."来连接
                .compact();
        System.out.println(jwtToken);
    }

3.验证JWT

    @Test
    /*验证JWT*/
    public void checkJwt(){
        String token = "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VybmFtZSI6InRvbSIsInJvbGUiOiJhZG1pbiIsInN1YiI6ImFkbWluLXRlc3QiLCJleHAiOjE2OTM2MzgzMDMsImp0aSI6ImU5ZjY3ZjBhLWE0NTAtNGYzYy1hYTY3LTU3ZGMwOWRjMDM4ZCJ9.FxA5c91E2bk2KW1rdMo8jlmClXgn7r2mVSaXs19Qzzk";
        //Jwts.parser()：解析
        JwtParser jwtParser = Jwts.parser();
        //验证该token是否符合JWT规则
        boolean result = Jwts.parser().isSigned(token);
        System.out.println(result);//true
    }

4.解析JWT

    @Test
    /*解析JWT*/
    public void parseJwt(){
        String token = "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VybmFtZSI6InRvbSIsInJvbGUiOiJhZG1pbiIsInN1YiI6ImFkbWluLXRlc3QiLCJleHAiOjE2OTM2MzgzMDMsImp0aSI6ImU5ZjY3ZjBhLWE0NTAtNGYzYy1hYTY3LTU3ZGMwOWRjMDM4ZCJ9.FxA5c91E2bk2KW1rdMo8jlmClXgn7r2mVSaXs19Qzzk";
        //获取JWT的解析对象
        JwtParser jwtParser = Jwts.parser();
        //通过signature对token进行签名，解开
        //parseClaimsJws：将JWT转换为key-value的形式，通过key来获取对应的value
        //Jws<Claims>：类似于Map集合
        Jws<Claims> claimsJws = jwtParser.setSigningKey(signature).parseClaimsJws(token);
        //获取Jws对象中的数据:get(key)表示根据key来获取value
        //相当于将header和payload封装为一个claims
        Claims claims = claimsJws.getBody();//存储的是用户保存的数据
        Object username = claims.get("username");
        System.out.println(username);
        Object role = claims.get("role");
        System.out.println(role);
        String id = claims.getId();
        System.out.println(id);
        //签名
        String subject = claims.getSubject();
        System.out.println(subject);
        //有效期
        Date time = claims.getExpiration();
        System.out.println(time);
    }

3.SpringBoot + vue +JWT

 1.导入pom JWT依赖

JDK1.8以下的加入JWT依赖即可

        <!--JWT-->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.1</version>
        </dependency>

JDK1.8以上的还要加上以下依赖

        <!--JWT-->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.1</version>
        </dependency>
        <dependency>
            <groupId>javax.xml.bind</groupId>
            <artifactId>jaxb-api</artifactId>
            <version>2.3.0</version>
        </dependency>
        <dependency>
            <groupId>com.sun.xml.bind</groupId>
            <artifactId>jaxb-impl</artifactId>
            <version>2.3.0</version>
        </dependency>
        <dependency>
            <groupId>com.sun.xml.bind</groupId>
            <artifactId>jaxb-core</artifactId>
            <version>2.3.0</version>
        </dependency>
        <dependency>
            <groupId>javax.activation</groupId>
            <artifactId>activation</artifactId>
            <version>1.1.1</version>
        </dependency>

2.导入工具类

public class JwtUtil {

    //毫秒
    private static long time=1000*60*60*24;
    //签名
    private static String signature="admin";

    public static String createToken(){
        //构建JWT对象:Jwts.builder()
        JwtBuilder jwtBuilder = Jwts.builder();
        String jwtToken=jwtBuilder
                //header
                .setHeaderParam("typ", "JWT")
                .setHeaderParam("alg", "HS256")
                //payload
                .claim("username", "admin")
                .claim("role", "admin")
                .setSubject("admin-test")
                //有效时间===>一天=当前时间+24小时
                //获得当前的系统时间：System.currentTimeMillis()
                .setExpiration(new Date(System.currentTimeMillis()+time))
                .setId(UUID.randomUUID().toString())
                //signature
                //注意点：这个签名算法要与前面的算法一致
                .signWith(SignatureAlgorithm.HS256,signature)
                //将前面3个重要信息拼接起来
                .compact();
        return jwtToken;
    }
}

3.在后台解决跨域问题

@Configuration//配置类
public class CoreConfiguration implements WebMvcConfigurer {


    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")//所有接口
                .allowCredentials(true)//是否发送Cookie
                .allowedOriginPatterns("*")//支持域
                .allowedMethods("GET","POST","PUT","DELETE")//支持方法
                .allowedHeaders("*")
                .exposedHeaders("*");
    }
}

4.前台登录界面

5.前端代码

  methods:{
    handleSubmit(){
      this.$refs.ruleForm.validate((valid)=>{
        if(valid){
          let _this=this
          axios.get("http://localhost:8080/login",
              {param:_this.ruleForm}).then(function (response){
            console.log(response.data)
          })
        }
      })
    }
  }

6.进行路由跳转，并且将用户信息存到本地存储中

JSON.stringify-->将JSON转换为字符串

    handleSubmit(){
      this.$refs.ruleForm.validate((valid)=>{
        if(valid){
          let _this=this
          axios.get("http://localhost:8080/login",
              {param:_this.ruleForm})./*带着用户输入的用户名和密码*/
              then(function (response){
                console.log(response.data)
                //如果data不为空，则表示登录成功
                if(response.data!=null){
                  //使用localStorage
                  //将JSON转换为字符串
                  localStorage.setItem('access-admin',JSON.stringify(response.data))
                  //跳转到首页
                  _this.$router.replace({path:"/"})
                  }
                })
          }
      })
    }

7.将用户信息展示到页面中

JSON.parse--->将字符串转换为JSON

<template>
<div>
  欢迎回来：{{admin.username}}
</div>
</template>

  data(){
    return{
      admin:''
    }
  },
  created() {
//获取数据
    this.admin=JSON.parse(window.localStorage.getItem("access-admin"));
  },

8.添加验证用户信息是否存在【在路由中写】

/router/index.js

router.beforeEach((to,from,next)=>{
    if(to.path.startsWith('/login')){
        window.localStorage.removeItem('access-admin')
        next()
    }else {
        let admin=JSON.parse(window.localStorage.getItem('access-admin'))
        if(!admin){
            next({path:'/login'})
        }else {
            //校验token合法性
            axios({
                url:'http://localhost:8080/checkeToken',
                method:'get',
                headers:{
                    token:admin.token
                }
            }).then((response)=>{
                if(!response.data){
                    console.log("校验失败");
                    next({path:'/error'})
                }
            })
        }
    }
})

9.后端验证Token方法

UserController

    /**
     * 验证token方法
     */
    @GetMapping("/checkToken")
    public Boolean checkToken(HttpServletRequest request){
        //因为前端是将数据存储在header，所以我们要是有getHeader
        String token = request.getHeader("token");
        return JwtUtil.checkToken(token);
    }

JwtUtil

    /**
     * 校验token是否正确
     */
    public static boolean checkToken(String token){
        if (token==null){
            return false;
        }
        try {
            //解析
            Jws<Claims> claimsJws = Jwts.parser().setSigningKey(signature).parseClaimsJws(token);
        }catch (Exception e){
            e.printStackTrace();
        }
        return true;
    }

4.Springboot+JWT

User

@Data
public class User {
    private String username;
    private String password;
    private String token;
}

UserController：生成JWT令牌

public class UserController {

    private final String USERNAME = "admin";
    private final String PASSWORD = "123123";

    @GetMapping("/login")
    public User login(User user){
        //判断是否正确
        if(USERNAME.equals(user.getUsername()) && PASSWORD.equals(user.getPassword())){
            //添加token;token保存到user对象
            //定义一个工具类，将生成JWT
            user.setToken(JwtUtil.createToken());
            return user;
        }
        return null;
    }
}

JwtUtil：生成JWT令牌

public class JwtUtil {

    //毫秒
    private static long time=1000*60*60*24;
    //签名
    private static String signature="admin";

    public static String createToken(){
        //构建JWT对象:Jwts.builder()
        JwtBuilder jwtBuilder = Jwts.builder();
        String jwtToken=jwtBuilder
                //header
                .setHeaderParam("typ", "JWT")
                .setHeaderParam("alg", "HS256")
                //payload
                .claim("username", "admin")
                .claim("role", "admin")
                .setSubject("admin-test")
                //有效时间===>一天=当前时间+24小时
                //获得当前的系统时间：System.currentTimeMillis()
                .setExpiration(new Date(System.currentTimeMillis()+time))
                .setId(UUID.randomUUID().toString())
                //signature
                //注意点：这个签名算法要与前面的算法一致
                .signWith(SignatureAlgorithm.HS256,signature)
                //将前面3个重要信息拼接起来
                .compact();
        return jwtToken;
    }
}

【前端直接传递token】

JwtUtil：验证JWT是否过期

    /**
     * 校验token是否过期
     */
    public static boolean checkToken(String token){
        if (token==null || token==""){
            return false;//false表示令牌过期
        }
        try {
            //拿到JWT对象
            Jws<Claims> claimsJws = Jwts.parser().setSigningKey(signature).parseClaimsJws(token);
        }catch (Exception e){
            e.printStackTrace();
        }
        return true;
    }

UserController:验证JWT是否过期

    /**
     * 验证token是否过期:前端传递token
     */
    @GetMapping("/checkToken")
    public Boolean checkToken(String token){
        return JwtUtil.checkToken(token);
    }

【将Token放入请求头中，使用request】

 JwtUtil：验证JWT是否过期

    /**
     * 校验token是否过期
     */
    public static boolean checkToken(String token){
        if (token==null || token==""){
            return false;//false表示令牌过期
        }
        try {
            //拿到JWT对象
            Jws<Claims> claimsJws = Jwts.parser().setSigningKey(signature).parseClaimsJws(token);
        }catch (Exception e){
            e.printStackTrace();
        }
        return true;
    }

UserController:验证JWT是否过期

    /**
     * 验证token是否过期:前端将数据封装在请求头中
     * @param request
     * @return
     */
    public boolean checkToken(HttpServletRequest request){
        //getHeader中的key要与前端通过一致
        String token = request.getHeader("token");//key-->token
        return JwtUtil.checkToken(token);
    }

解决跨域问题

参考：SpringBoot跨域请求的问题_m0_63077733的博客-CSDN博客

@Configuration
public class CorsConfig implements WebMvcConfigurer {

    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**") // 所有接口
                .allowCredentials(true) // 是否发送 Cookie
                .allowedOriginPatterns("*") // 支持域
                .allowedMethods("GET", "POST", "PUT", "DELETE") // 支持方法
                .allowedHeaders("*")
                .exposedHeaders("*");
    }
}

拦截器实现Token验证

@Configuration
public class TokenInterceptor implements HandlerInterceptor {

    //在请求处理方法被调用之前被调用
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //前提：token放在请求头中
        String token = request.getHeader("token");
        if (!JwtUtil.checkToken(token)) {
            return false;//验证失败
        }
        return true;
    }
}

m0_63077733
关注
SpringBoot集成JWT实现token验证-源码
10-02
SpringBoot集成JWT实现token验证_源码
【Spring Security系列】Spring Security整合JWT：构建安全的Web应用_springsecurity jwt
最新发布
heike_Ch的博客
09-13 535
在企业级开发或者我们自己的课程设计中，确保用户数据的安全性和访问控制非常重要。而Spring Security和JWT是都两个强大的工具，它俩结合可以帮助我们实现这一目标。Spring Security提供了全面的安全功能，而JWT则是一种用于身份验证的令牌机制。前面两个章节介绍过了Spring Security，这里就不再赘述了！！！JWT是一种轻量级的身份验证和授权机制，通过发送包含用户信息的加密令牌来实现身份验证。这个工具我们在前面的文章中也提起过。
Springboot项目整合JWT
qq_51770163的博客
03-19 2041
Springboot框架整合JWT拦截验证
JWT使用方法
weixin_42333933的博客
07-26 465
JWT使用方法
SpringSecurity整合jwt
weixin_41359273的博客
03-20 554
SpringSecurity整合jwt1.pom.xml2.用户实体类3. 自定义认证拦截器，登录成功，则返回token4. 自定义校验拦截器，校验用户每次发请求时携带的token是否正确5. security的配置6. controller7. 测试 1.pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://ww
JWT入门指南
白豆五的博客
06-20 2155
JWT（全称：JSON Web Token），通过数字签名的方式，以JSON对象作为载体，在不同的服务终端之间安全的传输信息。JWT 是实现Token无状态会话认证技术的一种标准。 JWT作用：通常用于web应用程序的 身份验证 和 鉴权 。 JWT令牌由Header、Payload、Signature三部分组成，每部分字符串中间用`.` 拼接。JWT令牌的最终格式是这样的： Header.Payload.Signature。
JWT基本使用与整合
YSecret_Y的博客
08-02 596
1、引入jwt的pom依赖 <!-- 引入jwt--> <dependency> <groupId>com.auth0</groupId> <artifactId>java-jwt</artifactId> <version>3.4.0</version> </dependency>
springboot集成jwt
01-25
**SpringBoot集成JWT详解** SpringBoot是一个轻量级的Java框架，它简化了Spring应用程序的创建和部署。JWT（Json Web Token）则是一种用于在各方之间安全地传输信息的开放标准，广泛应用于身份验证和授权场景。在...
springboot集成jwt和shiro实现前后端分离权限demo
04-04
本示例项目“springboot集成jwt和shiro实现前后端分离权限demo”旨在帮助初学者理解如何在Spring Boot环境下结合JWT（JSON Web Token）和Shiro进行权限管理，以实现安全的Web应用。下面将详细介绍相关的知识点。 **...
springboot集成jwt和shiro实现前后端分离权限demo2
04-10
这个"springboot集成jwt和shiro实现前后端分离权限demo2"项目，旨在提供一个实际的案例，帮助开发者理解如何在Spring Boot应用中实现前后端分离的权限管理。通过学习和实践这个示例，你可以掌握JWT和Shiro的使用技巧...
springboot整和jwt、shiro、redis实现token自动刷新
08-19
接着，我们需要创建一个JWTToken Realm，实现Shiro的AuthenticationInfo接口，处理JWT的验证。在Realm中，我们可以解析JWT，获取用户信息，并与数据库进行比对，完成身份验证。 对于Redis的使用，我们需要配置一个...
【微服务环境配置JWT】SpringBoot中配置jwt
酷奇的博客
04-04 678
【代码】【微服务环境配置JWT】SpringBoot中配置jwt。
java jwt的pom文件_SpringBoot集成JWT实现token验证
weixin_32019329的博客
03-06 2166
Jwt全称是：json web token。它将用户信息加密到token里，服务器不保存任何用户信息。服务器通过使用保存的密钥验证token的正确性，只要正确即通过验证。优点简洁: 可以通过URL、POST参数或者在HTTP header发送，因为数据量小，传输速度也很快；自包含：负载中可以包含用户所需要的信息，避免了多次查询数据库；因为Token是以JSON加密的形式保存在客户端的，所以JWT是...
JWT令牌的使用
m0_73505556的博客
01-17 556
JWT令牌的使用
Java基础之《JWT使用》
csj50的专栏
11-07 3558
1、Json web token (JWT) 的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服务器获取资源。也可以增加一些额外的其他业务逻辑所必须的声明信息，该token也可直接被用于认证，也可被加密。传统的token，例如：用户登录成功生成对应的令牌，key为令牌，value为userid，隐藏了数据真实性，同时将该token存放到redis中，返回对应的真实令牌给客户端存放。4、为什么不再用session id。session缺点，集群无法共享。3、传统的token。
jwt配置
weixin_62907807的博客
06-24 600
【代码】jwt配置。
Spring Boot整合JWT
java知识整理
08-04 1441
参考b站视频整理：https://www.bilibili.com/video/BV1i54y1m7cP?p=1 springboot整合jwt步骤： 1、登录时，验证账号和密码成功后，生成jwt，返回给前端； 2、前端接收后保存，再做其他操作，比如增删改查时，同时将jwt传给后端进行验证，如果jwt当做参数一起传给后端，那么每个操作都会有jwt，为了方便，把jwt放到请求头中，通过拦截器来验证。 代码 代码结构图如下，除了常规的controller、entity、mapper和service层，还有两.
jwt的使用
qq_51134950的博客
03-12 650
jwt的学习 1. jwt 是什么 什么是JSON Web令牌？ JSON Web Token（JWT）是一种开放标准（RFC7519）， 它定义了一种紧凑且自包含的方式，用于在各方之间作为 JSON对象安全地传输信息。此信息可以验证和信任，因为 它是经过数字签名的。JWT可以使用秘密（使用HMAC算 法）或使用RSA或ECDSA的公钥/私钥对进行签名 2. jwt 能干什么 授权：这是使用JWT最常见的场景。用户登录后，每个后续请求都将包括JWT，允许用户访问该令牌允许的路由、服务和资源。
SpringBoot与JWT结合实现Token权限管理示例
通过该项目，开发者可以学习到如何使用Spring Security进行安全配置，以及如何利用JWT生成和验证token。同时，此项目也展示了如何通过Spring Boot简化配置和部署过程，使得整个安全体系更加简洁高效。以下将详细介绍...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值