SpringCloud Gateway 实现自定义全局过滤器 + JWT权限验证

本文涉及的产品
RDS MySQL Serverless 基础系列,0.5-2RCU 50GB
云数据库 Redis 版,社区版 2GB
推荐场景:
搭建游戏排行榜
RDS MySQL Serverless 高可用系列,价值2615元额度,1个月
简介: SpringCloud Gateway 实现自定义全局过滤器 + JWT权限验证


一、 Gateway filter应用

一、filter简介

1、gateway filter的生命周期

Spring Cloud Gateway同zuul类似,有“pre”和“post”两种方式的filter。客户端的请求先经过“pre”类型的filter,然后将请求转发到具体的业务服务,收到业务服务的响应之后,再经过“post”类型的filter处理,最后返回响应到客户端

  • pre类型的filter:在业务逻辑之前
  • post类型的filter:在业务逻辑之后

2、gateway filter的应用场景

  • pre类型的过滤器:参数校验、权限校验、流量监控、日志输出、协议转换等
  • post类型的过滤器:响应内容、响应头的修改,日志的输出,流量监控等
二、全局过滤器的使用

1、引入依赖和application.yml配置文件

引入依赖

<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway</artifactId>
            <version>3.0.7</version>
        </dependency>
        <dependency>
            <groupId>com.mdx</groupId>
            <artifactId>mdx-shop-common</artifactId>
            <version>1.0.0</version>
        </dependency>

application.yml配置

server:
  port: 9010
spring:
  application:
    name: mdx-shop-gateway
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
        namespace: mdx
        group: mdx
    gateway:
      discovery:
        locator:
          enabled: true  #开启通过服务中心的自动根据 serviceId 创建路由的功能
gateway:
  routes:
    config:
      data-id: gateway-routes  #动态路由
      group: shop
      namespace: mdx

注:

  • 配置文件中的相关路由信息已经配置在了nacos的配置中心
  • springcloud gateway路由相关和引入gateway依赖和spring-boot-starter-web依赖冲突问题可以先看下面的文章
  • springcloud gateway的使用 +
    nacos动态路由

2、创建自定义全局过滤器

新建自定义filter类,需要实现GlobalFilter, Ordered类

其中GlobalFilter是gateway的全局过滤类

他的实现类如下:

Ordered类是过滤器的执行级别,数值越小执行顺序越靠前

MdxAuthFilter完整代码

注:先简单的模拟了一个token验证的流程

package com.mdx.gateway.filter;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
import java.nio.charset.StandardCharsets;
/**
 * @author : jiagang
 * @date : Created in 2022/8/8 15:30
 */
@Component
@Slf4j
public class MdxAuthFilter implements GlobalFilter, Ordered {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        log.info("=========================请求进入filter=========================");
        // 模拟token验证
        String token = exchange.getRequest().getHeaders().getFirst("token");
        if (!"token123".equals(token)){
            log.error("token验证失败...");
            return writeResponse(exchange.getResponse(),401,"token验证失败");
        }
        log.info("token验证成功...");
        return chain.filter(exchange);
    }
    /**
     * 值越小执行顺序越靠前
     * @return
     */
    @Override
    public int getOrder() {
        return 0;
    }
    /**
     * 构建返回内容
     *
     * @param response ServerHttpResponse
     * @param code     返回码
     * @param msg     返回数据
     * @return Mono
     */
    protected Mono<Void> writeResponse(ServerHttpResponse response, Integer code, String msg) {
        JSONObject message = new JSONObject();
        message.put("code", code);
        message.put("msg", msg);
        byte[] bits = message.toJSONString().getBytes(StandardCharsets.UTF_8);
        DataBuffer buffer = response.bufferFactory().wrap(bits);
        response.setStatusCode(HttpStatus.OK);
        // 指定编码,否则在浏览器中会中文乱码
        response.getHeaders().add("Content-Type", "application/json;charset=UTF-8");
        return response.writeWith(Mono.just(buffer));
    }
}

