网关分类与开放API

开放API (OpenAPI)

企业需要将自身数据、能力等作为开发平台向外开放，通常会以REST的方式向外提供，最好的例子就是淘宝开放平台、腾讯公司的QQ开发平台、微信开放平台。开放API平台必然涉及到客户应用的接入、API权限的管理、调用次数管理等，必然会有一个统一的入口进行管理，这正是API网关可以发挥作用的时候。

微服务网关

微服务的概念最早在2012年提出，在Martin Fowler的大力推广下，微服务在2014年后得到了大力发展。在微服务架构中，有一个组件可以说是必不可少的，那就是微服务网关。微服务网关处理了负载均衡、缓存、路由、访问控制、服务代理、监控、日志等功能。API网关在微服务架构中正是以微服务网关的身份存在。

API服务管理平台

上述的微服务架构对企业来说有可能在实施上是困难的。企业有很多遗留系统，要全部抽取为微服务的改动太大，对企业来说成本太高。但是由于不同系统间存在大量的API服务互相调用，因此需要对系统间服务调用进行管理，清晰地看到各系统调用关系，对系统间调用进行监控等。API网关可以解决这些问题。如果没有大规模实施微服务架构，那么对企业来说，微服务网关就是企业的API服务管理平台。

网关设计

开放API接口

    对于OpenAPI使用的API网关来说，一般合作伙伴要以应用的形式接入到OpenAPI平台，合作伙伴需要到 OpenAPI平台申请应用。因此在OpenAPI网关之外，需要有一个面向合作伙伴的使用的平台用于合作伙伴，这就要求OpenAPI网关需要提供API给这个用户平台进行访问。 当然如果是在简单的场景下，可能并不需要提供一个面向合作伙伴的门户，只需要由公司的运营人员直接添加合作伙伴应用id/密钥等，这种情况下也就不需要合作伙伴门户子系统。

内网API接口

对于内网的API网关，在起到的作用上来说可以认为是微服务网关，也可以认为是内网的API服务治理平台。当企业将所有的应用使用微服务的架构管理起来，那么API网关就起到了微服务网关的作用。而当企业只是将系统与系统之间的调用使用rest api的方式进行访问时使用API网关对调用进行管理，那么API网关起到的就是API服务治理的作用。

对于公司内部公网应用（如APP、公司的网站），如果管理上比较细致，在架构上是可能由独立的API网关来处理这部分内部公网应用，如果想比较简单的处理，也可以是使用面向合作伙伴的API网关。如果使用独立的API网关，有以下的好处：

面向合作伙伴和面向公司主体业务的优先级不一样，不同的API网关可以做到业务影响的隔离。

    内部API使用的管理流程和面向合作伙伴的管理流程可能不一样。

    内部的API在功能扩展等方面的需求一般会大于OpenAPI对于功能的要求。

    基于以上的分析，如果公司有能力，那么还是建议分开使用合作伙伴OPEN API网关和内部公网应用网关。

网关框架

Tyk

