微服务网关设计与实战：Spring Cloud Gateway 全解析

微服务网关设计与实战：Spring Cloud Gateway 全解析 | 极客日志

技术选型	核心优势	不足之处	适用场景
Spring Cloud Gateway	1. 基于 Spring 生态，与 Spring Cloud 无缝整合； 2. 基于 Netty 异步非阻塞，性能优异（吞吐量是 Zuul 的 2-3 倍）； 3. 支持动态路由、灵活的断言与过滤器； 4. 原生支持 WebSocket、限流、熔断等功能	1. 仅支持 Spring Boot/Spring Cloud 项目； 2. 学习成本略高于 Zuul	Spring Cloud 生态的微服务项目，对性能要求较高的场景
Zuul（1.x/2.x）	1. 简单易用，与 Spring Cloud 整合成熟； 2. 社区成熟，文档丰富； 3. Zuul 2.x 支持异步非阻塞	1. Zuul 1.x 基于 Servlet 同步阻塞，性能较差； 2. 功能扩展性不如 Spring Cloud Gateway	小型微服务项目，对性能要求不高，追求开发效率
Kong	1. 基于 Nginx，性能极高，支持高并发； 2. 支持多语言微服务（不局限于 Java）； 3. 丰富的插件生态（认证、限流、监控等）	1. 与 Spring Cloud 生态整合不够紧密； 2. 配置复杂，二次开发成本高	多语言混合开发的微服务项目，对性能和并发要求极高的场景

客户端请求 → 网关接收请求 → 路由匹配（断言 Predicate） → 过滤器链执行（Filter） → 转发到微服务 → 微服务响应 → 过滤器链反向执行 → 响应客户端

<!-- Spring Boot 父依赖 -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.7.15</version>
    <relativePath/>
</parent>
<!-- Spring Cloud 依赖管理 -->
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>2021.0.4</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>
<dependencies>
    <!-- Spring Cloud Gateway 核心依赖（注意：排除 spring-boot-starter-web，避免冲突） -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-gateway</artifactId>
        <exclusions>
            <exclusion>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <!-- Nacos 服务发现（用于动态路由，从 Nacos 获取微服务地址） -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        <version>2021.0.4.0</version>
    </dependency>
    <!-- Lombok -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <!-- 日志依赖（SLF4J+Logback） -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-logging</artifactId>
    </dependency>
</dependencies>

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@SpringBootApplication
@EnableDiscoveryClient // 开启服务发现（从 Nacos 获取微服务列表）
public class GatewayApplication {
    public static void main(String[] args) {
        SpringApplication.run(GatewayApplication.class, args);
    }
}