writeResponse是对返回错误信息结果的封装

这里有个比较容易犯错的点,我们通常会在业务系统中建立全局异常处理器,来建立友好的错误返回信息,但是对于filter来说是不生效的,因为filter是在controller之前执行的,所全局异常处理器是不生效的

测试

通过访问网关服务路由到其他服务,查看filter反应

我这里是启动了一个网关服务和一个订单服务

访问接口并在请求头添加token(9010端口为网关服务)

可以看到请求是成功经过了过滤器

测试传递一个错误的token

成功返回错误信息

二、 Gateway filter + JWT实现token拦截

一、jwt简介

1、官方解释什么是jwt

JWT(JSON WEB

TOKEN):JSON网络令牌,JWT是一个轻便的安全跨平台传输格式,定义了一个紧凑的自包含的方式在不同实体之间安全传输信息(JSON格式)。它是在Web环境下两个实体之间传输数据的一项标准。实际上传输的就是一个字符串。广义上讲JWT是一个标准的名称;狭义上JWT指的就是用来传递的那个token字符串

2、jwt的结构

  • Header Header 主要包括两部分,分别是Token的类型(typ)和签名算法(alg)
  • Payload Payload 表示有效负载,主要`是关于实体和其他数据的声明。主要有三种类型,分别是 registered(已注册信息),
    public(公开信息),private(私有信息)

3、jwt的作用

由于http协议是无状态的,所以客户端每次访问都是新的请求。这样每次请求都需要验证身份,传统方式是用session+cookie来记录/传输用户信息,而JWT就是更安全方便的方式。它的特点就是简洁,紧凑和自包含,而且不占空间,传输速度快,而且有利于多端分离,接口的交互等等

JWT是一种Token规范,主要面向的还是登录、验证和授权方向,当然也可以用只来传递信息。一般都是存在header里,也可以存在cookie里

3、jwt和token的关系

  • Token是服务器签发的一串加密字符串,是为了给客户端重复访问的一个令牌,作用是为了证明请求者(客户端)的身份,保持用户长期保持登录状态
  • JWT就是token的一种载体,或者说JWT是一种标准,而Token是一个概念,而JWT就是这个概念执行的一种规范,通俗点说token就是一串字符串,jwt就是加上类型,信息等数据再加密包装一下成为一个新的token
二、jwt工具类

1、引入jwt依赖

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

2、jwt工具类

package com.mdx.gateway.utils;
import com.mdx.common.utils.LocalDateUtil;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
/**
 * JWTProvider需要至少提供两个方法,一个用来创建我们的token,另一个根据token获取Authentication。
 * provider需要保证Key密钥是唯一的,使用init()构建,否则会抛出异常。
 * @author : jiagang
 * @date : Created in 2022/2/9 14:12
 */
@Component
@Slf4j
public class JWTProvider {
    @Value("${jwt.secret}")
    private String secret;
    @Value("${jwt.expiration}")
    private Long expiration;
    /**
     * 根据用户信息生成token
     *
     * @param userName
     * @return
     */
    public String generateToken(String userName) {
        Map<String, Object> claims = new HashMap<>();
        claims.put("CLAIM_KEY_USERNAME", userName);
        claims.put("CLAIM_KEY_CREATED", new Date());
        return generateToken(claims);
    }
    /**
     * 从token中获取登录用户名
     * @param token
     * @return
     */
    public String getUserNameFromToken(String token){
        String username;
        try {
            Claims claims = getClaimsFormToken(token);
//            username = claims.getSubject();
            username = claims.get("CLAIM_KEY_USERNAME").toString();
        } catch (Exception e) {
            username = null;
        }
        return username;
    }
    /**
     * 验证token是否有效
     * @param token
     * @param userName
     * @return
     */
    public boolean validateToken(String token,String userName){
        String username = getUserNameFromToken(token);
        return username.equals(userName) && !isTokenExpired(token);
    }
    /**
     * 判断token是否可以被刷新
     * @param token
     * @return
     */
    public boolean canRefresh(String token){
        return !isTokenExpired(token);
    }
    /**
     * 刷新token
     * @param token
     * @return
     */
    public String refreshToken(String token){
        Claims claims = getClaimsFormToken(token);
        claims.put("CLAIM_KEY_CREATED",new Date());
        return generateToken(claims);
    }
    /**
     * 判断token是否失效
     * @param token
     * @return
     */
    private boolean isTokenExpired(String token) {
        Date expireDate = getExpiredDateFromToken(token);
        return expireDate.before(new Date());
    }
    /**
     * 从token中获取过期时间
     * @param token
     * @return
     */
    public Date getExpiredDateFromToken(String token) {
        Claims claims = getClaimsFormToken(token);
        return claims.getExpiration();
    }
    /**
     * 从token中获取荷载
     * @param token
     * @return
     */
    private Claims getClaimsFormToken(String token) {
        Claims claims = null;
        try {
            claims = Jwts.parser()
                    .setSigningKey(secret)
                    .parseClaimsJws(token)
                    .getBody();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return claims;
    }
    /**
     * 根据荷载生成JWT TOKEN
     *
     * @param claims
     * @return
     */
    private String generateToken(Map<String, Object> claims) {
        return Jwts.builder()
                .setSubject(claims.get("CLAIM_KEY_USERNAME").toString())
                .setClaims(claims)
                .setExpiration(generateExpirationDate())
                .signWith(SignatureAlgorithm.HS512, secret)
                .compact();
    }
    /**
     * 生成token失效时间
     *
     * @return
     */
    private Date generateExpirationDate() {
        // 向后推7天
        return new Date(System.currentTimeMillis() + expiration * 1000);
    }
    public static void main(String[] args) {
        Date date = new Date(System.currentTimeMillis() + 604800 * 1000);
        String s = LocalDateUtil.dateToString(date, "yyyy-MM-dd HH:mm:ss");
        System.out.println(s);
    }
}

2、配置文件

# 这个是 jwt 的配置
jwt:
  tokenHeader: Authorization
  secret: mdx-secrt000001
  expiration: 604800 #秒 7天
  prefix: Bearer
三、登录签发token

1、引入mysql和jpa依赖(redis也会用到)

注:此文章是连载文章,因为之前没有用到mysql,在这里登录要查数据库,所以在这里引入mysql

SpringCloud Alibaba 入门可以从这里看:

springcloud alibaba微服务工程搭建(保姆级)

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.9</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

注意: 因为gateway模块引用了webflux,webflux是无法使用mysql的,所以如果你的mysql是放在了最父级的pom中,启动gateway是会报错的,所以建议将mysql相关依赖放到其他子模块,或者可以在gateway启动类增加注解:@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)

2、配置文件

server:
  port: 9090
spring:
  application:
    name: mdx-shop-user
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    url: jdbc:mysql://127.0.0.1:3306/mdx_shop?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
    driverClassName: com.mysql.cj.jdbc.Driver
    username: root
    password: Bendi+Ceshi+
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
        namespace: mdx
        group: mdx
    sentinel:
      transport:
        dashboard: localhost:8080 #配置Sentinel dashboard地址
        port: 8719
  redis:
    database: 0
    host: localhost
    port: 6379
    jedis:
      pool:
        max-active: 100
        max-idle: 3
        max-wait: -1
        min-idle: 0
    timeout: 2000
feign:
  sentinel:
    enabled: true
# 这个是 jwt 的配置
jwt:
  tokenHeader: Authorization
  secret: mdx-secrt000001
  expiration: 604800 #秒
  prefix: Bearer

3、表结构

/*
 Navicat Premium Data Transfer
 Source Server         : 本地2
 Source Server Type    : MySQL
 Source Server Version : 50724
 Source Host           : localhost:3306
 Source Schema         : mdx_shop
 Target Server Type    : MySQL
 Target Server Version : 50724
 File Encoding         : 65001
 Date: 09/08/2022 10:07:37
*/
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for mdx_user
-- ----------------------------
DROP TABLE IF EXISTS `mdx_user`;
CREATE TABLE `mdx_user`  (
  `user_id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '用户id',
  `user_name` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL COMMENT '用户名',
  `password` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL COMMENT '密码',
  `nick` varchar(6) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL COMMENT '昵称',
  `phone` varchar(11) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL COMMENT '手机号',
  `email` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL COMMENT '电子邮件',
  `status` int(1) NULL DEFAULT NULL COMMENT '状态 0 启用 1禁用',
  `sex` int(1) NULL DEFAULT NULL COMMENT '性别 0 男 1 女',
  `remarks` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL COMMENT '个人描述',
  `last_login_time` datetime(0) NOT NULL COMMENT '上次登录时间',
  `create_time` datetime(0) NOT NULL COMMENT '创建时间',
  `update_time` datetime(0) NULL DEFAULT NULL COMMENT '修改时间',
  PRIMARY KEY (`user_id`) USING BTREE,
  INDEX `idx_phone`(`phone`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 2 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_unicode_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of mdx_user
-- ----------------------------
INSERT INTO `mdx_user` VALUES (1, 'admin', '$2a$10$c./nfmokuQSEn1KKbXbGw.AgTyT5a.Hs3O/qaXQ5BTjb8xRivgytK', '管理员', '13612345678', '123456789@qq.com', 0, 18, NULL, '2022-02-08 17:15:11', '2022-02-08 17:15:03', NULL);
SET FOREIGN_KEY_CHECKS = 1;

4、用户登录接口实现

jpa接口

/**
 * @author : jiagang
 * @date : Created in 2022/2/8 17:01
 */
@Repository
public interface MdxUserRepository extends JpaRepository<MdxUser,Long> {
    /**
     * 获取用户信息
     * @param userName
     * @return
     */
    MdxUser findByUserName(String userName);
}

service实现类

@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private OrderFeign orderFeign;
    @Autowired
    private MdxUserRepository userRepository;
    @Autowired
    private JWTProvider jwtProvider;
    @Autowired
    private RedisManager redisManager;
    @Value("${jwt.prefix}")
    private String prefix;
    /**
     * 登录
     * @param mdxUserDTO
     * @return
     */
    @Override
    public LoginVo login(MdxUserDTO mdxUserDTO) {
        MdxUser mdxUser = userRepository.findByUserName(mdxUserDTO.getUserName());
        if (mdxUser == null){
            throw new BizException("用户不存在");
        }
        BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();
        // 判断用户名密码是否正确
        if (StringUtils.isEmpty(mdxUser.getUserName()) ||
                ! encoder.matches(mdxUserDTO.getPassword(), mdxUser.getPassword())){
            throw new BizException("用户名或者密码错误");
        }
        // 生成token
        String token = jwtProvider.generateToken(mdxUser.getUserName());
        // 将token存入redis
        redisManager.set(UserConstant.USER_TOKEN_KEY_REDIS + mdxUser.getUserName(),token,604800);
        return LoginVo.builder()
                .userId(mdxUser.getUserId().toString())
                .userName(mdxUser.getUserName())
                .token(prefix + " " + token).build();
    }
    public static void main(String[] args) {
        BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();
        String password = encoder.encode("admin");
        System.out.println(password);
    }
    @Override
    public String getOrderNo(String userId, String tenantId, HttpServletRequest request) {
        return orderFeign.getOrderNo(userId,tenantId, request.getHeader("token"));
    }
}

