1
    <dependencyManagement>
2
        <dependencies>
3
            <dependency>
4
                <groupId>org.springframework.cloud</groupId>
5
                <artifactId>spring-cloud-dependencies</artifactId>
6
                <version>${spring-cloud.version}</version>
7
                <type>pom</type>
8
                <scope>import</scope>
9
            </dependency>
10
        </dependencies>
11
    </dependencyManagement>
12

13
    <dependencies>
14
        <dependency>
15
            <groupId>org.springframework.cloud</groupId>
16
            <artifactId>spring-cloud-starter-gateway</artifactId>
17
        </dependency>
18
    </dependencies>

二、运行即可启动#

三、网关功能#

1、断言配置：只有通过过了断言才继续往下走

2、路由，断言后指定走哪个路由

3、路由过程中经过网关过滤器：网关内置了很多过滤器，可以按需选择（例如：路径重写过滤器）

四、网关路由配置#

1
spring:
2
  cloud:
3
    gateway:
4
      routes:
5
        - id: coupon
6
          uri: lb://gulimall-coupon
7
          predicates:
8
            - Path=/api/coupon/**
9
          filters:
10
            - RewritePath=/api/coupon(?<segment>/?.*), /$\{segment}
11
        - id: product
12
          uri: lb://gulimall-product
13
          predicates:
14
            - Path=/api/product/**
15
          filters:
16
            - RewritePath=/api/(?<segment>/?.*), /$\{segment}
17
        - id: fast
18
          uri: lb://renren-fast
19
          predicates:
20
            - Path=/api/**
21
          filters:
22
            - RewritePath=/api/(?<segment>/?.*), /renren-fast/$\{segment}

id <随便取的名字>

uri: 要路由到的地址（这里写的是服务名），lb<代表> 负载均衡

predicates：断言规则，符合条件的进入该路由

filters：过滤器，配置到路由服务前，或则后的过滤规则（这里用到的是路径重写）
1
示例
2
- RewritePath=/api/(?<segment>/?.*), /$\{segment}
3
分析
4
api/cms/user/add       路径重写后    user/add

五、网关异常处理#

Spring Cloud Gateway中的全局异常处理不能直接用@ControllerAdvice来处理，通过跟踪异常信息的抛出，找到对应的源码，自定义一些处理逻辑来符合业务的需求。

网关都是给接口做代理转发的，后端对应的都是REST API，返回数据格式都是JSON。如果不做处理，当发生异常时，Gateway默认给出的错误信息是页面，不方便前端进行异常处理。

需要对异常信息进行处理，返回JSON格式的数据给客户端。下面先看实现的代码，后面再跟大家讲下需要注意的地方。自定义异常处理逻辑：

GlobalGatewayExceptionHandler#

异常处理器

1
package com.easypark.gateway.exception;
2

3
import com.easypark.common.exception.EpException;
4
import com.easypark.common.utils.response.ServiceCodeEnum;
5
import lombok.Getter;
6
import lombok.Setter;
7
import lombok.extern.slf4j.Slf4j;
8
import org.springframework.boot.autoconfigure.web.ErrorProperties;
9
import org.springframework.boot.autoconfigure.web.ResourceProperties;
10
import org.springframework.boot.autoconfigure.web.reactive.error.DefaultErrorWebExceptionHandler;
11
import org.springframework.boot.web.reactive.error.ErrorAttributes;
12
import org.springframework.cloud.gateway.support.NotFoundException;
13
import org.springframework.context.ApplicationContext;
14
import org.springframework.http.HttpStatus;
15
import org.springframework.web.reactive.function.server.*;
16

17
import java.util.HashMap;
18
import java.util.Map;
19

20
/**
21
 * @author zy
22
 * @version 1.0
23
 * @Description 网关异常全局处理
24
 * @date 2021/4/29 9:16
25
 */
