springCloud整合JWT

最新推荐文章于 2024-09-06 15:03:42 发布
最新推荐文章于 2024-09-06 15:03:42 发布
阅读量999 收藏 5
点赞数
分类专栏： 互联网技术 文章标签： jwt 过滤器 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZRHZRHH/article/details/103729612
版权

1. 整合环境

  • 添加pom依赖
 <!--jwt依赖-->
        <dependency>
            <groupId>commons-beanutils</groupId>
            <artifactId>commons-beanutils</artifactId>
            <version>1.9.3</version>
        </dependency>

        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.0</version>
        </dependency>

        <dependency>
            <groupId>joda-time</groupId>
            <artifactId>joda-time</artifactId>
            <version>2.9.7</version>
        </dependency>
  • 添加工具类 (文档最后)
    在这里插入图片描述

2. 整合流程示意图

在这里插入图片描述

3.实现

  • 步骤一: 登录时生成token, 并返回
  • 步骤二: 前端登录成功后, 将token保存到sessionStorage
  • 步骤三: 每次请求追加请求头
  • 步骤四: 在网关中, 编写网关过滤器, 对请求进行校验
  • 步骤五: token获取失败, 在api.js中,跳转登录页面登录 (可选)

具体实现

  • 步骤一: 登录时生成token, 并返回
    在这里插入图片描述
   private static final String priKeyPath = "D:\\ras\\ras.pri";

    @PostMapping("/login")
    public BaseResult login(@RequestBody Customer customer){
        System.out.println(customer);
       Customer loginCustomer = customerServiceImpl.login(customer);
       if(loginCustomer == null){
           return BaseResult.error("用户名和密码错误");
       }
        //登录成功,生成token
        String token=null;
        try {
            token = JwtUtils.generateToken(loginCustomer, 30, RasUtils.getPrivateKey(priKeyPath));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return BaseResult.ok("登录成功",loginCustomer).append("token",token);
    }
  • 步骤二: 前端登录成功后, 将token保存到sessionStorage(login.vue)
    在这里插入图片描述
async loginCu(){
        let {data} = await login(this.custom);
        if(data.code == 1){
           this.$message.success(data.message);
          //  保存token到浏览器
          sessionStorage.setItem('token',data.other.token);
           this.$router.push("/home");
        }else{
          this.$message.error(data.message);
        }
      }
  • 步骤三: 每次请求追加请求头(api.js)
    在这里插入图片描述
axios.interceptors.request.use(request => {
    // 给每个请求都添加token
    let token = sessionStorage.getItem('token');
    if(token){
       request.headers.authorization = token;
    }
    // 放行
    return request;
},error => {});
  • 步骤四: 在网关中, 编写网关过滤器, 对请求进行校验
package com.czxy.filter;

import com.czxy.domain.Customer;
import com.czxy.utils.JwtUtils;
import com.czxy.utils.RasUtils;
import com.netflix.zuul.ZuulFilter;
import com.netflix.zuul.context.RequestContext;
import com.netflix.zuul.exception.ZuulException;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;

/**
 * @author zhaorenhui@itcast.cn
 * @version 1.0
 * @date 2019/12/26
 */
@Component
public class LoginFilter extends ZuulFilter {
    private static final String pubKeyPath = "D:\\ras\\ras.pub";

    @Override
    public String filterType() {
        return "pre";
    }

    @Override
    public int filterOrder() {
        return 1;
    }

    @Override
    public boolean shouldFilter() {
        //判断是否是登录路径
        //1,获取请求上下文
        RequestContext requestContext = RequestContext.getCurrentContext();
        //2,获得请求
        HttpServletRequest request = requestContext.getRequest();
        //3,获得请求路径
        String requestURI = request.getRequestURI();
        System.err.println(requestURI);
        //4,判断
        if("/api/examcustomer/customer/login".equals(requestURI)){
            return false;
        }
        return true;
    }

    @Override
    public Object run() throws ZuulException {
        //1,获得请求上下文
        RequestContext requestContext = RequestContext.getCurrentContext();
        //2,获得请求对象
        HttpServletRequest request = requestContext.getRequest();
        //3,获得请求头,获得token值
        String token = request.getHeader("Authorization");
        //4,判断-校验
        try {
            JwtUtils.getObjectFromToken(token, RasUtils.getPublicKey(pubKeyPath), Customer.class);
        } catch (Exception e) {
            e.printStackTrace();
            //    获取token错误, 不予许放行, 返回403状态码
            requestContext.setSendZuulResponse(false);
            requestContext.setResponseStatusCode(403);
        }
        //放行
        return null;
    }
}
  • 步骤五: token获取失败, 在api.js中,跳转登录页面登录 (可选)

在这里插入图片描述
在这里插入图片描述


axios.interceptors.response.use(response => {
    // 放行
    return response
}, error => {
    // 错误提示
      // 获取响应状态码
    console.info(error.response);
    if(error.response.status=='403'){
        router.push("/login")
    }
    console.info(error)
    Message.error(error.message)
    return Promise.reject(error)
})

4.工具类

  • JwtUtils
package com.czxy.utils;


import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.apache.commons.beanutils.BeanUtils;
import org.joda.time.DateTime;

import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.security.PrivateKey;
import java.security.PublicKey;

public class JwtUtils {
    /**
     *  私钥加密token
     * @param data 需要加密的数据（载荷内容）
     * @param expireMinutes 过期时间，单位：分钟
     * @param privateKey 私钥
     * @return
     */
    public static String generateToken(Object data, int expireMinutes, PrivateKey privateKey) throws Exception {
        //1 获得jwt构建对象
        JwtBuilder jwtBuilder = Jwts.builder();
        //2 设置数据
        if( data == null ) {
            throw new RuntimeException("数据不能为空");
        }
        BeanInfo beanInfo = Introspector.getBeanInfo(data.getClass());
        PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
        for (PropertyDescriptor propertyDescriptor : propertyDescriptors) {
            // 获得属性名
            String name = propertyDescriptor.getName();
            // 获得属性值
            Object value = propertyDescriptor.getReadMethod().invoke(data);
            if(value != null) {
                jwtBuilder.claim(name,value);
            }
        }
        //3 设置过期时间
        jwtBuilder.setExpiration(DateTime.now().plusMinutes(expireMinutes).toDate());
        //4 设置加密
        jwtBuilder.signWith(SignatureAlgorithm.RS256, privateKey);
        //5 构建
        return jwtBuilder.compact();
    }

    /**
     * 通过公钥解析token
     * @param token 需要解析的数据
     * @param publicKey 公钥
     * @param beanClass 封装的JavaBean
     * @return
     * @throws Exception
     */
    public static <T> T  getObjectFromToken(String token, PublicKey publicKey,Class<T> beanClass) throws Exception {
        //1 获得解析后内容
        Claims body = Jwts.parser().setSigningKey(publicKey).parseClaimsJws(token).getBody();
        //2 将内容封装到对象JavaBean
        T bean = beanClass.newInstance();
        BeanInfo beanInfo = Introspector.getBeanInfo(beanClass);
        PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
        for (PropertyDescriptor propertyDescriptor : propertyDescriptors) {
            // 获得属性名
            String name = propertyDescriptor.getName();
            // 通过属性名，获得对应解析的数据
            Object value = body.get(name);
            if(value != null) {
                // 将获得的数据封装到对应的JavaBean中
                BeanUtils.setProperty(bean,name,value);
            }
        }
        return bean;
    }
}
  • RasUtils
package com.czxy.utils;


import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;


public class RasUtils {

    /**
     * 从文件中读取公钥
     *
     * @param filename 公钥保存路径，相对于classpath
     * @return 公钥对象
     * @throws Exception
     */
    public static PublicKey getPublicKey(String filename) throws Exception {
        byte[] bytes = readFile(filename);
        return getPublicKey(bytes);
    }

    /**
     * 从文件中读取密钥
     *
     * @param filename 私钥保存路径，相对于classpath
     * @return 私钥对象
     * @throws Exception
     */
    public static PrivateKey getPrivateKey(String filename) throws Exception {
        byte[] bytes = readFile(filename);
        return getPrivateKey(bytes);
    }

    /**
     * 获取公钥
     *
     * @param bytes 公钥的字节形式
     * @return
     * @throws Exception
     */
    public static PublicKey getPublicKey(byte[] bytes) throws Exception {
        X509EncodedKeySpec spec = new X509EncodedKeySpec(bytes);
        KeyFactory factory = KeyFactory.getInstance("RSA");
        return factory.generatePublic(spec);
    }

    /**
     * 获取密钥
     *
     * @param bytes 私钥的字节形式
     * @return
     * @throws Exception
     */
    public static PrivateKey getPrivateKey(byte[] bytes) throws Exception {
        PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(bytes);
        KeyFactory factory = KeyFactory.getInstance("RSA");
        return factory.generatePrivate(spec);
    }

    /**
     * 根据密文，生存rsa公钥和私钥,并写入指定文件
     *
     * @param publicKeyFilename  公钥文件路径
     * @param privateKeyFilename 私钥文件路径
     * @param secret             生成密钥的密文
     * @throws Exception
     */
    public static void generateKey(String publicKeyFilename, String privateKeyFilename, String secret) throws Exception {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        SecureRandom secureRandom = new SecureRandom(secret.getBytes());
        keyPairGenerator.initialize(1024, secureRandom);
        KeyPair keyPair = keyPairGenerator.genKeyPair();
        // 获取公钥并写出
        byte[] publicKeyBytes = keyPair.getPublic().getEncoded();
        writeFile(publicKeyFilename, publicKeyBytes);
        // 获取私钥并写出
        byte[] privateKeyBytes = keyPair.getPrivate().getEncoded();
        writeFile(privateKeyFilename, privateKeyBytes);
    }

    private static byte[] readFile(String fileName) throws Exception {
        return Files.readAllBytes(new File(fileName).toPath());
    }

    private static void writeFile(String destPath, byte[] bytes) throws IOException {
        File dest = new File(destPath);

        //创建父文件夹
        if(!dest.getParentFile().exists()){
            dest.getParentFile().mkdirs();
        }
        //创建需要的文件
        if (!dest.exists()) {
            dest.createNewFile();
        }

        Files.write(dest.toPath(), bytes);
    }


}
ZRHZRHH
关注
专栏目录
Spring Cloud Gateway整合JWT现统一认证和鉴权
LynRaen的博客
03-02 4711
当下比较主流的微服务权限解决方案，在网关进行校验认证和鉴权，而系统其他的业务api服务只需要单纯的提供服务。从而实现业务逻辑代码和认证鉴权的解耦。 系统架构 架构方面可以抽象成三种类型的服务，分别是网关服务、认证服务、API服务 主要maven依赖 <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-.
springcloud：4.2 GateWay结合JWT实现网关鉴权
m0_63040701的博客
03-18 1492
算出签名以后，把 Header、Payload、Signature 三个部分拼成一个字符串，每个部分之间用"点"（.）分隔，就可以返回给用户。
jwt springcloud
11-20
jwt springcloud,修复了刷新tokenbug， 注意修改下端口网关 登录认证地址 http://localhost:8764/openplt/auth/login 刷新tocken 地址 http://localhost:8764/openplt/auth/refresh_token，详情参考 https://www.jb51.net/article/133832.htm 原始作者
SpringCloud整合JWT
qq1192360489的博客
12-27 1930
JWT，全称是Json Web Token， 是JSON风格轻量级的授权和身份认证规范，可实现无状态、分布式的Web应用授权；官网：[](https://jwt.io) 流程图 导入依赖 <!--jwt依赖--> <dependency> <groupId>commons-beanutils</groupId&g...
SpringCloud之JWT
qq_45578181的博客
08-27 664
文章目录登录状态有状态登录无状态登录JWT(Json Web Token)JWT三部分headerpayload 负载signature 数字签名JWT使用令牌验证JWT缺点 登录状态 有状态登录 即服务端需要记录每次会话的客户端信息，从而识别客户端身份，根据用户身份进行请求的处理. 典型的设计如tomcat中的session。 缺点是什么？ 服务端保存大量数据，增加服务端压力 客户端请求依赖服务端，多次请求必须访问同一台服务器。 无状态登录 无状态服务，服务端不保存任何客户端请求者信息，客户端的每次请
springcloud整合oauth2和jwt
04-09
springcloud整合oauth2和jwt实现权限认证,整合mybaits
Springcloud+Jwt应用开发
如果你想拥有更多的人生选择，你必须拥有更多的知识。-- 来自u011437883的博客
05-15 218
Springcloud+Jwt应用开发。
微服务安全架构(Spring Boot _ Spring Cloud-JWT).pdf
03-26
基于Spring Boot与Spring Cloud的微服务安全架构，主要关注点是使用JWT（JSON Web Token）作为微服务之间的认证和授权机制，这在当今云计算和分布式系统架构中是非常关键的部分。整个文档描述了在构建和维护微服务...
Spring Cloud集成OAuth2和JWT
升仔聊编程的博客
01-28 645
Spring Cloud作为微服务解决方案的重要组成部分，提供了服务发现、配置管理、负载均衡等功能，极大地简化了分布式系统环境下的服务交互。而在微服务架构中，安全性是个不可忽视的话题。这时，OAuth2和JWT（JSON Web Tokens）就派上用场了。OAuth2是一种授权框架，它允许应用程序代表用户去访问其在另一个应用程序中的资源。它支持多种授权模式，例如授权码模式、简化模式、密码模式和客户端凭证模式。而JWT是一种用于双方之间传递安全信息的JSON对象。
redis 查看key的有效期_redis key过期时间设置的两种方法
weixin_39584405的博客
12-22 4041
设置redis key过期时间或生存时间有两种方法可以用，为什么要设置redis key的过期时间呢？有哪些应用场景？比如我们在发送手机验证码的时候，可以将手机号作为redis key，验证码作为redis value存储在redis中，并设置过期时间为60秒，这个时候当用户收到短信验证码的时候，如果60秒的时间到了，从redis中获取手机短信验证码时就会返回nil，这样我们就可以认为用户输入短信...
详解用JWT对SpringCloud进行认证和鉴权
08-26
主要介绍了详解用JWT对SpringCloud进行认证和鉴权，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
RSA加密 公钥、密钥生成工具
03-17
RSA加密 公钥、密钥生成工具，搜索引擎只搜得到方法，却没有工具，这么好用的东西，却没人分享，那就让我来分享！ 使用前，请确定您已安装 .Net Framework 4.0！
java RSA 生成公钥私钥
10-14 359
/** * 引进的包都是Java自带的jar包 * 秘钥相关包 * base64 编解码 * 这里只用到了编码 */ import java.security.Key; import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.inte...
Spring Cloud入门-Oauth2授权之JWT集成(Hoxton版本)
m0_63099094的博客
10-26 305
| 11 | Spring Cloud入门-Consul服务注册发现与配置中心(Hoxton版本) | https://blog.csdn.net/ThinkWon/article/details/103756139 | | 12 | Spring Cloud入门-Gateway服务网关(Hoxton版本) | https://blog.csdn.net/ThinkWon/article/details/103757927 | | 13 | Spring Cloud入门-Admin服务监控中心(Hoxton
Spring Cloud 完整整合 Security + Oauth2 + jwt实现权限认证
最新发布
qq_41935756的博客
09-06 1630
OAuth2是一个开放的标准，协议。即允许用户让第三方应用访问某一个网站上存储的用户私密资源(照片，头像等)。这个过程中无需将用户名和密码提供给第三方应用。在互联网中，我们最常见的OAuth2的应用就是各种第三方通过QQ授权，微信授权，微博授权等登录了。   OAuth2协议一共支持4中不同的授权模式。OAuth2的重要参数 ①response_type code：表示要求返回授权码。token：表示直接返回令牌 ②client_id 客户端身份标识 ③client_secret 客户端密钥 ④redire
【Spring Cloud】使用JWT技术实现登录功能
hui_zai_的博客
05-20 1028
使用JWT技术实现登录功能
SpringCloud微服务之最全JWT学习教程03
Maynor的博客
11-18 794
1.JWT 1.0 为什么要学习JWT？ 1.1.简介 JWT，全称是Json Web Token， 是JSON风格轻量级的授权和身份认证规范，可实现无状态、分布式的Web应用授权；它是分布式服务权限控制的标准解决方案！ 它跟RBAC的区别：两者不冲突，在项目中后台权限服务的数据库设计使用RBAC，而前端项目访问后台微服务的权限校验使用jwt 官网：https://jwt.io . GitHub上jwt的java客户端：https://github.com/jwtk/jjwt 什么是token：http
【SpringCloud-9】JWT
growing_duck的博客
07-06 375
JWT
springcloud 整合shiro和jwt
03-16
Spring Cloud可以与Shiro和JWT进行整合，实现安全认证和授权功能。 Shiro是一个强大的Java安全框架，可以提供身份验证、授权、加密和会话管理等功能。Spring Cloud可以通过集成Shiro来实现安全认证和授权功能。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值