密码加密方法

public static void main(String[] args) {
        BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();
        String password = encoder.encode("admin");
        System.out.println(password);
    }

controller

@Autowired
    private UserService userService;
    /**
     * 登录
     * @param mdxUserDTO
     * @return
     */
    @PostMapping("login")
    public CommonResponse<LoginVo> login(@RequestBody MdxUserDTO mdxUserDTO){
        return CommonResponse.success(userService.login(mdxUserDTO));
    }

测试

成功返回jwt token

四、filter拦截token验证,并对特殊接口放行

1、重新修改我们之前gateway服务中的filter

完成代码如下:

@Component
@Slf4j
public class MdxAuthFilter implements GlobalFilter, Ordered {
    @Autowired
    private RedisManager redisManager;
    @Autowired
    private JWTProvider jwtProvider;
    @Value("${jwt.tokenHeader}")
    private String tokenHeader;
    @Value("${jwt.prefix}")
    private String prefix;
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        log.info("=========================请求进入filter=========================");
        // 验证token
        String authHeader = exchange.getRequest().getHeaders().getFirst(tokenHeader);
        if (authHeader != null && authHeader.startsWith(prefix)){
            String authToken = authHeader.substring(prefix.length());
            String userName = jwtProvider.getUserNameFromToken(authToken);
            // 查询redis
            Object token = redisManager.get(UserConstant.USER_TOKEN_KEY_REDIS + userName);
            if (token == null){
                log.error("token验证失败或已过期...");
                return writeResponse(exchange.getResponse(),401,"token验证失败或已过期...请重新登录");
            }
            // 这里也可以使用 jwtProvider.validateToken() 来验证token,使用redis是因为管理员可以在任意时间将用户token踢出
            // 去除首尾空格
            String trimAuthToken = authToken.trim();
            if (! trimAuthToken.equals(token.toString())){
                log.error("token验证失败或已过期...");
                return writeResponse(exchange.getResponse(),401,"token验证失败或已过期...请重新登录");
            }
        }else {
            return writeResponse(exchange.getResponse(),500,"token不存在");
        }
        log.info("token验证成功...");
        return chain.filter(exchange);
    }
    /**
     * 值越小执行顺序越靠前
     * @return
     */
    @Override
    public int getOrder() {
        return 0;
    }
    /**
     * 构建返回内容
     *
     * @param response ServerHttpResponse
     * @param code     返回码
     * @param msg     返回数据
     * @return Mono
     */
    protected Mono<Void> writeResponse(ServerHttpResponse response, Integer code, String msg) {
        JSONObject message = new JSONObject();
        message.put("code", code);
        message.put("msg", msg);
        byte[] bits = message.toJSONString().getBytes(StandardCharsets.UTF_8);
        DataBuffer buffer = response.bufferFactory().wrap(bits);
        response.setStatusCode(HttpStatus.OK);
        // 指定编码,否则在浏览器中会中文乱码
        response.getHeaders().add("Content-Type", "application/json;charset=UTF-8");
        return response.writeWith(Mono.just(buffer));
    }
}