26
@Slf4j
27
@Getter
28
@Setter
29
public class GlobalGatewayExceptionHandler extends DefaultErrorWebExceptionHandler {
30

31
    public GlobalGatewayExceptionHandler(ErrorAttributes errorAttributes, ResourceProperties resourceProperties,
32
                                ErrorProperties errorProperties, ApplicationContext applicationContext) {
33
        super(errorAttributes, resourceProperties, errorProperties, applicationContext);
34
    }
35

36
    /**
37
     * 获取异常属性
38
     */
39
    @Override
40
    protected Map<String, Object> getErrorAttributes(ServerRequest request, boolean includeStackTrace) {
41
        int code = 500;
42
        Throwable error = super.getError(request);
43
        String message = this.buildMessage(request, error);
44
        if(error instanceof EpException){
45
            EpException epException = (EpException)error;
46
            code = epException.getErrorCode();
47
        }
48
        if(error instanceof NotFoundException){
49
            log.error("【服务器异常】url={}",request.uri().getPath());
50
            code = 503;
51
            message = ServiceCodeEnum.SERVICE_UNAVAILABLE.getMessage();
52
        }
53

54
        return response(code,message);
55
    }
56

57
    /**
58
     * 指定响应处理方法为JSON处理的方法
59
     * @param errorAttributes errorAttributes
60
     */
61
    @Override
62
    protected RouterFunction<ServerResponse> getRoutingFunction(ErrorAttributes errorAttributes) {
63
        return RouterFunctions.route(RequestPredicates.all(), this::renderErrorResponse);
64
    }
65

66
    /**
67
     * 根据code获取对应的HttpStatus
68
     * @param errorAttributes errorAttributes
69
     */
70
    @Override
71
    protected int getHttpStatus(Map<String, Object> errorAttributes) {
72
        int statusCode = (int) errorAttributes.get("code");
73
        return HttpStatus.valueOf(statusCode).value();
74
    }
75

76
    /**
77
     * 构建异常信息
78
     * @param request request
79
     * @param ex 异常
80
     * @return
81
     */
82
    private String buildMessage(ServerRequest request, Throwable ex) {
83
//        StringBuilder message = new StringBuilder("Failed to handle request [");
84
//        message.append(request.methodName());
85
//        message.append(" ");
86
//        message.append(request.uri());
87
//        message.append("]");
88
//        if (ex != null) {
89
//            message.append(": ");
90
//            message.append(ex.getMessage());
91
//        }
92
//        return message.toString();
93
        return ex.getMessage().toString();
94
    }
95

96
    /**
97
     * 构建返回的JSON数据格式
98
     * @param status 状态码
99
     * @param errorMessage 异常信息
100
     * @return
101
     */
102
    public static Map<String, Object> response(int status, String errorMessage) {
103
        Map<String, Object> map = new HashMap<>();
104
        map.put("code", status);
105
        map.put("msg", errorMessage);
106
        map.put("data", null);
107
        return map;
108
    }
109
}

GlobalGatewayExceptionConfig#

配置：异常处理器

1
package com.easypark.gateway.exception;
2

3
import org.springframework.beans.factory.ObjectProvider;
4
import org.springframework.boot.autoconfigure.web.ResourceProperties;
5
import org.springframework.boot.autoconfigure.web.ServerProperties;
6
import org.springframework.boot.context.properties.EnableConfigurationProperties;
7
import org.springframework.boot.web.reactive.error.ErrorAttributes;
8
import org.springframework.boot.web.reactive.error.ErrorWebExceptionHandler;
9
import org.springframework.context.ApplicationContext;
10
import org.springframework.context.annotation.Bean;
11
import org.springframework.context.annotation.Configuration;
12
import org.springframework.context.annotation.Primary;
13
import org.springframework.core.Ordered;
14
import org.springframework.core.annotation.Order;
15
import org.springframework.http.codec.ServerCodecConfigurer;
16
import org.springframework.web.reactive.result.view.ViewResolver;
17

18
import java.util.Collections;
19
import java.util.List;
20

21
/**
22
 * @author zy
23
 * @version 1.0
24
 * @Description 网关异常配置，覆盖默认的异常处理
25
 * @date 2021/4/29 9:16
26
 */
