从零开始的Spring Cloud Gateway指南：构建强大微服务架构

微服务架构的兴起已经改变了软件开发的面貌，使得开发者能够更灵活地构建、部署和维护应用程序。而在这个微服务的时代，强大而灵活的网关是确保微服务之间通信顺畅的关键之一。在本文中，我们将深入研究spring cloud gateway，一款开源的、基于spring framework的微服务网关，带领你从零开始构建强大的微服务架构。

一、 什么是gateway？

1. 网关的由来

单体应用拆分成多个服务后，对外需要一个统一入口，解耦客户端与内部服务
注：图片来自网络

2. 网关的作用

spring cloud gateway是spring cloud生态系统中的一员，它被设计用于处理所有微服务的入口流量。作为一个反向代理，它不仅提供了负载均衡和路由功能，还支持灵活的过滤器机制，过滤器可以在请求进入网关和离开网关时执行，用于处理各种逻辑，如身份验证、日志记录和性能监测，使得开发者能够定制和扩展其功能。

网关核心功能是路由转发，因此不要有耗时操作在网关上处理，让请求快速转发到后端服务上。

注：图片来自网络

3. 网关的技术实现

在springcloud中网关的实现包括两种:

• gateway
• zuul

zuul 是基于servlet的实现，在1.x版本属于阻塞式编程，在2.x后是基于netty，是非阻塞的。而springcloudgateway则是基于spring5中提供的webflux，属于响应式编程的实现，具备更好的性能。

目前一般都选用springcloudgateway，毕竟都是spring家族一员，支持性更好。

二、如何搭建一个简易网关服务

1. 引入依赖

需要先搭建一个springboot项目，在父pom中引入依赖