2、测试

通过访问gateway服务路由到order服务的接口来看下效果

我们先不传token,访问接口(其中9010端口为gateway服务)

提示token不存在

添加一个正确token,将我们上面登录时获取的token填入即可

成功返回订单服务结果

再测试一个错误的token

可以看到返回401

3、特殊接口放行

在一些实际业务中有一些接口是不用登录的,比如登录接口,注册接口等,所以我们需要对这些接口放行。

我们先试下通过网关访问登录接口,不做特殊接口处理的情况

提示我们token不存在

然后我们对登录接口进行放行

配置文件添加如下配置,一般是将以下配置放到nacos配置中心

# 不用登录就可以访问的接口
allowed:
  paths: /mdx-shop-user/user/login

filter方法新增逻辑

完整代码如下

/**
 * @author : jiagang
 * @date : Created in 2022/8/8 15:30
 */
@Component
@Slf4j
public class MdxAuthFilter implements GlobalFilter, Ordered {
    @Autowired
    private RedisManager redisManager;
    @Autowired
    private JWTProvider jwtProvider;
    @Value("${jwt.tokenHeader}")
    private String tokenHeader;
    @Value("${jwt.prefix}")
    private String prefix;
    @Value("${allowed.paths}")
    private String paths; // 不需要登录就能访问的路径
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        log.info("=========================请求进入filter=========================");
        ServerHttpRequest request = exchange.getRequest();
        String requestPath = request.getPath().toString();
        boolean allowedPath = false;
        if (paths != null && !paths.equals("")){
            allowedPath = StringUtil.checkSkipAuthUrls(requestPath, paths.split(","));
        }
        if (allowedPath || StringUtils.isEmpty(requestPath)){
            return chain.filter(exchange);
        }
        // 验证token
        String authHeader = exchange.getRequest().getHeaders().getFirst(tokenHeader);
        if (authHeader != null && authHeader.startsWith(prefix)){
            String authToken = authHeader.substring(prefix.length());
            String userName = jwtProvider.getUserNameFromToken(authToken);
            // 查询redis
            Object token = redisManager.get(UserConstant.USER_TOKEN_KEY_REDIS + userName);
            if (token == null){
                log.error("token验证失败或已过期...");
                return writeResponse(exchange.getResponse(),401,"token验证失败或已过期...请重新登录");
            }
            // 这里也可以使用 jwtProvider.validateToken() 来验证token,使用redis是因为管理员可以在任意时间将用户token踢出
            // 去除首尾空格
            String trimAuthToken = authToken.trim();
            if (! trimAuthToken.equals(token.toString())){
                log.error("token验证失败或已过期...");
                return writeResponse(exchange.getResponse(),401,"token验证失败或已过期...请重新登录");
            }
        }else {
            return writeResponse(exchange.getResponse(),500,"token不存在");
        }
        log.info("token验证成功...");
        return chain.filter(exchange);
    }
    /**
     * 值越小执行顺序越靠前
     * @return
     */
    @Override
    public int getOrder() {
        return 0;
    }
    /**
     * 构建返回内容
     *
     * @param response ServerHttpResponse
     * @param code     返回码
     * @param msg     返回数据
     * @return Mono
     */
    protected Mono<Void> writeResponse(ServerHttpResponse response, Integer code, String msg) {
        JSONObject message = new JSONObject();
        message.put("code", code);
        message.put("msg", msg);
        byte[] bits = message.toJSONString().getBytes(StandardCharsets.UTF_8);
        DataBuffer buffer = response.bufferFactory().wrap(bits);
        response.setStatusCode(HttpStatus.OK);
        // 指定编码,否则在浏览器中会中文乱码
        response.getHeaders().add("Content-Type", "application/json;charset=UTF-8");
        return response.writeWith(Mono.just(buffer));
    }
}