27
@Configuration
28
@EnableConfigurationProperties({ServerProperties.class, ResourceProperties.class})
29
public class GlobalGatewayExceptionConfig {
30

31
    private final ServerProperties serverProperties;
32

33
    private final ApplicationContext applicationContext;
34

35
    private final ResourceProperties resourceProperties;
36

37
    private final List<ViewResolver> viewResolvers;
38

39
    private final ServerCodecConfigurer serverCodecConfigurer;
40

41
    public GlobalGatewayExceptionConfig(ServerProperties serverProperties,
42
                                        ApplicationContext applicationContext,
43
                                        ResourceProperties resourceProperties,
44
                                        ObjectProvider<List<ViewResolver>> viewResolversProvider,
45
                                        ServerCodecConfigurer serverCodecConfigurer) {
46
        this.serverProperties = serverProperties;
47
        this.applicationContext = applicationContext;
48
        this.resourceProperties = resourceProperties;
49
        this.viewResolvers = viewResolversProvider.getIfAvailable(Collections::emptyList);
50
        this.serverCodecConfigurer = serverCodecConfigurer;
51
    }
52

53
    @Primary
54
    @Bean
55
    @Order(Ordered.HIGHEST_PRECEDENCE)
56
    public ErrorWebExceptionHandler errorWebExceptionHandler(ErrorAttributes errorAttributes) {
57
        GlobalGatewayExceptionHandler exceptionHandler = new GlobalGatewayExceptionHandler(
58
                errorAttributes,
59
                this.resourceProperties,
60
                this.serverProperties.getError(),
61
                this.applicationContext);
62
        exceptionHandler.setViewResolvers(this.viewResolvers);
63
        exceptionHandler.setMessageWriters(this.serverCodecConfigurer.getWriters());
64
        exceptionHandler.setMessageReaders(this.serverCodecConfigurer.getReaders());
65
        return exceptionHandler;
66
    }
67
}

注意点

异常时如何返回JSON而不是HTML

在org.springframework.boot.autoconfigure.web.reactive.error.DefaultErrorWebExceptionHandler中的getRoutingFunction()方法就是控制返回格式的，原代码如下：

1
@Override
2
protected RouterFunction<ServerResponse> getRoutingFunction(
3
 ErrorAttributes errorAttributes) {
4
  return RouterFunctions.route(acceptsTextHtml(), this::renderErrorView)
5
 .andRoute(RequestPredicates.all(), this::renderErrorResponse);
6
}

这边优先是用HTML来显示的，想用JSON的改下就可以了，如下：

1
protected RouterFunction<ServerResponse> getRoutingFunction(ErrorAttributes errorAttributes) {
2
 return RouterFunctions.route(RequestPredicates.all(), this::renderErrorResponse);
3
}

如果我们定义的格式中没有status字段的话，这么就会报错，找不到对应的响应码，要么返回数据格式中增加status子段，要么重写，我这边返回的是code，所以要重写，代码如下：

1
    /**
2
     * 根据code获取对应的HttpStatus
3
     * @param errorAttributes errorAttributes
4
     */
5
    @Override
6
    protected int getHttpStatus(Map<String, Object> errorAttributes) {
7
        int statusCode = (int) errorAttributes.get("code");
8
        return HttpStatus.valueOf(statusCode).value();
9
    }

六、网关限流#

从1.6.0版本开始，Sentinel提供了SpringCloud Gateway的适配模块，可以提供两种资源维度的限流：

route维度：即在Spring配置文件中配置的路由条目，资源名为对应的routeId

自定义API维度：用户可以利用Sentinel提供的API来自定义一些API分组

1 导入依赖#

1
<dependency>
2
    <groupId>com.alibaba.csp</groupId>
3
    <artifactId>sentinel-spring-cloud-gateway-adapter</artifactId>
4
</dependency>

2 编写配置类#

基于Sentinel 的Gateway限流是通过其提供的Filter来完成的，使用时只需注入对应的

SentinelGatewayFilter实例以及 SentinelGatewayBlockExceptionHandler 实例即可。

路由限流：#

1
package com.easypark.gateway.config;
2

3
import com.alibaba.csp.sentinel.adapter.gateway.common.rule.GatewayFlowRule;
4
import com.alibaba.csp.sentinel.adapter.gateway.common.rule.GatewayRuleManager;
5
import com.alibaba.csp.sentinel.adapter.gateway.sc.SentinelGatewayFilter;
6
import com.alibaba.csp.sentinel.adapter.gateway.sc.callback.BlockRequestHandler;
7
import com.alibaba.csp.sentinel.adapter.gateway.sc.callback.GatewayCallbackManager;
8
import com.alibaba.csp.sentinel.adapter.gateway.sc.exception.SentinelGatewayBlockExceptionHandler;
9
import com.easypark.common.utils.response.ServiceCodeEnum;
10
import org.springframework.beans.factory.ObjectProvider;
11
import org.springframework.cloud.gateway.filter.GlobalFilter;
12
import org.springframework.context.annotation.Bean;
13
import org.springframework.core.Ordered;
14
import org.springframework.core.annotation.Order;
15
import org.springframework.http.HttpStatus;
16
import org.springframework.http.MediaType;
17
import org.springframework.http.codec.ServerCodecConfigurer;
18
import org.springframework.web.reactive.function.BodyInserters;
19
import org.springframework.web.reactive.function.server.ServerResponse;
20
import org.springframework.web.reactive.result.view.ViewResolver;
21
import org.springframework.web.server.ServerWebExchange;
22
import reactor.core.publisher.Mono;
23