spring:
  application:
    name: gateway-service # 网关服务名称（注册到 Nacos）
  cloud:
    # Nacos 服务发现配置
    nacos:
      discovery:
        server-addr: localhost:8848 # Nacos 地址
    # Gateway 配置
    gateway:
      # 启用服务发现路由（自动从 Nacos 获取微服务，生成路由规则）
      discovery:
        locator:
          enabled: true # 开启服务发现路由
          lower-case-service-id: true # 微服务名称转为小写（如 USER-SERVICE→user-service）
      # 路由规则配置（静态路由，优先级高于服务发现路由）
      routes:
        # 路由 1：用户服务路由
        - id: user-service-route # 路由唯一 ID（自定义，建议与服务名一致）
          uri: lb://user-service # 目标微服务地址（lb 表示负载均衡）
          predicates:
            - Path=/api/user/** # 路径断言：匹配以/api/user/开头的请求
          filters:
            - RewritePath=/api/user/(?<segment>.*), /${segment} # 路径重写：/api/user/1 → /1
        # 路由 2：订单服务路由
        - id: order-service-route
          uri: lb://order-service
          predicates:
            - Path=/api/order/**
          filters:
            - RewritePath=/api/order/(?<segment>.*), /${segment}
server:
  port: 8080 # 网关端口（客户端统一访问 8080 端口）
# 日志配置（打印请求详细日志，便于调试）
logging:
  level:
    org.springframework.cloud.gateway: DEBUG
    org.springframework.web.reactive: INFO

{"orderId":1695888888888,"userId":1,"username":"张三 1","productName":"Java 编程思想","price":89.0,"count":1,"totalAmount":89.0,"status":"已创建"}

{"id":1,"username":"张三 1","phone":"13800138001","address":"北京市朝阳区"}

spring:
  cloud:
    gateway:
      routes:
        - id: user-service-route
          uri: lb://user-service
          predicates:
            # 1. 路径断言（必选，匹配/api/user/**或/user/**）
            - Path=/api/user/**, /user/**
            # 2. 方法断言（仅允许 GET 请求）
            - Method=GET
            # 3. 请求头断言（必须包含 X-Request-Id 请求头）
            - Header=X-Request-Id, \d+ # 正则表达式：X-Request-Id 的值为数字
            # 4. 请求参数断言（可选参数 token，值包含"auth"）
            - Query=token, auth.*
            # 5. 时间断言（请求时间在 2024-01-01 之后）
            - After=2024-01-01T00:00:00+08:00[Asia/Shanghai]
          filters:
            - RewritePath=/api/user/(?<segment>.*), /${segment}
            - RewritePath=/user/(?<segment>.*), /${segment}

import org.springframework.cloud.gateway.handler.predicate.AbstractRoutePredicateFactory;
import org.springframework.cloud.gateway.handler.predicate.GatewayPredicate;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.stereotype.Component;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.server.ServerWebExchange;
import javax.validation.constraints.NotEmpty;
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

// 断言工厂名称：IpWhiteListRoutePredicateFactory → 配置时使用 IpWhiteList
@Component
public class IpWhiteListRoutePredicateFactory extends AbstractRoutePredicateFactory<IpWhiteListRoutePredicateFactory.Config> {
    // 配置类（接收 yaml 中的配置参数）
    @Validated
    public static class Config {
        @NotEmpty(message = "IP 白名单不能为空")
        private List<String> allowedIps;

        public List<String> getAllowedIps() { return allowedIps; }
        public void setAllowedIps(List<String> allowedIps) { this.allowedIps = allowedIps; }
    }

    // 构造方法：指定配置类
    public IpWhiteListRoutePredicateFactory() {
        super(Config.class);
    }

    // 配置参数解析（将 yaml 中的 allowedIps 转为 List<String>）
    @Override
    public List<String> shortcutFieldOrder() {
        return Arrays.asList("allowedIps");
    }

    // 断言逻辑：判断请求 IP 是否在白名单中
    @Override
    public GatewayPredicate apply(Config config) {
        return new GatewayPredicate() {
            @Override
            public boolean test(ServerWebExchange exchange) {
                // 获取客户端 IP（实际开发中需处理反向代理场景，如 Nginx 转发）
                ServerHttpRequest request = exchange.getRequest();
                String clientIp = request.getRemoteAddress().getAddress().getHostAddress();
                // 判断 IP 是否在白名单中
                return config.getAllowedIps().contains(clientIp);
            }

            @Override
            public String toString() {
                return "IpWhiteList: " + config.getAllowedIps();
            }
        };
    }
}

spring:
  cloud:
    gateway:
      routes:
        - id: user-service-route
          uri: lb://user-service
          predicates:
            - Path=/api/user/**
            - IpWhiteList=127.0.0.1, 192.168.1.100 # 仅允许本地和 192.168.1.100 访问
          filters:
            - RewritePath=/api/user/(?<segment>.*), /${segment}

过滤器类型	作用范围	配置方式	典型场景
局部过滤器	特定路由	在路由的 filters 节点中配置	路径重写、局部限流、特定路由的参数处理
全局过滤器	所有路由	实现 GlobalFilter 接口，无需配置	统一认证、日志收集、跨域处理、全局限流

spring:
  cloud:
    gateway:
      routes:
        - id: user-service-route
          uri: lb://user-service
          predicates:
            - Path=/api/user/**
          filters:
            - RewritePath=/api/user/(?<segment>.*), /${segment}
            - AddRequestHeader=X-Gateway-Version, v1.0.0 # 添加请求头

filters:
  - AddRequestParameter=source, gateway # 所有转发到 user-service 的请求都会携带 source=gateway 参数

import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
import java.util.Arrays;
import java.util.List;

// 局部过滤器工厂名称：ResponseTimeGatewayFilterFactory → 配置时使用 ResponseTime
@Component
public class ResponseTimeGatewayFilterFactory extends AbstractGatewayFilterFactory<ResponseTimeGatewayFilterFactory.Config> {
    // 配置类（无参数，仅作为标识）
    public static class Config {}

    public ResponseTimeGatewayFilterFactory() {
        super(Config.class);
    }

    @Override
    public List<String> shortcutFieldOrder() {
        return Arrays.asList(); // 无配置参数，返回空列表
    }

    @Override
    public GatewayFilter apply(Config config) {
        return (exchange, chain) -> {
            // 1. pre 逻辑：记录请求开始时间
            long startTime = System.currentTimeMillis();
            // 2. 转发请求到微服务
            return chain.filter(exchange).then(Mono.fromRunnable(() -> {
                // 3. post 逻辑：计算耗时，添加响应头
                long duration = System.currentTimeMillis() - startTime;
                exchange.getResponse().getHeaders().add("X-Response-Time", duration + "ms");
            }));
        };
    }
}

spring:
  cloud:
    gateway:
      routes:
        - id: user-service-route
          uri: lb://user-service
          predicates:
            - Path=/api/user/**
          filters:
            - RewritePath=/api/user/(?<segment>.*), /${segment}
            - ResponseTime # 引用自定义局部过滤器

<!-- JWT 依赖 -->
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-api</artifactId>
    <version>0.11.5</version>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-impl</artifactId>
    <version>0.11.5</version>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-jackson</artifactId>
    <version>0.11.5</version>
    <scope>runtime</scope>
</dependency>

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.security.Keys;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import javax.crypto.SecretKey;
import java.util.Date;

@Component
public class JwtUtil {
    // JWT 密钥（实际开发中需配置在 Nacos，避免硬编码）
    @Value("${jwt.secret:abcdefghijklmnopqrstuvwxyz1234567890}")
    private String secret;

    // 令牌过期时间（2 小时）
    @Value("${jwt.expire:7200000}")
    private long expire;

    // 生成密钥（HMAC-SHA256 算法要求密钥长度至少 256 位）
    private SecretKey getSecretKey() {
        return Keys.hmacShaKeyFor(secret.getBytes());
    }

    // 生成 JWT 令牌
    public String generateToken(Long userId, String username) {
        return Jwts.builder()
                .setSubject(userId.toString()) // 主题（存储用户 ID）
                .claim("username", username) // 自定义声明（存储用户名）
                .setIssuedAt(new Date()) // 签发时间
                .setExpiration(new Date(System.currentTimeMillis() + expire)) // 过期时间
                .signWith(getSecretKey()) // 签名
                .compact();
    }

    // 校验令牌有效性
    public boolean validateToken(String token) {
        try {
            Jwts.parserBuilder().setSigningKey(getSecretKey()).build().parseClaimsJws(token);
            return true;
        } catch (Exception e) {
            // 令牌过期、签名错误等都会抛出异常
            return false;
        }
    }

    // 解析令牌中的声明
    public Claims parseClaims(String token) {
        return Jwts.parserBuilder().setSigningKey(getSecretKey()).build().parseClaimsJws(token).getBody();
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

@Component
public class AuthGlobalFilter implements GlobalFilter, Ordered {
    @Autowired
    private JwtUtil jwtUtil;

    // 不需要认证的接口（白名单）
    private static final String[] WHITE_LIST = {
        "/api/user/login", // 登录接口
        "/api/user/register", // 注册接口
        "/actuator/health" // 健康检查接口
    };

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, org.springframework.cloud.gateway.filter.GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        ServerHttpResponse response = exchange.getResponse();

        // 1. 判断请求路径是否在白名单中，若在则直接放行
        String path = request.getPath().value();
        for (String whitePath : WHITE_LIST) {
            if (path.startsWith(whitePath)) {
                return chain.filter(exchange);
            }
        }

        // 2. 从请求头中获取 Authorization 令牌
        String authHeader = request.getHeaders().getFirst("Authorization");
        if (!StringUtils.hasText(authHeader) || !authHeader.startsWith("Bearer ")) {
            // 3. 无令牌或令牌格式错误，返回 401
            response.setStatusCode(HttpStatus.UNAUTHORIZED);
            return response.setComplete();
        }

        // 4. 提取令牌（去掉"Bearer "前缀）
        String token = authHeader.substring(7);
        if (!jwtUtil.validateToken(token)) {
            // 5. 令牌无效，返回 401
            response.setStatusCode(HttpStatus.UNAUTHORIZED);
            return response.setComplete();
        }

        // 6. 令牌有效，解析用户信息，添加到请求头（供微服务使用）
        try {
            String userId = jwtUtil.parseClaims(token).getSubject();
            String username = jwtUtil.parseClaims(token).get("username", String.class);
            // 向请求头添加用户信息（微服务可通过请求头获取，无需再次解析 JWT）
            ServerHttpRequest newRequest = request.mutate()
                    .header("X-User-Id", userId)
                    .header("X-User-Name", username)
                    .build();
            // 替换请求对象
            return chain.filter(exchange.mutate().request(newRequest).build());
        } catch (Exception e) {
            response.setStatusCode(HttpStatus.UNAUTHORIZED);
            return response.setComplete();
        }
    }

    // 过滤器优先级：值越小越先执行（认证过滤器需优先执行）
    @Override
    public int getOrder() {
        return -100;
    }
}

{"code":200,"msg":"登录成功","data":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."}

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.http.server.reactive.ServerHttpRequest;
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.util.UUID;

@Component
public class LogGlobalFilter implements GlobalFilter, Ordered {
    private static final Logger logger = LoggerFactory.getLogger(LogGlobalFilter.class);

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, org.springframework.cloud.gateway.filter.GatewayFilterChain chain) {
        // 1. 生成请求唯一 ID（用于追踪请求链路）
        String requestId = UUID.randomUUID().toString();
        ServerHttpRequest request = exchange.getRequest();
        ServerHttpResponse response = exchange.getResponse();

        // 2. pre 逻辑：记录请求信息
        long startTime = System.currentTimeMillis();
        String method = request.getMethodValue();
        String path = request.getPath().value();
        String clientIp = request.getRemoteAddress().getAddress().getHostAddress();
        logger.info("【请求开始】requestId: {}, 客户端 IP: {}, 方法：{}, 路径：{}, 请求头：{}", requestId, clientIp, method, path, request.getHeaders());

        // 3. 转发请求，监听响应完成事件
        return chain.filter(exchange).then(Mono.fromRunnable(() -> {
            // 4. post 逻辑：记录响应信息
            long duration = System.currentTimeMillis() - startTime;
            int statusCode = response.getStatusCode().value();
            logger.info("【请求结束】requestId: {}, 响应状态：{}, 耗时：{}ms", requestId, statusCode, duration);
        }));
    }

    // 日志过滤器优先级低于认证过滤器（先认证，再记录日志）
    @Override
    public int getOrder() {
        return -90;
    }
}

【请求开始】requestId: 550e8400-e29b-41d4-a716-446655440000, 客户端 IP: 127.0.0.1, 方法：GET, 路径：/api/user/1, 请求头：[Authorization:"Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...", X-Request-Id:"123456"] 【请求结束】requestId: 550e8400-e29b-41d4-a716-446655440000, 响应状态：200, 耗时：35ms

spring:
  cloud:
    gateway:
      globalcors:
        cors-configurations:
          '[/**]': # 对所有路径生效
            allowed-origins: "*" # 允许所有来源（生产环境建议指定具体域名，如 https://www.example.com）
            allowed-methods: "*" # 允许所有 HTTP 方法（GET、POST、PUT、DELETE 等）
            allowed-headers: "*" # 允许所有请求头
            allow-credentials: true # 允许携带 Cookie
            max-age: 3600 # 预检请求缓存时间（1 小时）

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
    <version>2021.0.4.0</version>
</dependency>

spring:
  application:
    name: gateway-service
  cloud:
    nacos:
      config:
        server-addr: localhost:8848 # Nacos 配置中心地址
        file-extension: yaml # 配置文件格式
        namespace: public # 命名空间
        group: DEFAULT_GROUP # 配置分组
        profiles:
          active: dev # 环境标识

spring:
  cloud:
    gateway:
      routes:
        - id: user-service-route
          uri: lb://user-service
          predicates:
            - Path=/api/user/**
          filters:
            - RewritePath=/api/user/(?<segment>.*), /${segment}
        - id: order-service-route
          uri: lb://order-service
          predicates:
            - Path=/api/order/**
          filters:
            - RewritePath=/api/order/(?<segment>.*), /${segment}

import com.alibaba.nacos.api.NacosFactory;
import com.alibaba.nacos.api.config.ConfigService;
import com.alibaba.nacos.api.config.listener.Listener;
import com.alibaba.nacos.api.exception.NacosException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.gateway.event.RefreshRoutesEvent;
import org.springframework.cloud.gateway.route.RouteDefinition;
import org.springframework.cloud.gateway.route.RouteDefinitionWriter;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;
import org.springframework.stereotype.Component;
import reactor.core.publisher.Mono;
import javax.annotation.PostConstruct;
import java.util.List;
import java.util.Properties;
import java.util.concurrent.Executor;

@Component
public class DynamicRouteConfig implements ApplicationEventPublisherAware {
    @Value("${spring.cloud.nacos.config.server-addr}")
    private String serverAddr;
    @Value("${spring.cloud.nacos.config.namespace}")
    private String namespace;
    @Value("${spring.cloud.nacos.config.group}")
    private String group;
    @Value("${spring.application.name}")
    private String serviceName;
    @Value("${spring.profiles.active}")
    private String activeProfile;

    // 路由定义写入器（用于更新路由）
    @Autowired
    private RouteDefinitionWriter routeDefinitionWriter;

    // 事件发布器（用于发布路由刷新事件）
    private ApplicationEventPublisher applicationEventPublisher;

    // Nacos 配置服务
    private ConfigService configService;

    // 配置 Data ID
    private String dataId;

    @PostConstruct
    public void init() throws NacosException {
        // 初始化 Data ID
        dataId = serviceName + "-" + activeProfile + ".yaml";
        // 初始化 Nacos ConfigService
        Properties properties = new Properties();
        properties.put("serverAddr", serverAddr);
        properties.put("namespace", namespace);
        configService = NacosFactory.createConfigService(properties);
        // 加载初始路由配置
        loadRouteConfig();
        // 注册 Nacos 配置监听器（监听配置变更）
        configService.addListener(dataId, group, new Listener() {
            @Override
            public void receiveConfigInfo(String configInfo) {
                // 配置变更时，重新加载路由
                loadRouteConfig();
            }

            @Override
            public Executor getExecutor() {
                return null;
            }
        });
    }

    // 加载路由配置（简化版：实际开发中需解析 YAML 为 RouteDefinition 列表）
    private void loadRouteConfig() {
        try {
            // 从 Nacos 获取配置
            String config = configService.getConfig(dataId, group, 5000);
            if (org.springframework.util.StringUtils.hasText(config)) {
                // 解析 YAML 配置为 RouteDefinition 列表（此处省略解析逻辑，推荐使用 SnakeYAML）
                // 假设解析后得到 List<RouteDefinition> routeDefinitionsList
                List<RouteDefinition> routeDefinitions = parseYamlToRouteDefinitions(config);
                // 1. 删除所有现有路由
                routeDefinitionWriter.delete(Mono.just("user-service-route")).subscribe();
                routeDefinitionWriter.delete(Mono.just("order-service-route")).subscribe();
                // 2. 添加新路由
                for (RouteDefinition routeDefinition : routeDefinitions) {
                    routeDefinitionWriter.save(Mono.just(routeDefinition)).subscribe();
                }
                // 3. 发布路由刷新事件
                applicationEventPublisher.publishEvent(new RefreshRoutesEvent(this));
                System.out.println("动态路由更新成功！");
            }
        } catch (Exception e) {
            System.err.println("动态路由更新失败：" + e.getMessage());
        }
    }

    // 解析 YAML 配置为 RouteDefinition 列表（实际开发中需实现）
    private List<RouteDefinition> parseYamlToRouteDefinitions(String config) {
        // 此处使用 Spring 的 YamlPropertiesFactoryBean 解析 YAML，转换为 RouteDefinition
        // 简化示例，实际需根据配置结构编写解析逻辑
        return null;
    }

    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
        this.applicationEventPublisher = applicationEventPublisher;
    }
}

- id: product-service-route
  uri: lb://product-service
  predicates:
    - Path=/api/product/**
  filters:
    - RewritePath=/api/product/(?<segment>.*), /${segment}

<!-- Sentinel 核心依赖 -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
    <version>2021.0.4.0</version>
</dependency>
<!-- Sentinel 与 Gateway 整合依赖 -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-alibaba-sentinel-gateway</artifactId>
    <version>2021.0.4.0</version>
</dependency>
<!-- Sentinel 控制台通信依赖 -->
<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-transport-simple-http</artifactId>
    <version>1.8.6</version>
</dependency>

spring:
  cloud:
    sentinel:
      transport:
        dashboard: localhost:8080 # Sentinel 控制台地址（注意：与网关端口冲突时需修改 Sentinel 端口）
        port: 8720 # 与 Sentinel 控制台通信的端口（默认 8719，避免冲突）
      # 网关限流配置
      scg:
        fallback:
          mode: response # 降级模式：返回自定义响应
          response-status: 429 # 降级响应状态码
          response-body: '{"code":429,"msg":"当前请求过于频繁，请稍后再试！"}' # 降级响应体

java -jar sentinel-dashboard-1.8.6.jar --server.port=8083

{"code":429,"msg":"当前请求过于频繁，请稍后再试！"}

@GetMapping("/user/{id}")
public User getUserById(@PathVariable Long id) throws InterruptedException {
    Thread.sleep(2000); // 模拟慢调用
    // 其余逻辑不变
}

客户端 → Nginx（负载均衡） → 网关实例 1（8080） → 微服务集群
                      → 网关实例 2（8081） → 微服务集群
                      → 网关实例 3（8082） → 微服务集群

http {
    # 网关集群配置
    upstream gateway_cluster {
        server 127.0.0.1:8080 weight=1; # 权重 1
        server 127.0.0.1:8081 weight=1; # 权重 1
        server 127.0.0.1:8082 weight=1; # 权重 1
    }
    server {
        listen 80; # Nginx 监听 80 端口（客户端统一访问 80 端口）
        server_name localhost;
        location / {
            # 转发请求到网关集群
            proxy_pass http://gateway_cluster;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
        }
    }
}

spring:
  cloud:
    gateway:
      httpclient:
        pool:
          max-idle-time: 60000 # 连接池最大空闲时间（60 秒）
          max-connections: 1000 # 每个路由的最大连接数
        response-timeout: 5000 # 响应超时时间（5 秒）

server:
  http2:
    enabled: true # 启用 HTTP/2

logging:
  level:
    org.springframework.cloud.gateway: DEBUG
    org.springframework.http.server.reactive: DEBUG
    reactor.netty: DEBUG

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

management:
  endpoints:
    web:
      exposure:
        include: gateway, health, info # 暴露 gateway 监控端点
  endpoint:
    gateway:
      enabled: true # 启用网关监控

常见问题	解决方案
路由匹配失败（404）	1. 检查路由 Path 断言是否正确； 2. 检查微服务是否已注册到 Nacos； 3. 开启 `discovery.locator.enabled=true`，测试服务名路由
跨域请求失败（CORS）	检查网关全局 CORS 配置，确保 `allowed-origins`、`allowed-methods` 配置正确
认证失败（401）	1. 检查 JWT 令牌是否有效； 2. 检查请求头 `Authorization` 格式是否正确（Bearer + 空格 + 令牌）； 3. 检查白名单配置是否包含当前路径
限流熔断不生效	1. 检查 Sentinel 依赖是否完整； 2. 确认已访问网关接口触发 Sentinel 监控； 3. 检查 Sentinel 控制台规则配置是否正确
网关响应缓慢	1. 排查后端微服务响应时间； 2. 检查过滤器链是否过长； 3. 调整 Netty 连接池参数

微服务网关设计与实战：Spring Cloud Gateway 全解析

微服务网关设计与实战：Spring Cloud Gateway 全解析

学习目标与重点

学习目标

学习重点

微服务网关核心概念与技术选型

微服务网关的核心价值

主流微服务网关技术对比

Spring Cloud Gateway 核心架构

核心组件详解

Spring Cloud Gateway 环境搭建与基础路由配置

环境准备

技术栈选型

项目初始化

基础路由测试

启动依赖服务

测试路由转发

核心断言工厂实战

常用断言工厂示例

断言测试

自定义断言工厂（可选）

过滤器开发实战：全局功能与局部定制

过滤器分类与执行顺序

过滤器执行顺序

局部过滤器实战：路径重写与参数处理

路径重写（RewritePath）

添加请求头（AddRequestHeader）

添加请求参数（AddRequestParameter）

自定义局部过滤器

全局过滤器实战：统一认证与日志收集

统一认证过滤器（JWT 令牌校验）

全局日志过滤器

跨域处理（CORS）

网关高级功能：动态路由、限流熔断与高可用

动态路由（基于 Nacos 配置）

集成 Nacos Config

实现动态路由刷新

测试动态路由

网关限流与熔断（整合 Sentinel）

集成 Sentinel 依赖

配置 Sentinel

配置网关限流规则（Sentinel 控制台）

测试限流效果

配置网关熔断规则

网关高可用部署

高可用架构图

部署步骤

网关性能优化与故障排查

性能优化方案

基础优化

缓存优化

限流优化

故障排查方法

日志排查

监控排查

常见问题与解决方案

本章总结

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具