<properties>
        <spring-cloud.version>2021.0.1</spring-cloud.version>
        <spring-cloud-alibaba.version>2021.0.1.0</spring-cloud-alibaba.version>
    </properties>

    <dependencymanagement>
        <dependencies>
            <!-- springcloud 微服务 -->
            <dependency>
                <groupid>org.springframework.cloud</groupid>
                <artifactid>spring-cloud-dependencies</artifactid>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <!-- springcloud alibaba 微服务 -->
            <dependency>
                <groupid>com.alibaba.cloud</groupid>
                <artifactid>spring-cloud-alibaba-dependencies</artifactid>
                <version>${spring-cloud-alibaba.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

    </dependencymanagement>

在gateway服务中引入相关依赖

<dependencies>
        <!--spring cloud gateway-->
        <dependency>
            <groupid>org.springframework.cloud</groupid>
            <artifactid>spring-cloud-starter-gateway</artifactid>
        </dependency>
        <!--nacos 服务发现-->
        <dependency>
            <groupid>com.alibaba.cloud</groupid>
            <artifactid>spring-cloud-starter-alibaba-nacos-discovery</artifactid>
        </dependency>

    </dependencies>

此外，请检查一下你的依赖中是否含有spring-boot-starter-web，如果有， 请干掉它 。因为我们的springcloud gateway是一个netty+webflux实现的web服务器，和springboot web本身就是冲突的。

2. 配置yml文件

server:
  port: 8081 # 网关端口
spring:
  application:
    name: gateway # 服务名称
  cloud:
    nacos:
      server-addr: 127.0.0.1:8848 # nacos地址
    gateway:
      routes: # 网关路由配置
        - id: baidu # 路由id, 自定义，唯一即可
          # uri: 127.0.0.1:/order # - 路由目的地，支持lb和http两种
          uri: lb://orderservice # 路由的目的地，lb是负载均衡，后面跟服务名称
          predicates: # 路由断言，也就是判断是否符合路由规则的条件
            - path=/order-service/** # path 按照路径进行匹配，只要以/order-service/开头就符合规则
          filters:
            - stripprefix=1 # 过滤器，去除请求的前缀路径，stripprefix=1 表示去除请求路径的第一个路径片段

网关路由可以配置的内容包括：

• 路由id:路由唯一标示
• uri: 路由目的地，支持lb和http两种
• predicates: 路由断言，判断请求是否符合要求，符合则转发到路由目的地
• filters:路由过滤器，处理请求或响应

做到这里，一个简易的路由转发网关服务就搭建成功了，直接运行gatewayapplication服务，得到结果如图：

接下来在网页直接访问：http://127.0.0.1:8081/order-service/xx，网关就会将路由转发到orderservice服务。

如果你是通过负载均衡路由到其他服务，这时候可能会报问题：

这是由于缺少一个相关的依赖

<!--客户端负载均衡loadbalancer-->
<dependency>
    <groupid>org.springframework.cloud</groupid>
    <artifactid>spring-cloud-starter-loadbalancer</artifactid>
</dependency>

原因：

引入依赖重新运行，ok！

三、进阶话题：过滤器和路由配置

网关服务一个主要作用就是路由配置，通过不同的路由配置实现相应的功能。

下面看一个案例：

spring:
  application:
    name: gateway # 服务名称
  cloud:
    nacos:
      server-addr: 127.0.0.1:8848 # nacos地址
    gateway:
      routes: # 网关路由配置
        - id: order# 路由id, 自定义，唯一即可
          # uri: 127.0.0.1:/order # - 路由目的地，支持lb和http两种
          uri: lb://orderservice # 路由的目的地，lb是负载均衡，后面跟服务名称
          predicates: # 路由断言，也就是判断是否符合路由规则的条件
            - path=/order-service/** # path 按照路径进行匹配，只要以/order-service/开头就符合规则
          filters: # 过滤器，对请求和响应进行处理
            - stripprefix=1 # 过滤器，去除请求的前缀路径，stripprefix=1 表示去除请求路径的第一个路径片段

注：图片来自网络

1. gateway的执行原理

网关的核心逻辑就是路由转发，执行过滤器链。在下面的处理过程中，gateway handler mapping将请求和路由进行匹配，这时候就需要用到predicate，它是决定了一个请求是否走哪一个路由。

2. 路由断言工厂: predicate factory

我们在配置文件中写的断言规则只是字符串，这些字符串会被predicate factory读取并处理，转变为路由判断的条件。

例如path=/user/**是按照路径匹配，这个规则是由org.springframework.cloud.gateway.handler.predicate.pathroutepredicatefactory类来处理的。

像这样的断言工厂在springcloudgateway还有十几个：

在上图中，有很多类型的predicate。
比如说时间类型的predicated（afterroutepredicatefactory、 beforeroutepredicatefactory、betweenroutepredicatefactory），当只有满足特定时间要求的请求才会交由router处理；

spring:
  cloud:
    gateway:
      routes: # 网关路由配置
        - id: order
          uri: lb://orderservice 
          predicates: 
            - before=2023-12-25t14:33:47.789+08:00

这个路由规则会在东8区的2023-12-25 14:33:47后，将请求转跳到订单服务。

cookie类型的cookieroutepredicatefactory，cookie名字和正则表达式的value作为两个输入参数，请求的cookie需要匹配cookie名和符合其中value的正则，才会进入此router;

spring:
  cloud:
    gateway:
      routes: # 网关路由配置
        - id: order
          uri: lb://orderservice 
          predicates: 
            - cookie=cookiename, cookievalue

路由匹配请求存在cookie名为cookiename，cookie内容匹配cookievalue的，将请求转发到订单服务。

以及host、method、path、querparam、remoteaddr类型的predicate，每一种predicate都会对当前的客户端请求进行判断，是否满足当前的要求，如果满足则交给当前请求处理。

如果有很多个predicate，并且一个请求满足多个predicate，则按照配置的顺序第一个生效。

请注意：一个请求满足多个路由的谓词条件时，请求只会被首个成功匹配的路由转发。

3. 网关过滤器：gatewayfilter

gatewayfilter是网关中提供的一种过滤器，可以对进入网关的请求和微服务返回的响应做处理

针对某些特殊的场景，spring cloud gateway提供了31种不同的路由过滤器工厂。例如

注：图片来自网络

案例：

1. addrequestheader：给所有进入orderservice的请求添加一个请求头: mark=specifications

spring:
  cloud:
    gateway:
      routes: # 网关路由配置
        - id: order
          uri: lb://orderservice 
          filters:
            - addrequestheader=mark, specifications

对匹配的请求，会额外添加mark:specifications的header。

addrequestparameter、addresponseheader 类似。

2. removerequestheader：移除请求的header

spring:
  cloud:
    gateway:
      routes: # 网关路由配置
        - id: order
          uri: lb://orderservice 
          filters:
            - removerequestheader=mark

上面路由在发送请求给订单服务时，会将请求中的mark头信息去掉。

3. stripprefix：截断请求路径前缀

spring:
  cloud:
    gateway:
      routes: # 网关路由配置
        - id: order
          uri: lb://orderservice
          predicates: 
            - path=/order-service/** 
          filters:
            - stripprefix=1

stripprefix gatewayfilter factory通过配置parts来表示截断路径前缀的数量。上面例子中，如果请求的路径为/order-service/order/1，则路径会修改为/order/1。

gateway提供的过滤器很多，这里不一一做展示。

自定义网关过滤器

定义方式是实现abstractgatewayfilterfactory<>类。

public abstract class abstractgatewayfilterfactory<c> extends abstractconfigurable<c> implements gatewayfilterfactory<c>, applicationeventpublisheraware {
    private applicationeventpublisher publisher;

    public abstractgatewayfilterfactory() {
        super(object.class);
    }

    public abstractgatewayfilterfactory(class<c> configclass) {
        super(configclass);
    }

    protected applicationeventpublisher getpublisher() {
        return this.publisher;
    }

    public void setapplicationeventpublisher(applicationeventpublisher publisher) {
        this.publisher = publisher;
    }

    public static class nameconfig {
        private string name;

        public nameconfig() {
        }

        public string getname() {
            return this.name;
        }

        public void setname(string name) {
            this.name = name;
        }
    }
}

自定义过滤器实现黑名单功能

@component
public class blacklisturlfilter extends abstractgatewayfilterfactory<blacklisturlfilter.config>
{
    @override
    public gatewayfilter apply(config config)
    {
        return (exchange, chain) -> {

            string url = exchange.getrequest().geturi().getpath();
            if (config.matchblacklist(url))
            {
                return servletutils.webfluxresponsewriter(exchange.getresponse(), "请求地址不允许访问");
            }

            return chain.filter(exchange);
        };
    }

    public blacklisturlfilter()
    {
        super(config.class);
    }

    public static class config
    {
        private list<string> blacklisturl;

        private list<pattern> blacklisturlpattern = new arraylist<>();

        public boolean matchblacklist(string url)
        {
            return !blacklisturlpattern.isempty() && blacklisturlpattern.stream().anymatch(p -> p.matcher(url).find());
        }

        public list<string> getblacklisturl()
        {
            return blacklisturl;
        }

        public void setblacklisturl(list<string> blacklisturl)
        {
            this.blacklisturl = blacklisturl;
            this.blacklisturlpattern.clear();
            this.blacklisturl.foreach(url -> {
                this.blacklisturlpattern.add(pattern.compile(url.replaceall("\\*\\*", "(.*?)"), pattern.case_insensitive));
            });
        }
    }

}

配置自定义过滤器

spring:
  cloud:
    gateway:
      routes: # 网关路由配置
        - id: order
          uri: lb://orderservice 
          filters:
            - name: blacklisturlfilter
              args:
                blacklisturl:
                  - /user/list
                  - 192.168.20.1

4. 默认过滤器：default filter

如果要对所有的路由都生效，则可以将过滤器工厂写到default下。格式如下

spring:
  cloud:
    gateway:
      routes: # 网关路由配置
        - id: order # 路由id, 自定义，唯一即可
          # uri: http://www.baidu.com # - 路由目的地，支持lb和http两种
          uri: lb://orderservice # 路由的目的地，lb是负载均衡，后面跟服务名称
          predicates: # 路由断言，也就是判断是否符合路由规则的条件
            - path=/order-service/** 
          filters:
            - stripprefix=1 
            - addrequestheader=mark, specifications
      default-filters: 
        - addrequestheader=mark, specifications 

default-filters下的过滤器将对所有的路由都生效。

5. 全局过滤器：globalfilter

全局过滤器的作用也是处理一切进入网关的请求和微服务响应，与gatewayfilter的作用一样。
区别在于gatewayfilter通过配置定义，处理逻辑是固定的。而globalfilter的逻辑需要自己写代码实现。

我们可以通过globalfilter实现日志记录、权限校验、流量监控等功能

定义方式是实现globalfilter接口：

自定义全局过滤器实现网关鉴权：

@component
public class authfilter implements globalfilter, ordered {
    private static final logger log = loggerfactory.getlogger(authfilter.class);

    // 白名单，排除过滤的 uri 地址
    @autowired
    private ignorewhiteproperties ignorewhite;

    @autowired
    private redisservice redisservice;


    @override
    public mono<void> filter(serverwebexchange exchange, gatewayfilterchain chain) {
        serverhttprequest request = exchange.getrequest();
        serverhttpresponse response = exchange.getresponse();
        serverhttprequest.builder mutate = request.mutate();

        string url = request.geturi().getpath();
        // 跳过不需要验证的路径
        if (stringutils.matches(url, ignorewhite.getwhites())) {
            return chain.filter(exchange);
        }
        string token = gettoken(request);
        if (stringutils.isempty(token)) {
            token=getwebsockettoken(request,response);
            if (stringutils.isempty(token)){
                return unauthorizedresponse(exchange, "令牌不能为空");
            }
        }
        claims claims = jwtutils.parsetoken(token);
        if (claims == null) {
            return unauthorizedresponse(exchange, "令牌已过期或验证不正确！");
        }
        string userkey = jwtutils.getuserkey(claims);
        boolean islogin = redisservice.haskey(gettokenkey(userkey));
        if (!islogin) {
            return unauthorizedresponse(exchange, "登录状态已过期");
        }
        string userid = jwtutils.getuserid(claims);
        string username = jwtutils.getusername(claims);
        if (stringutils.isempty(userid) || stringutils.isempty(username)) {
            return unauthorizedresponse(exchange, "令牌验证失败");
        }
        string nickname = jwtutils.getnickname(claims);


        // 设置用户信息到请求
        addheader(mutate, securityconstants.user_key, userkey);
        addheader(mutate, securityconstants.details_user_id, userid);
        addheader(mutate, securityconstants.details_username, username);
       
        // 内部请求来源参数清除
        removeheader(mutate, securityconstants.from_source);
        return chain.filter(exchange.mutate().request(mutate.build()).build());
    }

    private void addheader(serverhttprequest.builder mutate, string name, object value) {
        if (value == null) {
            return;
        }
        string valuestr = value.tostring();
        string valueencode = servletutils.urlencode(valuestr);
        mutate.header(name, valueencode);
    }

    private void removeheader(serverhttprequest.builder mutate, string name) {
        mutate.headers(httpheaders -> httpheaders.remove(name)).build();
    }

    private mono<void> unauthorizedresponse(serverwebexchange exchange, string msg) {
        log.error("[鉴权异常处理]请求路径:{}", exchange.getrequest().getpath());
        return servletutils.webfluxresponsewriter(exchange.getresponse(), msg, httpstatus.unauthorized);
    }

    /**
     * 获取缓存key
     */
    private string gettokenkey(string token) {
        return cacheconstants.login_token_key + token;
    }

    /**
     * 获取请求token
     */
    private string gettoken(serverhttprequest request) {
        string token = request.getheaders().getfirst(tokenconstants.authentication);
        // 如果前端设置了令牌前缀，则裁剪掉前缀
        if (stringutils.isnotempty(token) && token.startswith(tokenconstants.prefix)) {
            token = token.replacefirst(tokenconstants.prefix, stringutils.empty);
        }
        return token;
    }
    private string getwebsockettoken(serverhttprequest request,serverhttpresponse response){
        string token = request.getheaders().getfirst(tokenconstants.websocket_authentication);
        serverhttprequest.builder mutate = request.mutate();
        // 如果前端设置了令牌前缀，则裁剪掉前缀
        if (stringutils.isnotempty(token) ) {
            response.getheaders().set(tokenconstants.websocket_authentication, token);
            removeheader(mutate, tokenconstants.websocket_authentication);
        }
        return token;
    }

    @override
    public int getorder() {
        return -200;
    }
}

