【Spring Cloud】Spring Cloud Gateway 网关介绍

最新推荐文章于 2024-09-11 18:34:41 发布

cangloe

最新推荐文章于 2024-09-11 18:34:41 发布

阅读量1k

点赞数 17

分类专栏： java 文章标签： spring cloud spring 后端 java spring boot

本文链接：https://blog.csdn.net/u013675821/article/details/140869874

版权

java 专栏收录该内容

36 篇文章 2 订阅

订阅专栏

Spring Cloud Gateway 介绍

Spring Cloud Gateway 是 Spring Cloud 生态系统中的官方 API 网关解决方案。它构建在 Spring Framework 5、Spring Boot 3 和 Project Reactor 之上，旨在为现代微服务架构提供动态路由、监控、弹性、请求限流、路径重写、过滤等功能。Spring Cloud Gateway 是为了替代 Zuul 的下一个代替方案，具备非阻塞、异步的特性，能够处理高并发的请求。

一、API 网关的基本概念

API 网关在微服务架构中扮演着重要角色，主要功能包括：

请求路由：将外部请求路由到后端的具体服务。
负载均衡：分发流量至多个服务实例。
安全认证：保护 API 免受未经授权的访问。
限流：控制对服务的访问速率，避免服务过载。
监控和日志：记录请求的详细信息，便于后续分析。

Spring Cloud Gateway 提供了一个灵活的网关解决方案，允许开发者通过简单的配置实现上述功能。

二、Spring Cloud Gateway 的优势

Spring Cloud Gateway 作为 Spring 生态系统的一部分，与其他组件无缝集成，具备以下几个优点：

反应式编程模型：基于 Spring WebFlux 和 Project Reactor，采用响应式编程模式，支持异步非阻塞的请求处理，提高了系统的吞吐量。
简单易用：通过 Java 和 YAML 配置，Spring Cloud Gateway 可以快速配置和启动。
丰富的内置功能：包括路径重写、请求限流、熔断、重试、负载均衡、全局和局部过滤器等。
高度可扩展性：允许开发者自定义断言和过滤器，满足特定的业务需求。
与 Spring Security 集成：提供了安全认证和授权的能力。
兼容 WebSocket：支持 WebSocket 协议，适用于实时通信场景。

三、Spring Cloud Gateway 的核心概念

Spring Cloud Gateway 的工作机制依赖于三个核心概念：路由（Route）、断言（Predicate）、过滤器（Filter）。

1. 路由（Route）

路由是网关的基本构建块，每个路由定义了一个断言和一组过滤器。当请求满足断言条件时，路由将请求转发到指定的 URI。

ID：路由的唯一标识符。
URI：目标服务的地址。
Predicates：断言，用于匹配请求的条件。
Filters：过滤器，对请求和响应进行处理。

示例：