24
import javax.annotation.PostConstruct;
25
import java.util.*;
26

27
/**
28
 * @author zy
29
 * @version 1.0
30
 * @Description 网关配置
31
 * @date 2021/4/29 14:03
32
 */
33
//@Configuration
34
public class GatewayConfiguration {
35

36
    private final List<ViewResolver> viewResolvers;
37
    private final ServerCodecConfigurer serverCodecConfigurer;
38

39
    public GatewayConfiguration(ObjectProvider<List<ViewResolver>> viewResolversProvider, ServerCodecConfigurer serverCodecConfigurer) {
40
        this.viewResolvers = viewResolversProvider.getIfAvailable(Collections::emptyList);
41
        this.serverCodecConfigurer = serverCodecConfigurer;
42
    }
43

44
    /**
45
     * 初始化一个限流的过滤器
46
     *
47
     * @return GlobalFilter
48
     */
49
    @Bean
50
    @Order(Ordered.HIGHEST_PRECEDENCE)
51
    public GlobalFilter sentinelGatewayFilter() {
52
        return new SentinelGatewayFilter();
53
    }
54

55
    /**
56
     * 配置初始化的限流参数
57
     */
58
    @PostConstruct
59
    public void initGatewayRules() {
60
        Set<GatewayFlowRule> rules = new HashSet<>();
61
        //资源名称,对应路由id
62
        rules.add(new GatewayFlowRule("cms")
63
                // 限流阈值
64
                .setCount(100)
65
                // 统计时间窗口，单位是秒，默认是 1 秒
66
                .setIntervalSec(1));
67
        GatewayRuleManager.loadRules(rules);
68
    }
69

70
    /**
71
     * 配置限流的异常处理器
72
     *
73
     * @return SentinelGatewayBlockExceptionHandler
74
     */
75
    @Bean
76
    @Order(Ordered.HIGHEST_PRECEDENCE)
77
    public SentinelGatewayBlockExceptionHandler sentinelGatewayBlockExceptionHandler() {
78
        return new SentinelGatewayBlockExceptionHandler(viewResolvers, serverCodecConfigurer);
79
    }
80

81
    /**
82
     * 自定义限流异常页面
83
     */
84
    @PostConstruct
85
    public void initBlockHandlers() {
86
        BlockRequestHandler blockRequestHandler = new BlockRequestHandler() {
87
            @Override
88
            public Mono<ServerResponse> handleRequest(ServerWebExchange serverWebExchange, Throwable throwable) {
89
                Map map = new HashMap<>();
90
                map.put("code", ServiceCodeEnum.FAIL.getCode());
91
                map.put("msg", "接口被限流了");
92
                return ServerResponse.status(HttpStatus.OK).
93
                        contentType(MediaType.APPLICATION_JSON_UTF8).
94
                        body(BodyInserters.fromObject(map));
95
            }
96
        };
97
        GatewayCallbackManager.setBlockHandler(blockRequestHandler);
98
    }
99

100
}

路由id加url限流#

1
package com.easypark.gateway.config;
2

3
import com.alibaba.csp.sentinel.adapter.gateway.common.SentinelGatewayConstants;
4
import com.alibaba.csp.sentinel.adapter.gateway.common.api.ApiDefinition;
5
import com.alibaba.csp.sentinel.adapter.gateway.common.api.ApiPathPredicateItem;
6
import com.alibaba.csp.sentinel.adapter.gateway.common.api.ApiPredicateItem;
7
import com.alibaba.csp.sentinel.adapter.gateway.common.api.GatewayApiDefinitionManager;
8
import com.alibaba.csp.sentinel.adapter.gateway.common.rule.GatewayFlowRule;
9
import com.alibaba.csp.sentinel.adapter.gateway.common.rule.GatewayRuleManager;
10
import com.alibaba.csp.sentinel.adapter.gateway.sc.SentinelGatewayFilter;
11
import com.alibaba.csp.sentinel.adapter.gateway.sc.exception.SentinelGatewayBlockExceptionHandler;
12
import org.springframework.beans.factory.ObjectProvider;
13
import org.springframework.cloud.gateway.filter.GlobalFilter;
14
import org.springframework.context.annotation.Bean;
15
import org.springframework.context.annotation.Configuration;
16
import org.springframework.core.Ordered;
17
import org.springframework.core.annotation.Order;
18
import org.springframework.http.codec.ServerCodecConfigurer;
19
import org.springframework.web.reactive.result.view.ViewResolver;
20