6. 过滤器的执行顺序

请求进入网关会碰到三类过滤器: 当前路由的过滤器、defaultfilter、globalfilter。

请求路由后，会将当前路由过滤器和defaultfilter、globalfilter，合并到一个过滤器链(集合)中，排序后依次执行每个过滤器。

• 每一个过滤器都必须指定一个int类型的order值，order值越小，优先级越高，执行顺序越靠前
• globalfilter通过实现ordered接口，或者添加@order注解来指定order值，由我们自己指定
• 路由过滤器和defaultfilter的order由spring指定，默认是按照声明顺序从1递增
• 当过滤器的order值一样时，会按照 defaultfilter > 路由过滤器>globalfilter的顺序执行

可以参考下面几个类的源码查看：

7. globalfilter和gatewayfilter的区别

spring cloud gateway 根据作用范围划分为 gatewayfilter 和 globalfilter，二者区别如下：

• gatewayfilter：网关过滤器，需要通过 spring.cloud.routes.filters 配置在具体路由下，只作用在当前路由上或通过 spring.cloud.default-filters 配置在全局，作用在所有路由上。
• globalfilter：全局过滤器，不需要在配置文件中配置，作用在所有的路由上，最终通过 gatewayfilteradapter 包装成 gatewayfilterchain 可识别的过滤器，它为请求业务以及路由的 uri 转换为真实业务服务请求地址的核心过滤器，不需要配置系统初始化时加载，并作用在每个路由上。