spring:
  cloud:
    gateway:
      routes:
        - id: service_route
          uri: http://localhost:8081
          predicates:
            - Path=/service/**
          filters:
            - StripPrefix=1

在上述配置中，当请求路径以 /service/ 开头时，将请求转发到 http://localhost:8081，并移除路径前缀 /service/。

2. 断言（Predicate）

断言用于判断请求是否与路由匹配，Spring Cloud Gateway 提供了一系列内置的断言工厂：

Path：基于请求路径的匹配。
Host：基于请求主机名的匹配。
Method：基于 HTTP 方法的匹配。
Header：基于请求头的匹配。
Query：基于请求参数的匹配。
Cookie：基于请求 Cookie 的匹配。

示例：

predicates:
  - Path=/service/**
  - Method=GET
  - Header=X-Request-Id, \d+

上述断言示例要求请求路径匹配 /service/**，方法为 GET，并且请求头 X-Request-Id 为数字。

3. 过滤器（Filter）

过滤器用于对请求和响应进行加工处理，如添加、移除请求头，重写路径，限流等。

内置过滤器：

AddRequestHeader：添加请求头。
AddResponseHeader：添加响应头。
RewritePath：重写请求路径。
StripPrefix：移除路径前缀。
RequestRateLimiter：请求限流。
CircuitBreaker：熔断器。

示例：

filters:
  - AddRequestHeader=X-Example, Value
  - RewritePath=/api/(?<segment>.*), /$\\{segment}
  - RequestRateLimiter=1, 5

在上述示例中，过滤器会为请求添加请求头 X-Example，重写路径，并限制请求速率为每秒 1 个，突发容量为 5。

4. 全局过滤器（Global Filter）

全局过滤器适用于所有路由，通常用于实现通用功能，如请求日志、全局认证、全局限流等。全局过滤器可以通过实现 GlobalFilter 接口并注入 Spring 容器来创建。

import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;
import reactor.core.publisher.Mono;

@Component
public class CustomGlobalFilter implements GlobalFilter, Ordered {

    @Override
    public Mono<Void> filter(org.springframework.web.server.ServerWebExchange exchange, GatewayFilterChain chain) {
        System.out.println("Global filter applied");
        return chain.filter(exchange);
    }

    @Override
    public int getOrder() {
        return -1; // Order of execution
    }
}

5. 自定义过滤器

Spring Cloud Gateway 允许开发者自定义过滤器，以实现特殊的业务需求。自定义过滤器可以分为两类：全局过滤器和局部过滤器。全局过滤器适用于所有路由，而局部过滤器仅适用于特定路由。

全局过滤器示例

通过实现 GlobalFilter 接口可以创建全局过滤器：

import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;
import reactor.core.publisher.Mono;

@Component
public class CustomGlobalFilter implements GlobalFilter, Ordered {

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        System.out.println("Custom global filter executed");
        return chain.filter(exchange);
    }

    @Override
    public int getOrder() {
        return Ordered.HIGHEST_PRECEDENCE; // 执行顺序
    }
}

局部过滤器示例

通过实现 GatewayFilter 接口可以创建局部过滤器：

import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;
import org.springframework.stereotype.Component;
import reactor.core.publisher.Mono;

@Component
public class CustomGatewayFilterFactory extends AbstractGatewayFilterFactory<CustomGatewayFilterFactory.Config> {

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

    @Override
    public GatewayFilter apply(Config config) {
        return (exchange, chain) -> {
            System.out.println("Custom gateway filter applied");
            return chain.filter(exchange).then(Mono.fromRunnable(() -> {
                // Post-processing logic
            }));
        };
    }

    public static class Config {
        // Configuration properties
    }
}

在 application.yml 中使用自定义过滤器：

spring:
  cloud:
    gateway:
      routes:
        - id: custom_route
          uri: http://example.com
          predicates:
            - Path=/custom/**
          filters:
            - CustomGatewayFilterFactory # 使用自定义过滤器

四、Spring Cloud Gateway 的功能特性

Spring Cloud Gateway 提供了多种强大的功能特性，帮助开发者构建功能全面的 API 网关。

1. 动态路由

Spring Cloud Gateway 支持动态路由，可以根据请求的路径、方法、头信息、参数等进行路由转发。

示例：

spring:
  cloud:
    gateway:
      routes:
        - id: route1
          uri: http://service1
          predicates:
            - Path=/service1/**
        - id: route2
          uri: http://service2
          predicates:
            - Method=GET

2. 负载均衡

Spring Cloud Gateway 可以与 Spring Cloud LoadBalancer 集成，实现请求的负载均衡。通过 Ribbon 或其他负载均衡器，可以将请求分发到多个实例上。

3. 安全性

Spring Cloud Gateway 支持与 Spring Security 集成，实现认证和授权功能。通过 OAuth2、JWT 等安全协议，可以保护 API 的访问安全。

示例：

import org.springframework.context.annotation.Bean;
import org.springframework.security.config.annotation.web.reactive.EnableWebFluxSecurity;
import org.springframework.security.config.web.server.ServerHttpSecurity;
import org.springframework.security.web.server.SecurityWebFilterChain;

@EnableWebFluxSecurity
public class SecurityConfig {

    @Bean
    public SecurityWebFilterChain securityWebFilterChain(Server

HttpSecurity http) {
        return http.authorizeExchange()
                .pathMatchers("/public/**").permitAll()
                .anyExchange().authenticated()
                .and().build();
    }
}

4. 限流

Spring Cloud Gateway 提供了基于 Redis 的限流过滤器，可以控制请求的速率和并发数，防止服务过载。

示例：

filters:
  - name: RequestRateLimiter
    args:
      redis-rate-limiter.replenishRate: 10
      redis-rate-limiter.burstCapacity: 20

在上面的配置中，限流过滤器将请求速率限制为每秒 10 个请求，突发容量为 20 个请求。

5. 请求重试

Spring Cloud Gateway 支持请求重试功能，可以在请求失败时进行重试，提高系统的稳定性。

示例：

filters:
  - name: Retry
    args:
      retries: 3
      statuses: BAD_GATEWAY

在上面的示例中，当请求返回 BAD_GATEWAY 状态时，网关将重试请求最多 3 次。

6. 熔断器

Spring Cloud Gateway 可以与 Resilience4j 等熔断器集成，实现服务的熔断和降级功能，增强系统的容错能力。

示例：

filters:
  - name: CircuitBreaker
    args:
      name: myCircuitBreaker
      fallbackUri: forward:/fallback

在上面的配置中，当服务异常时，熔断器会将请求转发到 /fallback 进行降级处理。

7. 日志与监控

Spring Cloud Gateway 提供了请求日志和监控功能，可以记录请求的详细信息，并与 Spring Boot Admin、Micrometer 等工具集成，实现系统的全面监控。

示例：

import org.springframework.context.annotation.Bean;
import org.springframework.web.server.WebFilter;

@Bean
public WebFilter loggingFilter() {
    return (exchange, chain) -> {
        System.out.println("Request: " + exchange.getRequest().getPath());
        return chain.filter(exchange);
    };
}

通过上述配置，Spring Cloud Gateway 将在处理请求时打印请求路径信息。

五、Spring Cloud Gateway 使用示例

下面是一个完整的 Spring Cloud Gateway 示例，展示如何在 Spring Boot 项目中集成和使用 Spring Cloud Gateway。

1. 创建 Spring Boot 项目

使用 Spring Initializr 创建一个新的 Spring Boot 项目，并添加以下依赖：

Spring Cloud Gateway
Spring Boot WebFlux
Spring Boot Actuator
Spring Boot Starter Security（可选，用于安全性示例）

pom.xml 示例：

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/POM/4.0.0">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>gateway-demo</artifactId>
    <version>1.0.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.2.5</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <java.version>17</java.version>
        <spring-cloud.version>2022.0.4</spring-cloud.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <!-- Spring Cloud Gateway -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway</artifactId>
        </dependency>

        <!-- Spring Boot WebFlux -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webflux</artifactId>
        </dependency>

        <!-- Spring Boot Actuator -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

        <!-- Spring Boot Starter Security -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>${project.parent.version}</version>
            </plugin>
        </plugins>
    </build>

</project>

2. 创建主应用类

创建 GatewayDemoApplication.java 文件：

package com.example.gatewaydemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class GatewayDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(GatewayDemoApplication.class, args);
    }
}

3. 配置文件

在 src/main/resources 目录下创建 application.yml 文件，配置路由、过滤器和安全性：

server:
  port: 8080

spring:
  application:
    name: gateway-demo

  cloud:
    gateway:
      routes:
        - id: service1_route
          uri: http://localhost:8081 # 转发到服务1
          predicates:
            - Path=/service1/**
          filters:
            - StripPrefix=1 # 移除路径前缀

        - id: service2_route
          uri: http://localhost:8082 # 转发到服务2
          predicates:
            - Path=/service2/**
          filters:
            - StripPrefix=1
            - AddRequestHeader=X-Gateway, Demo

      default-filters:
        - name: AddResponseHeader # 默认过滤器
          args:
            X-Response-Default: Gateway

management:
  endpoints:
    web:
      exposure:
        include: "*"

# Spring Security 配置
spring:
  security:
    user:
      name: user
      password: password

在上述配置中，我们定义了两个路由规则：

请求路径以 /service1/ 开头的请求，将转发到 http://localhost:8081，并移除路径前缀 /service1/。
请求路径以 /service2/ 开头的请求，将转发到 http://localhost:8082，并移除路径前缀 /service2/，同时添加请求头 X-Gateway: Demo。

此外，我们还配置了一个默认过滤器 AddResponseHeader，为所有响应添加 X-Response-Default: Gateway 响应头。

4. 启动示例服务

为了测试网关的路由功能，创建两个简单的 Spring Boot 服务：

Service1：

package com.example.service1;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class Service1Application {

    public static void main(String[] args) {
        SpringApplication.run(Service1Application.class, args);
    }

    @GetMapping("/hello")
    public String hello() {
        return "Hello from Service 1!";
    }
}

Service2：

package com.example.service2;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class Service2Application {

    public static void main(String[] args) {
        SpringApplication.run(Service2Application.class, args);
    }

    @GetMapping("/hello")
    public String hello() {
        return "Hello from Service 2!";
    }
}

将 Service1 运行在端口 8081，Service2 运行在端口 8082。

5. 访问网关

启动 GatewayDemoApplication，访问以下 URL 验证网关的路由和过滤器功能：

响应：

Hello from Service 1!
Hello from Service 2!

通过 Spring Cloud Gateway，客户端可以透明地访问后端服务，而无需直接与服务通信。网关处理请求路由、负载均衡、安全性等功能，简化了客户端的复杂性。

六、Spring Cloud Gateway 的最佳实践

在使用 Spring Cloud Gateway 时，遵循以下最佳实践可以提高网关的性能和可维护性：

1. 路由管理

使用配置中心**：将路由配置存储在配置中心（如 Spring Cloud Config、Nacos）中，实现动态更新。

命名约定：为路由 ID、URI、过滤器命名时使用统一的命名约定，提高可读性。

2. 过滤器管理

自定义过滤器：根据业务需求自定义过滤器，实现个性化的请求处理逻辑。
过滤器顺序：合理设置过滤器的执行顺序，确保逻辑正确。

3. 性能优化

使用缓存：使用缓存（如 Redis）减少请求的重复处理，提高性能。
限流与熔断：合理配置限流和熔断策略，防止服务过载。

4. 安全性

认证与授权：使用 Spring Security 实现认证和授权，保护 API 的安全。
数据加密：对敏感数据进行加密传输，防止数据泄露。

5. 监控与日志

请求日志：记录请求的详细信息，便于问题排查和分析。
监控工具：与监控工具（如 Prometheus、Grafana）集成，实时监控系统的健康状态。

七、Spring Cloud Gateway 的未来发展

Spring Cloud Gateway 是一个不断演进的项目，随着 Spring 生态的不断发展，Spring Cloud Gateway 也将引入更多的新特性和改进：

增强的可观测性：提供更多的监控指标和可视化工具，增强系统的可观测性。
更丰富的协议支持：支持更多的协议类型，如 gRPC、GraphQL。
更强的扩展能力：提供更灵活的扩展机制，支持多种自定义需求。

Spring Cloud Gateway 是构建现代微服务架构的理想选择，它提供了丰富的功能和强大的扩展性，帮助开发者轻松构建高性能的 API 网关。

八、总结

Spring Cloud Gateway 是 Spring Cloud 生态中的重要组件，提供了路由、过滤、负载均衡、安全性、限流等丰富的功能特性。通过 Spring Cloud Gateway，开发者可以轻松构建功能全面的 API 网关，简化客户端与微服务之间的交互。

在现代微服务架构中，Spring Cloud Gateway 扮演着重要的角色，帮助开发者管理和控制请求的流量，提高系统的稳定性和安全性。在未来的发展中，Spring Cloud Gateway 将继续增强其功能特性，满足不断变化的业务需求。

cangloe

关注

17
点赞
踩
13

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录