SpringCloud 核心组件解析之服务网关

          ┌──────────┐
访客 ───→ │ 小区门卫  │ ───→ 各栋楼（微服务）
          │          │
          │ 职责：    │
          │ ① 查身份 │ ← 鉴权/认证
          │ ② 指路    │ ← 路由转发
          │ ③ 登记    │ ← 日志/监控
          │ ④ 限流    │ ← 防止太多人同时涌入
          └──────────┘

没有网关：用户 → http://192.168.1.10:8001/pay/get/1  ❌ 暴露内部 IP
有了网关：用户 → http://gateway.company.com/pay/get/1   ✅ 统一入口
                   │
                   ▼
               Gateway :9527 → Provider :8001/:8002

用户 → Nginx(SSL终结/静态资源) → Gateway(动态路由/鉴权) → 微服务

Route（路由）
  ├── id：唯一标识
  ├── uri：目标地址（lb://服务名）
  ├── predicates：断言（匹配规则）
  └── filters：过滤器（请求修改）

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-consul-discovery</artifactId>
</dependency>

server:
  port: 9527
spring:
  application:
    name: cloud-gateway
  cloud:
    consul:
      host: localhost
      port: 8500
      discovery:
        prefer-ip-address: true
        service-name: ${spring.application.name}
    gateway:
      routes:
        # 路由1：基础路由 + 自定义断言
        - id: pay_routh1
          uri: lb://cloud-payment-service
          predicates:
            - Path=/pay/gateway/get/**
            - MyRoutePredicatedFactory="3"
        # 路由2：另一个路径
        - id: pay_routh2
          uri: lb://cloud-payment-service
          predicates:
            - Path=/pay/gateway/info/**
        # 路由3：带过滤器
        - id: pay_routh3
          uri: lb://cloud-payment-service
          predicates:
            - Path=/pay/gateway/filter/**
          filters:
            - My=atguigu

// cloud-gateway-9527/.../mygateway/MyRoutePredicatedFactory.java
@Component
public class MyRoutePredicatedFactory
        extends AbstractRoutePredicateFactory<MyRoutePredicatedFactory.Config> {
    public MyRoutePredicatedFactory() {
        super(Config.class);
    }
    @Override
    public Predicate<ServerWebExchange> apply(Config config) {
        return exchange -> {
            String usertype = exchange.getRequest()
                .getQueryParams().getFirst("userType");
            return "3".equals(usertype);  // 只有三级会员能访问
        };
    }
    @Validated
    public static class Config {
        @Getter @Setter @NotEmpty
        private String usertype;
    }
    @Override
    public List<String> shortcutFieldOrder() {
        return Collections.singletonList("userType");
    }
}

// cloud-gateway-9527/.../mygateway/MyGatewayFilterFactory.java
@Component
public class MyGatewayFilterFactory
        extends AbstractGatewayFilterFactory<MyGatewayFilterFactory.Config> {
    public MyGatewayFilterFactory() { super(Config.class); }
    @Override
    public GatewayFilter apply(Config config) {
        return (exchange, chain) -> {
            // 请求必须包含参数 atguigu
            if (exchange.getRequest().getQueryParams().containsKey("atguigu")) {
                return chain.filter(exchange);  // ✅ 放行
            } else {
                exchange.getResponse().setStatusCode(HttpStatus.BAD_REQUEST);
                return exchange.getResponse().setComplete();  // ❌ 拦截
            }
        };
    }
    public static class Config {
        @Setter @Getter
        private String status;
    }
    @Override
    public List<String> shortcutFieldOrder() {
        return Arrays.asList("status");
    }
}

// cloud-gateway-9527/.../mygateway/MyGlobalFilter.java
@Component
@Slf4j
public class MyGlobalFilter implements GlobalFilter, Ordered {
    private static final String BEGIN_VISIT_TIME = "begin_visit_time";
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // Pre-filter：记录进入时间
        exchange.getAttributes().put(BEGIN_VISIT_TIME, System.currentTimeMillis());
        // Post-filter：打印日志
        return chain.filter(exchange).then(Mono.fromRunnable(() -> {
            Long beginTime = exchange.getAttribute(BEGIN_VISIT_TIME);
            if (beginTime != null) {
                log.info("访问接口: {}:{}{}  参数: {}  耗时: {}ms",
                    exchange.getRequest().getURI().getHost(),
                    exchange.getRequest().getURI().getPort(),
                    exchange.getRequest().getURI().getPath(),
                    exchange.getRequest().getURI().getRawQuery(),
                    System.currentTimeMillis() - beginTime);
            }
        }));
    }
    @Override
    public int getOrder() { return 0; }
}

请求 → [Pre Filter: 鉴权/日志] → 业务处理 → [Post Filter: 修改响应/记日志] → 响应

// cloud-provider-payment8001/.../controller/PayGateWayController.java
@RestController
public class PayGateWayController {
    @Resource
    private PayService payService;
    @GetMapping("/pay/gateway/get/{id}")
    public ResultData<Pay> getById(@PathVariable("id") Integer id) {
        return ResultData.success(payService.getById(id));
    }
    @GetMapping("/pay/gateway/get/info")
    public ResultData<String> getInfo() {
        return ResultData.success("gateway info test " + IdUtil.simpleUUID());
    }
    // 测试过滤器效果
    @GetMapping("/pay/gateway/filter")
    public ResultData<String> getFilter(HttpServletRequest request) {
        String result = "";
        Enumeration<String> names = request.getHeaderNames();
        while (names.hasMoreElements()) {
            String name = names.nextElement();
            String value = request.getHeader(name);
            if (name.equalsIgnoreCase("X-Request-atguigu1")
                || name.equalsIgnoreCase("X-Request-atguigu2")) {
                result += name + "\t" + value + " ";
            }
        }
        return ResultData.success("gateWayFilter 过滤器test：" + result
            + "\t" + DateUtil.now());
    }
}

┌──────────────────────────────────────────┐
│           Spring Cloud Gateway            │
│  ┌─────────────────────────────────────┐ │
│  │     RoutePredicateHandlerMapping    │ │ ← 匹配路由（遍历所有路由规则）
│  └──────────────┬──────────────────────┘ │
│                 ▼                         │
│  ┌─────────────────────────────────────┐ │
│  │     FilteringWebHandler             │ │ ← 执行过滤器链
│  │     (Pre Filter → Proxy → Post)     │ │
│  └──────────────┬──────────────────────┘ │
│                 ▼                         │
│  ┌─────────────────────────────────────┐ │
│  │     NettyRoutingFilter              │ │ ← 基于 Netty 异步非阻塞
│  └─────────────────────────────────────┘ │
└──────────────────────────────────────────┘

- id: service_v1
  uri: lb://service
  predicates: [Path=/api/**, Weight=group1, 80]  # 80% 流量
- id: service_v2
  uri: lb://service-v2
  predicates: [Path=/api/**, Weight=group1, 20]  # 20% 流量