四、实战经验分享：处理微服务间通信

1. 跨域问题处理

跨域问题：浏览器禁止请求的发起者与服务端发生跨域ajax请求，请求被浏览器拦截的问题。它是由浏览器的同源策略所造成的，是浏览器对于javascript所定义的安全限制策略。

同源策略：是指协议，域名，端口都要相同，其中有一个不同都会产生跨域。

• 同一协议， 如http或https
• 同一ip地址或域名, 如127.0.0.1
• 同一端口, 如8080

以上三个条件中有一个条件不同就会产生跨域问题。

例如：

• 域名不同: www.taobao.com 和 www.taobao.org 和 www.jd.com
• 域名相同，端口不同: localhost:8080和localhost:8081

解决方案：

跨源资源共享 (cors)：（或通俗地译为跨域资源共享）是一种基于 http 头的机制，该机制通过允许服务器标示除了它自己以外的其它origin（域，协议和端口），这样浏览器可以访问加载这些资源。现代浏览器支持在 api 容器中（例如 xmlhttprequest 或 fetch）使用 cors，以降低跨源 http 请求所带来的风险。

网关处理跨域采用的同样是cors方案，并且只需要简单配置即可实现。

cors跨域要配置的参数包括：

• 允许哪些域名跨域?
• 允许哪些请求头?
• 允许哪些请求方式?
• 是否允许使用cookie?
• 有效期是多久?

