SpringCloud Zuul和Gateway的实例代码(搭建方式)_Java

一、 spring cloud zuul和spring cloud gateway是什么

spring cloud zuul和spring cloud gateway都是spring cloud框架提供的用于构建微服务架构中的api网关的组件。

spring cloud zuul：spring cloud zuul是基于netflix zuul构建的微服务网关组件。它提供了路由、负载均衡、容错、安全性等功能。zuul使用同步阻塞模型，适用于较小规模的微服务架构。然而，需要注意的是，spring cloud zuul目前已经进入维护模式，spring cloud官方推荐使用spring cloud gateway作为替代方案。
spring cloud gateway：spring cloud gateway是spring cloud官方推荐的api网关解决方案。它基于spring framework 5和project reactor构建，并采用异步非阻塞模型，具有更高的性能和吞吐量。spring cloud gateway提供了动态路由、过滤器链、集成服务发现、断路器等功能特性，同时支持java和函数式编程的api，具有更高级的定制和扩展能力。

这两个组件都可以用于构建微服务架构中的api网关，它们的选择取决于具体的需求和场景。

如果需要更高的性能、更灵活的定制能力以及与spring生态系统更好的集成，推荐使用spring cloud gateway。

如果已经在使用netflix的生态系统组件，并且对性能要求不是特别高，可以考虑使用spring cloud zuul。

二、spring cloud zuul的简单示例

创建一个spring boot项目并添加依赖：在你的项目中创建一个新的spring boot应用程序，并添加以下依赖。如果你使用的是maven，可以在pom.xml文件中添加以下依赖：

<dependencies>
    <dependency>
        <groupid>org.springframework.cloud</groupid>
        <artifactid>spring-cloud-starter-netflix-zuul</artifactid>
    </dependency>
</dependencies>

启用zuul网关：在你的spring boot应用程序的主类上添加@enablezuulproxy注解，以启用zuul网关。例如：

import org.springframework.boot.springapplication;
import org.springframework.boot.autoconfigure.springbootapplication;
import org.springframework.cloud.netflix.zuul.enablezuulproxy;

@springbootapplication
@enablezuulproxy
public class yourapplication {

    public static void main(string[] args) {
        springapplication.run(yourapplication.class, args);
    }
}