checkSkipAuthUrls工具类方法

/**
     * 将通配符表达式转化为正则表达式
     *
     * @param path
     * @return
     */
    public static String getRegPath(String path) {
        char[] chars = path.toCharArray();
        int len = chars.length;
        StringBuilder sb = new StringBuilder();
        boolean preX = false;
        for (int i = 0; i < len; i++) {
            if (chars[i] == '*') {// 遇到*字符
                if (preX) {// 如果是第二次遇到*,则将**替换成.*
                    sb.append(".*");
                    preX = false;
                } else if (i + 1 == len) {// 如果是遇到单星,且单星是最后一个字符,则直接将*转成[^/]*
                    sb.append("[^/]*");
                } else {// 否则单星后面还有字符,则不做任何动作,下一把再做动作
                    preX = true;
                    continue;
                }
            } else {// 遇到非*字符
                if (preX) {// 如果上一把是*,则先把上一把的*对应的[^/]*添进来
                    sb.append("[^/]*");
                    preX = false;
                }
                if (chars[i] == '?') {// 接着判断当前字符是不是?,是的话替换成.
                    sb.append('.');
                } else {// 不是?的话,则就是普通字符,直接添进来
                    sb.append(chars[i]);
                }
            }
        }
        return sb.toString();
    }
    public static boolean checkSkipAuthUrls(String reqPath,String[] skipAuthUrls) {
        for (String skipAuthUrl:skipAuthUrls) {
            if(wildcardEquals(skipAuthUrl, reqPath)) {
                return true;
            }
        }
        return false;
    }
    /**
     * 通配符模式
     *
     * @param skipAuthUrl - 需要跳过的地址
     * @param reqPath   - 请求地址
     * @return
     */
    public static boolean wildcardEquals(String skipAuthUrl, String reqPath) {
        String regPath = getRegPath(skipAuthUrl);
        return Pattern.compile(regPath).matcher(reqPath).matches();
    }