介绍：Tyk 是一个开放源码的 API 网关，它是快速、可扩展和现代的。
功能：提供了一个 API 管理平台，其中包括 API 网关、API 分析、开发人员门户和 API 管理面板。
实现：基于 Go 实现。
官网：[https://tyk.io](https://tyk.io)

Kong

介绍：Kong 是一个可扩展的开放源码 API Layer（也称为 API 网关或 API 中间件）。
功能：在任何 RESTful API 的前面运行，通过插件扩展，提供超越核心平台的额外功能和服务。
实现：基于 Nginx + Lua 进行二次开发。
官网：[https://konghq.com](https://konghq.com)

Orange

介绍：Orange 和 Kong 类似，也是基于 OpenResty 的一个 API 网关程序，由国人开发。
官网：[http://orange.sumory.com](http://orange.sumory.com)

Netflix Zuul

介绍：Zuul 是 Netflix 公司的开源项目，提供动态路由、监视、弹性、安全性等功能的边缘服务。
功能：Zuul 是 Netflix 出品的一个基于 JVM 路由和服务端的负载均衡器。
集成：Spring Cloud 在 Netflix 项目中也已经集成了 Zuul。
GitHub：[https://github.com/Netflix/zuul](https://github.com/Netflix/zuul)

GateWay

介绍：GateWay 是 Spring Cloud 的一个子项目，构建于 Spring 5+，基于 Spring Boot 2.x 响应式的、非阻塞式的 API。
官网：[https://spring.io/projects/spring-cloud-gateway](https://spring.io/projects/spring-cloud-gateway)

网关作用

功能：网关的作用可以实现负载均衡、路由转发、日志记录、权限控制、监控等。

网关与过滤器区别

网关：拦截所有服务器请求进行控制。
过滤器：拦截单个服务器请求进行控制。

Nginx 与 Zuul 区别

Nginx

  方式：采用服务器负载均衡进行转发。
  功能：能够整合其他语言（如 Lua 脚本）实现强大的功能。
  优势：更好的抗高并发。

Zuul

  方式：依赖 Ribbon 和 Eureka 实现本地负载均衡转发。
  适用场景：适用于请求过滤和拦截等。

Zuul

创建工程Zuul，添加依赖：

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
            <version>2.2.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
            <version>2.2.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

配置文件（这里其实用了serviceId就不需要写url，但是由于版本问题，我这里两个都写了）：

server:
  port: 7015
spring:
  application:
    name: Zuul
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:7001/eureka
  instance:
    lease-renewal-interval-in-seconds: 1    #间隔1s，向服务端发送一次心跳，证明自己依然“存活”
    lease-expiration-duration-in-seconds: 2    # 告诉服务端，如果我2s之内没有给你发心跳，就代表我“死”了，请将我踢掉
management:
  endpoints:
    web:
      exposure:
        include: "*"
zuul:
  routes:
    EurekaClient:
      path: /EurekaClient/**
      url: http://127.0.0.1:7002/
      serviceId: EurekaClient
    Feign:
      path: /Feign/**
      url: http://127.0.0.1:7007/
      serviceId: Feign
ribbon:
  eureka:
    enabled: true

由于版本过高缺少ErrorController，我们这里做相应配置：

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.boot.web.servlet.error.ErrorController;
import org.springframework.cglib.proxy.*;
import org.springframework.cloud.netflix.zuul.filters.RouteLocator;
import org.springframework.cloud.netflix.zuul.web.ZuulController;
import org.springframework.cloud.netflix.zuul.web.ZuulHandlerMapping;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

/**
 * Fix for Zuul configuration with Spring Boot 2.5.x + Zuul - "NoSuchMethodError: ErrorController.getErrorPath()":
 */
@Configuration
public class ZuulConfiguration {
  /**
   * The path returned by ErrorController.getErrorPath() with Spring Boot < 2.5
   * (and no longer available on Spring Boot >= 2.5).
   */
  private static final String ERROR_PATH = "/error";
  private static final String METHOD = "lookupHandler";

  /**
   * Constructs a new bean post-processor for Zuul.
   *
   * @param routeLocator    the route locator.
   * @param zuulController  the Zuul controller.
   * @param errorController the error controller.
   * @return the new bean post-processor.
   */
  @Bean
  public ZuulPostProcessor zuulPostProcessor(@Autowired RouteLocator routeLocator,
                                             @Autowired ZuulController zuulController,
                                             @Autowired(required = false) ErrorController errorController) {
    return new ZuulPostProcessor(routeLocator, zuulController, errorController);
  }

  private enum LookupHandlerCallbackFilter implements CallbackFilter {
    INSTANCE;

    @Override
    public int accept(Method method) {
      if (METHOD.equals(method.getName())) {
        return 0;
      }
      return 1;
    }
  }

  private enum LookupHandlerMethodInterceptor implements MethodInterceptor {
    INSTANCE;

    @Override
    public Object intercept(Object target, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
      if (ERROR_PATH.equals(args[0])) {
        // by entering this branch we avoid the ZuulHandlerMapping.lookupHandler method to trigger the
        // NoSuchMethodError
        return null;
      }
      return methodProxy.invokeSuper(target, args);
    }
  }

  private static final class ZuulPostProcessor implements BeanPostProcessor {

    private final RouteLocator routeLocator;
    private final ZuulController zuulController;
    private final boolean hasErrorController;

    ZuulPostProcessor(RouteLocator routeLocator, ZuulController zuulController, ErrorController errorController) {
      this.routeLocator = routeLocator;
      this.zuulController = zuulController;
      this.hasErrorController = (errorController != null);
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
      if (hasErrorController && (bean instanceof ZuulHandlerMapping)) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(ZuulHandlerMapping.class);
        enhancer.setCallbackFilter(LookupHandlerCallbackFilter.INSTANCE); // only for lookupHandler
        enhancer.setCallbacks(new Callback[] {LookupHandlerMethodInterceptor.INSTANCE, NoOp.INSTANCE});
        Constructor<?> ctor = ZuulHandlerMapping.class.getConstructors()[0];
        return enhancer.create(ctor.getParameterTypes(), new Object[] {routeLocator, zuulController});
      }
      return bean;
    }
  }
}

启动类如下：

@EnableZuulProxy
@EnableEurekaClient
@EnableDiscoveryClient
@SpringBootApplication
public class ZuulApplication {

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

}

然后启动项目，访问127.0.0.1:7015/EurekaClient/client/hello，和127.0.0.1:7015/Feign/feign/hello，就可以分别访问不同的服务：

访问127.0.0.1:7015/actuator/filters,