21
import javax.annotation.PostConstruct;
22
import java.util.Collections;
23
import java.util.HashSet;
24
import java.util.List;
25
import java.util.Set;
26

27
/**
28
 * @author zy
29
 * @version 1.0
30
 * @Description 网关配置
31
 * @date 2021/4/29 14:03
32
 */
33
@Configuration
34
public class GatewayConfigurationV2 {
35

36
    private final List<ViewResolver> viewResolvers;
37
    private final ServerCodecConfigurer serverCodecConfigurer;
38

39
    public GatewayConfigurationV2(ObjectProvider<List<ViewResolver>> viewResolversProvider, ServerCodecConfigurer serverCodecConfigurer) {
40
        this.viewResolvers = viewResolversProvider.getIfAvailable(Collections::emptyList);
41
        this.serverCodecConfigurer = serverCodecConfigurer;
42
    }
43

44
    /**
45
     * 初始化一个限流的过滤器
46
     *
47
     * @return GlobalFilter
48
     */
49
    @Bean
50
    @Order(Ordered.HIGHEST_PRECEDENCE)
51
    public GlobalFilter sentinelGatewayFilter() {
52
        return new SentinelGatewayFilter();
53
    }
54

55
    /*** 配置初始化的限流参数 */
56
    @PostConstruct
57
    public void initGatewayRules() {
58
        Set<GatewayFlowRule> rules = new HashSet<>();
59
        rules.add(new GatewayFlowRule("cms").setCount(1).setIntervalSec(1));
60
        rules.add(new GatewayFlowRule("product_api2").setCount(1).setIntervalSec(1));
61
        GatewayRuleManager.loadRules(rules);
62
    }
63

64
    /**
65
     * 配置限流的异常处理器
66
     *
67
     * @return SentinelGatewayBlockExceptionHandler
68
     */
69
    @Bean
70
    @Order(Ordered.HIGHEST_PRECEDENCE)
71
    public SentinelGatewayBlockExceptionHandler sentinelGatewayBlockExceptionHandler() {
72
        return new SentinelGatewayBlockExceptionHandler(viewResolvers, serverCodecConfigurer);
73
    }
74

75
    //自定义API分组
76
    @PostConstruct
77
    private void initCustomizedApis() {
78
        Set<ApiDefinition> definitions = new HashSet<>();
79
        ApiDefinition api1 = new ApiDefinition("cms")
80
                .setPredicateItems(new HashSet<ApiPredicateItem>() {{
81
                    // 以/api/cms/sys/adminUser/** 开头的请求
82
                    add(new ApiPathPredicateItem()
83
                            .setPattern("/api/cms/sys/adminUser/**")
84
                            .setMatchStrategy(SentinelGatewayConstants.URL_MATCH_STRATEGY_PREFIX));
85
                }});
86
        ApiDefinition api2 = new ApiDefinition("product_api2")
87
                .setPredicateItems(new HashSet<ApiPredicateItem>() {{
88
                    // 以/product-serv/product/api2/demo1 完成的url路径匹配
89
                    add(new ApiPathPredicateItem().setPattern("/product-serv/product/api2/demo1"));
90
                }});
91
        definitions.add(api1);
92
        definitions.add(api2);
93
        GatewayApiDefinitionManager.loadApiDefinitions(definitions);
94
    }
95

96
}

如果这篇文章对你有帮助，欢迎分享给更多人！

SpringCloud Gateway：新一代微服务网关

https://onecodemaker.cn/posts/springcloud-03-gateway/

作者

糖糖IT

发布于

2026-03-08

许可协议

CC BY-NC-SA 4.0

部分信息可能已经过时

SpringCloud微服务熔断机制与网关实践

SpringCloud OpenFeign：声明式服务调用