再次访问登录接口

可以看到gateway已经放行,成功获取到结果

创作不易,点个赞吧👍

最后的最后送大家一句话

白驹过隙,沧海桑田

与君共勉

相关实践学习
基于Redis实现在线游戏积分排行榜
本场景将介绍如何基于Redis数据库实现在线游戏中的游戏玩家积分排行榜功能。
云数据库 Redis 版使用教程
云数据库Redis版是兼容Redis协议标准的、提供持久化的内存数据库服务,基于高可靠双机热备架构及可无缝扩展的集群架构,满足高读写性能场景及容量需弹性变配的业务需求。 产品详情:https://www.aliyun.com/product/kvstore &nbsp; &nbsp; ------------------------------------------------------------------------- 阿里云数据库体验:数据库上云实战 开发者云会免费提供一台带自建MySQL的源数据库&nbsp;ECS 实例和一台目标数据库&nbsp;RDS实例。跟着指引,您可以一步步实现将ECS自建数据库迁移到目标数据库RDS。 点击下方链接,领取免费ECS&amp;RDS资源,30分钟完成数据库上云实战!https://developer.aliyun.com/adc/scenario/51eefbd1894e42f6bb9acacadd3f9121?spm=a2c6h.13788135.J_3257954370.9.4ba85f24utseFl
相关文章
|
14天前
|
算法 NoSQL API
SpringCloud&Gateway网关限流
SpringCloud&Gateway网关限流
62 7
|
14天前
|
缓存
SpringCloud Gateway 网关的请求体body的读取和修改
SpringCloud Gateway 框架中,为了处理请求体body,实现多次读取与修改,创建了一个名为`RequestParamGlobalFilter`的全局过滤器。这个过滤器使用`@Component`和`@Slf4j`注解,实现了`GlobalFilter`和`Ordered`接口,设置最高优先级以首先读取body。它通过缓存请求体并创建装饰过的`ServerHttpRequest`来实现body的动态获取。
104 4
|
14天前
|
Java 微服务 Spring
SpringCloud&Gateway全局过滤器
SpringCloud&Gateway全局过滤器
14 1
|
14天前
|
Java Nacos 网络架构
SpringCloud Gateway的使用 + Nacos动态路由
SpringCloud Gateway的使用 + Nacos动态路由
|
14天前
|
Java Maven 微服务
使用Spring Cloud Gateway构建微服务网关
以上简要示例介绍了使用Spring Cloud Gateway构建微服务网关的基本步骤,包括添加依赖、配置路由、编写过滤器等。通过配置和自定义过滤器,可以实现请求转发、过滤、鉴权等功能。
51 5
|
14天前
|
前端开发 微服务
【十八】搭建SpringCloud项目二(GateWay)
【十八】搭建SpringCloud项目二(GateWay)
31 0
|
14天前
|
安全 数据安全/隐私保护
Springboot+Spring security +jwt认证+动态授权
Springboot+Spring security +jwt认证+动态授权
104 0
1天搞定SpringBoot+Vue全栈开发 (9)JWT跨域认证
1天搞定SpringBoot+Vue全栈开发 (9)JWT跨域认证
|
14天前
|
存储 JSON 算法
SpringBoot之JWT令牌校验
SpringBoot之JWT令牌校验
32 2
|
14天前
|
SQL 安全 Java
微服务之Springboot整合Oauth2.0 + JWT
微服务之Springboot整合Oauth2.0 + JWT
22 1