配置zuul路由规则：在application.properties或application.yml文件中配置zuul的路由规则。例如，以下是一个将/api/**路径下的请求转发到http://example.com/api/**的示例配置：

zuul:
  routes:
    example-service:
      path: /api/**
      url: http://example.com/api

在上面的示例中，example-service是一个自定义的路由名称，path指定了匹配的路径模式，url指定了要转发到的目标url。

运行应用程序并访问zuul网关：启动你的应用程序，并使用zuul网关转发请求。例如，如果你的应用程序运行在http://localhost:8080，你可以发送一个请求到http://localhost:8080/api/example，该请求将被zuul网关转发到http://example.com/api/example。

这就是一个使用zuul网关的简单示例。

通过配置不同的路由规则，你可以实现请求的转发、负载均衡、路由过滤等功能。

你还可以添加自定义的过滤器来对请求和响应进行处理。

请注意，zuul目前已被spring cloud宣布为不推荐使用，建议使用spring cloud gateway作为替代方案。

三、spring cloud gateway(推荐使用)的简单示例

创建一个spring boot项目并添加依赖：在你的项目中创建一个新的spring boot应用程序，并添加以下依赖。如果你使用的是maven，可以在pom.xml文件中添加以下依赖：

<dependencies>
    <dependency>
        <groupid>org.springframework.cloud</groupid>
        <artifactid>spring-cloud-starter-gateway</artifactid>
    </dependency>
</dependencies>

配置spring cloud gateway路由规则：在application.properties或application.yml文件中配置spring cloud gateway的路由规则。例如，以下是一个将/api/**路径下的请求转发到http://example.com/api/**的示例配置：

spring:
  cloud:
    gateway:
      routes:
        - id: example-service
          uri: http://example.com/api
          predicates:
            - path=/api/**

在上面的示例中，example-service是一个自定义的路由id，uri指定了要转发到的目标url，predicates指定了匹配的路径模式。

运行应用程序并访问spring cloud gateway：启动你的应用程序，并使用spring cloud gateway转发请求。例如，如果你的应用程序运行在http://localhost:8080，你可以发送一个请求到http://localhost:8080/api/example，该请求将被spring cloud gateway转发到http://example.com/api/example。
添加自定义过滤器（可选）：你可以添加自定义的过滤器来对请求和响应进行处理。例如，你可以创建一个实现globalfilter接口的自定义过滤器类，并在应用程序中进行注册。过滤器可以用于鉴权、日志记录、请求转换等操作。运行应用程序并访问zuul网关：启动你的应用程序，并使用zuul网关转发请求。例如，如果你的应用程序运行在http://localhost:8080，你可以发送一个请求到http://localhost:8080/api/example，该请求将被zuul网关转发到http://example.com/api/example。

import org.springframework.cloud.gateway.filter.gatewayfilterchain;
import org.springframework.cloud.gateway.filter.globalfilter;
import org.springframework.core.ordered;
import org.springframework.http.httpstatus;
import org.springframework.stereotype.component;
import org.springframework.web.server.serverwebexchange;
import reactor.core.publisher.mono;

@component
public class customfilter implements globalfilter, ordered {

    @override
    public mono<void> filter(serverwebexchange exchange, gatewayfilterchain chain) {
        // 在这里编写你的过滤器逻辑
        // 可以通过exchange对象获取请求和响应信息，并进行相关处理

        // 示例：检查请求头中是否包含特定的认证信息
        string authheader = exchange.getrequest().getheaders().getfirst("authorization");
        if (authheader == null || authheader.isempty()) {
            exchange.getresponse().setstatuscode(httpstatus.unauthorized);
            return exchange.getresponse().setcomplete();
        }

        // 继续执行后续的过滤器和路由处理
        return chain.filter(exchange);
    }

    @override
    public int getorder() {
        // 设置过滤器的执行顺序
        return ordered.highest_precedence;
    }
}

在上面的示例中，customfilter是一个自定义的过滤器类，实现了globalfilter接口和ordered接口。你可以在filter方法中编写自己的过滤器逻辑，并在getorder方法中设置过滤器的执行顺序。

这就是一个使用spring cloud gateway的简单示例。通过配置路由规则和添加自定义过滤器，你可以实现请求的转发、负载均衡、路由过滤等功能。spring cloud gateway还提供了许多其他功能，如断路器、限流、重试等，你可以根据具体需求进行配置和使用。

四、spring cloud gateway负载均衡的简单示例

在spring cloud gateway中，你可以使用loadbalancerclient或discoveryclient来实现负载均衡。下面是一个使用loadbalancerclient实现负载均衡的示例：

添加依赖：在你的spring boot项目中添加以下依赖。如果你使用的是maven，可以在pom.xml文件中添加以下依赖：

<dependencies>
    <dependency>
        <groupid>org.springframework.cloud</groupid>
        <artifactid>spring-cloud-starter-gateway</artifactid>
    </dependency>
    <dependency>
        <groupid>org.springframework.cloud</groupid>
        <artifactid>spring-cloud-starter-loadbalancer</artifactid>
    </dependency>
</dependencies>

配置路由规则：在application.properties或application.yml文件中配置spring cloud gateway的路由规则，指定负载均衡的目标服务。例如：

spring:
 cloud:
   gateway:
     routes:
       - id: example-service
         uri: lb://example-service
         predicates:
           - path=/api/**

在上面的示例中，example-service是一个服务的名称，lb://example-service表示通过负载均衡调用example-service服务。

创建一个自定义的loadbalancerclient配置类：创建一个自定义的loadbalancerclient配置类，用于配置负载均衡的策略。例如：

import org.springframework.cloud.client.loadbalancer.loadbalancerclient;
import org.springframework.cloud.gateway.config.gatewayloadbalancerproperties;
import org.springframework.cloud.gateway.filter.loadbalancerclientfilter;
import org.springframework.cloud.gateway.support.serverwebexchangeutils;
import org.springframework.context.annotation.bean;
import org.springframework.context.annotation.configuration;

@configuration
public class loadbalancerconfig {

    @bean
    public loadbalancerclientfilter loadbalancerclientfilter(loadbalancerclient loadbalancerclient,
                                                             gatewayloadbalancerproperties loadbalancerproperties) {
        return new loadbalancerclientfilter(loadbalancerclient, loadbalancerproperties);
    }

    @bean
    public loadbalancerclient loadbalancerclient() {
        return new myloadbalancerclient();
    }

    private static class myloadbalancerclient implements loadbalancerclient {

        @override
        public <t> t execute(string serviceid, loadbalancerrequest<t> request) {
            // 在这里实现你的负载均衡逻辑
            // 可以使用负载均衡算法选择目标服务的实例
            // 这里的示例代码直接返回了固定的目标服务实例
            serviceinstance serviceinstance = new defaultserviceinstance(serviceid, "example-host", 8080, false);
            return request.apply(serviceinstance);
        }

        @override
        public <t> t execute(string serviceid, serviceinstance serviceinstance, loadbalancerrequest<t> request) {
            return request.apply(serviceinstance);
        }

        @override
        public uri reconstructuri(serviceinstance instance, uri original) {
            return instance.geturi();
        }

        @override
        public serviceinstance choose(string serviceid) {
            // 在这里实现你的负载均衡逻辑
            // 可以使用负载均衡算法选择目标服务的实例
            // 这里的示例代码直接返回了固定的目标服务实例
            return new defaultserviceinstance(serviceid, "example-host", 8080, false);
        }
    }
}

在上面的示例中，myloadbalancerclient是一个自定义的loadbalancerclient实现，你可以在其中实现自己的负载均衡逻辑。示例代码中直接返回了固定的目标服务实例，你可以根据实际需求选择合适的负载均衡算法。