spring: 
  cloud:
    gateway:
      globalcors: # 全局跨域处理
      	add-to-simple-url-handler-mapping: true # 解决options请求被拦截问题
        cors-configurations:
          '[/**]':
            # 允许跨域的源(网站域名/ip)，设置*为全部
            # 允许跨域请求里的head字段，设置*为全部
            # 允许跨域的method， 默认为get和options，设置*为全部
            allow-credentials: true # 是否允许携带cookie
            allowed-origins: # 运行的跨域请求的网站
              - "http://taobao.123.com"
              - "http://www.xx.com"
            allowed-headers: "*" # 允许在请求中携带的头信息
            allowed-methods: # 允许跨域ajax请求方式
              - options
              - get
              - post
              - delete
              - put
              - patch
            max-age: 36000  # 跨域检测的有效期

2. 504 gateway timeout 网关超时处理

504 gateway timeout 错误是一个 http 状态码，表示网关或代理服务器在尝试从上游服务器（如 web 服务器或另一个代理）获取响应时，等待的时间超过了指定的超时限制。

在 spring cloud gateway 中，这个错误通常是由以下原因引起的：

1. 上游服务响应缓慢：上游服务（可能是您的微服务或其他后端服务）可能由于性能问题、资源瓶颈或处理逻辑复杂而响应缓慢。
2. 网络问题：网络延迟或不稳定也可能导致请求在传输过程中花费的时间超过预期。
3. 配置不当：spring cloud gateway 的超时配置可能设置得太低，不适合您的应用或服务。

为了解决这个问题，您可以尝试以下步骤：

1. 检查上游服务：确保上游服务正在运行并且性能良好。您可以使用工具（如 prometheus、grafana、jmeter 等）来监控和分析服务的性能和响应时间。
2. 增加超时时间：在 spring cloud gateway 的配置中增加超时时间。您可以在配置文件中（如 application.yml 或 application.properties）设置 spring.cloud.gateway.httpclient 相关的属性来调整超时时间。
   例如，在 application.yml 中：

spring:  
  cloud:  
    gateway:  
      # 设置全局超时时间
      httpclient:  
        connect-timeout: 1000 # 连接超时时间，单位毫秒  
        response-timeout: 5000 # 响应超时时间，单位毫秒
	  # 配置路由规则
      routes:
        - id: lucky-blog-admin
          # 采用 loadbalanceclient 方式请求，以 lb:// 开头，后面的是注册在 nacos 上的服务名
          uri: lb://lucky-blog-admin
          predicates:
            # 路径匹配，以 api 开头，直接配置是不生效的，看 filters 配置
            - path=/api/**
          filters:
            # 此处配置去掉 1 个路径前缀，再配置上面的 path=/api/**，就能按照 http://localhost:8888/api/** 的方式访问了
            - stripprefix=1
          # 设置当前路由超时时间
          metadata:
            response-timeout: 10000 # 连接超时时间，单位毫秒  
            connect-timeout: 10000 # 响应超时时间，单位毫秒

3. 网关统一异常处理

我们在通过gateway进行路由转发时，可能会遇到各种的问题，通过统一异常处理器，可以将不同的异常进行集中式处理和管理。在开发或者使用过程中报错时，可以更加清晰明了的发现错误提示信息，方便更快地理解和解决问题，还可以优化用户体验并降低维护成本。

自定义异常处理器方式：
可以通过实现errorwebexceptionhandler接口来自定义异常处理器，对全局异常进行统一处理。
在这个处理器中，可以根据异常的类型、状态码等信息，返回不同的响应结果给前端。

import com.alibaba.fastjson.json;
import org.slf4j.logger;
import org.slf4j.loggerfactory;
import org.springframework.boot.web.reactive.error.errorwebexceptionhandler;
import org.springframework.cloud.gateway.support.notfoundexception;
import org.springframework.context.annotation.configuration;
import org.springframework.core.annotation.order;
import org.springframework.core.io.buffer.databuffer;
import org.springframework.http.httpheaders;
import org.springframework.http.httpstatus;
import org.springframework.http.mediatype;
import org.springframework.http.server.reactive.serverhttpresponse;
import org.springframework.web.server.responsestatusexception;
import org.springframework.web.server.serverwebexchange;
import reactor.core.publisher.mono;
import com.fd.luckyblog.gateway.result.resultentity;

/**
 * 网关统一异常处理
 */
@order(-1)
@configuration
public class gatewayexceptionhandler implements errorwebexceptionhandler
{
    private static final logger log = loggerfactory.getlogger(gatewayexceptionhandler.class);

    @override
    public mono<void> handle(serverwebexchange exchange, throwable ex)
    {
        serverhttpresponse response = exchange.getresponse();
        
		# 首先检查响应是否已经提交（即是否已经发送给客户端）。如果已提交，则直接返回包含异常的mono。
        if (exchange.getresponse().iscommitted())
        {
            return mono.error(ex);
        }

        string msg = "";

        if (ex instanceof notfoundexception)
        {
            msg = "服务器迷路啦，30秒后再重试一下. o(∩_∩)o ";
        }
        else if (ex instanceof responsestatusexception)
        {
            responsestatusexception responsestatusexception = (responsestatusexception) ex;
            msg = responsestatusexception.getmessage();
        }
        else
        {
            msg = "内部服务器异常，请联系管理员";
        }

        log.error("[网关异常处理]请求路径:{},异常信息:{}", exchange.getrequest().getpath(), ex.getmessage());

        return webfluxresponsewriter(response, mediatype.application_json_value, httpstatus.ok, msg);
    }

    /**
     * 设置webflux模型响应
     *
     * @param response serverhttpresponse
     * @param contenttype content-type
     * @param status http状态码
     * @param value 响应内容
     * @return mono<void>
     */
    public static mono<void> webfluxresponsewriter(serverhttpresponse response, string contenttype, httpstatus status, object value)
    {
        response.setstatuscode(status);
        response.getheaders().add(httpheaders.content_type, contenttype);
        # 通用的响应实体类，使用自己定义的通用返回类就行
        resultentity<?> result = resultentity.failed(value.tostring());
        databuffer databuffer = response.bufferfactory().wrap(json.tojsonstring(result).getbytes());
        return response.writewith(mono.just(databuffer));
    }
}