乐趣区

关于java:深入Java微服务之网关系列3-SpringCloudalibaba-gateway详解史上最全

作者：

jiezi

在

九、服务网关：Gateway

9.1、网关简介

    大家都都晓得在微服务架构中，一个零碎会被拆分为很多个微服务。那么作为客户端要如何去调用这么多的微服务呢？如果没有网关的存在，咱们只能在客户端记录每个微服务的地址，而后别离去调用。

    这样的架构会存在许多的问题：

  1. 客户端屡次申请不同的微服务，减少客户端代码或配置编写的复杂性。
  2. 认证简单，每个服务都须要独立认证。
  3. 存在跨域申请，在肯定场景下解决绝对简单。

    网关就是为了解决这些问题而生的。所谓的API网关，就是指零碎的对立入口，它封装了应用程序的内部结构，为客户端提供对立服务，一些与业务自身性能无关的公共逻辑能够在这里实现，诸如认证、鉴权、监控、路由转发等等。

9.2、罕用的网关

9.2.1、Ngnix+lua

    应用nginx的反向代理和负载平衡可实现对api服务器的负载平衡及高可用。

    lua是一种脚本语言,能够来编写一些简略的逻辑, nginx反对lua脚本

9.2.2、Kong

    基于Nginx+Lua开发，性能高，稳固，有多个可用的插件(限流、鉴权等等)能够开箱即用。

他的毛病：

  1. 只反对Http协定。
  2. 二次开发，自在扩大艰难。
  3. 提供治理API，不足更易用的管控、配置形式。

9.2.3、Zuul

    Netflix开源的网关，功能丰富，应用JAVA开发，易于二次开发。

    他的毛病：

  1. 不足管控，无奈动静配置。
  2. 依赖组件较多。
  3. 解决Http申请依赖的是Web容器，性能不如Nginx。

9.2.4、Spring Cloud Gateway

    Spring公司为了替换Zuul而开发的网关服务，SpringCloud alibaba技术栈中并没有提供本人的网关，咱们能够采纳Spring Cloud Gateway来做网关

9.3、Gateway简介

    Spring Cloud Gateway是Spring公司基于Spring 5.0，Spring Boot 2.0 和 Project Reactor 等技术开发的网关，它旨在为微服务架构提供一种简略无效的对立的 API 路由治理形式。它的指标是代替Netflix Zuul，其不仅提供对立的路由形式，并且基于 Filter 链的形式提供了网关根本的性能，例如：平安，监控和限流。

    他的次要性能是：

  1. 进行转发重定向。
  2. 在开始的时候，所有类都须要做的初始化操作。
  3. 进行网络隔离。

9.4、疾速入门

    需要：通过浏览器拜访api网关,而后通过网关将申请转发到商品微服务。

9.4.1、根底版

创立一个api-gateway 模块，并且导入上面的依赖。

<?xml version="1.0" encoding="UTF-8"?>
<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/xsd/maven-4.0.0.xsd">
  <parent>
    Shop-parent
    <groupId>cn.linstudy</groupId>
    <version>1.0.0</version>
  </parent>
  <modelVersion>4.0.0</modelVersion>
  api-gateway

  <properties>
    <maven.compiler.source>11</maven.compiler.source>
    <maven.compiler.target>11</maven.compiler.target>
  </properties>

  <dependencies>
    <!--gateway网关-->
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      spring-cloud-starter-gateway
    </dependency>
    <dependency>
      <groupId>org.projectlombok</groupId>
      lombok
    </dependency>
  </dependencies>

</project>
复制代码

编写配置文件

server:
  port: 9000 # 指定网关服务的端口
spring:
  application:
    name: api-gateway
  cloud:
    gateway:
      routes: # 路由数组[路由 就是指定当申请满足什么条件的时候转到哪个微服务]
        - id: product_route # 以后路由的标识, 要求惟一
          uri: http://localhost:8081 # 申请要转发到的地址
          order: 1 # 路由的优先级,数字越小级别越高
          predicates: # 断言(就是路由转发要满足的条件)
            - Path=/product-serv/** # 当申请门路满足Path指定的规定时,才进行路由转发
          filters: # 过滤器,申请在传递过程中能够通过过滤器对其进行肯定的批改
            - StripPrefix=1 # 转发之前去掉1层门路
复制代码

测试

9.4.2、升级版

    咱们发现升级版有一个很大的问题，那就是在配置文件中写死了转发门路的地址，咱们须要在注册核心来获取地址。

退出nacos依赖

<?xml version="1.0" encoding="UTF-8"?>
<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/xsd/maven-4.0.0.xsd">
  <parent>
    Shop-parent
    <groupId>cn.linstudy</groupId>
    <version>1.0.0</version>
  </parent>
  <modelVersion>4.0.0</modelVersion>
  api-gateway

  <properties>
    <maven.compiler.source>11</maven.compiler.source>
    <maven.compiler.target>11</maven.compiler.target>
  </properties>

  <dependencies>
    <!--gateway网关-->
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      spring-cloud-starter-gateway
    </dependency>
    <!--nacos客户端-->
    <dependency>
      <groupId>com.alibaba.cloud</groupId>
      spring-cloud-starter-alibaba-nacos-discovery
    </dependency>
    <dependency>
      <groupId>org.projectlombok</groupId>
      lombok
    </dependency>
  </dependencies>

</project>
复制代码

在主类上增加注解

@SpringBootApplication
@EnableDiscoveryClient
public class GateWayServerApp {
  public static void main(String[] args) {
    SpringApplication.run(GateWayServerApp.class,args);
  }
}
复制代码

批改配置文件

server:
  port: 9000
spring:
  application:
    name: api-gateway
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
    gateway:
      discovery:
        locator:
          enabled: true # 让gateway能够发现nacos中的微服务
      routes:
        - id: product_route # 路由的名字
          uri: lb://product-service # lb指的是从nacos中依照名称获取微服务,并遵循负载平衡策略
          predicates:
            - Path=/product-serv/** # 合乎这个规定的才进行1转发
          filters:
            - StripPrefix=1 # 将第一层去掉
复制代码

    咱们还能够自定义多个路由规定。

spring:
  application:
    gateway:
      routes:
        - id: product_route
          uri: lb://product-service 
          predicates:
            - Path=/product-serv/**
          filters:
            - StripPrefix=1
        - id: order_route
          uri: lb://order-service 
          predicates:
            - Path=/order-serv/**
          filters:
            - StripPrefix=1
复制代码

9.4.3、简写版

    咱们的配置文件无需写的1那么简单就能够实现性能，有一个简写版。

server:
  port: 9000
spring:
  application:
    name: api-gateway
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
    gateway:
      discovery:
        locator:
          enabled: true # 让gateway能够发现nacos中的微服务
复制代码

    咱们发现，就发现只有依照网关地址/微服务名称/接口的格局去拜访，就能够失去胜利响应。

9.5、Gateway外围架构

9.5.1、基本概念

    路由(Route) 是 gateway 中最根本的组件之一，示意一个具体的路由信息载体。次要定义了上面的几个信息：

  1. id：路由标识符，区别于其余 Route。
  2. uri：路由指向的目的地 uri，即客户端申请最终被转发到的微服务。
  3. order：用于多个 Route 之间的排序，数值越小排序越靠前，匹配优先级越高。
  4. predicate：断言的作用是进行条件判断，只有断言都返回真，才会真正的执行路由。
  5. filter：过滤器用于批改申请和响应信息。
  6. predicate：断言，用于进行条件判断，只有断言都返回真，才会真正的执行路由。

9.5.2、执行原理

  1. 接管用户的申请，申请处理器交给处理器映射器，返回执行链。
  2. 申请处理器去调用web处理器，在web处理器外面对咱们的门路1进行解决。假如1咱们的门路1是：http://localhost:9000/product-serv/get?id=1 ，依据配置的路由规定，上本地找对应的服务信息：product-service对应的主机ip是192.168.10.130。
  3. 依据1ribbon的负载平衡策略去抉择一个节点，而后拼接好，将门路中的product-serv替换成192.168.10.130:8081，如果你配置了filter，那么他还会走filter。
  4. 如果你没有自定义路由的话，默认Gateway会帮你把第一层去掉。网关端口从此一个/开始到第二个/开始算第一层。

9.6、过滤器

    Gateway的过滤器的作用是：是在申请的传递过程中,对申请和响应做一些手脚。

    Gateway的过滤器的生命周期：

  1. PRE：这种过滤器在申请被路由之前调用。咱们可利用这种过滤器实现身份验证、在集群中抉择 申请的微服务、记录调试信息等。
  2. POST：这种过滤器在路由到微服务当前执行。这种过滤器可用来为响应增加规范的HTTP Header、收集统计信息和指标、将响应从微服务发送给客户端等。

    Gateway 的Filter从作用范畴可分为两种: GatewayFilter与GlobalFilter：

  1. GatewayFilter：利用到单个路由或者一个分组的路由上。
  2. GlobalFilter：利用到所有的路由上。

9.6.1、部分过滤器

    部分过滤器是针对单个路由的过滤器。他分为内置过滤器和自定义过滤器。

9.6.1.1、内置过滤器

    在SpringCloud Gateway中内置了很多不同类型的网关路由过滤器。

9.6.1.1.1、部分过滤器内容
过滤器工厂 作用 参数
AddRequestHeader 为原始申请增加Header Header的名称及值
AddRequestParameter 为原始申请增加申请参数 参数名称及值
AddResponseHeader 为原始响应增加Header Header的名称及值
DedupeResponseHeader 剔除响应头中反复的值 须要去重的Header名称及去重策略
Hystrix 为路由引入Hystrix的断路器爱护 HystrixCommand 的名称
FallbackHeaders 为fallbackUri的申请头中增加具体的异样信息 Header的名称
PrefixPath 为原始申请门路增加前缀 前缀门路
PreserveHostHeader 为申请增加一个preserveHostHeader=true的属性，路由过滤器会查看该属性以决定是否要发送原始的Host 无
RequestRateLimiter 用于对申请限流，限流算法为令牌桶 keyResolver、rateLimiter、statusCode、denyEmptyKey、emptyKeyStatus
RedirectTo 将原始申请重定向到指定的URL http状态码及重定向的url
RemoveHopByHopHeadersFilter 为原始申请删除IETF组织规定的一系列Header 默认就会启用，能够通过配置指定仅删除哪些Header
RemoveRequestHeader 为原始申请删除某个Header Header名称
RemoveResponseHeader 为原始响应删除某个Header Header名称
RewritePath 重写原始的申请门路 原始门路正则表达式以及重写后门路的正则表达式
RewriteResponseHeader 重写原始响应中的某个Header Header名称，值的正则表达式，重写后的值
SaveSession 在转发申请之前，强制执行WebSession::save操作 无
secureHeaders 为原始响应增加一系列起平安作用的响应头 无，反对批改这些平安响应头的值
SetPath 批改原始的申请门路 批改后的门路
SetResponseHeader 批改原始响应中某个Header的值 Header名称，批改后的值
SetStatus 批改原始响应的状态码 HTTP 状态码，能够是数字，也能够是字符串
StripPrefix 用于截断原始申请的门路 应用数字示意要截断的门路的数量
Retry 针对不同的响应进行重试 retries、statuses、methods、series
RequestSize 设置容许接管最大申请包的大小。如果申请包大小超过设置的值，则返回 413 Payload Too Large 申请包大小，单位为字节，默认值为5M
ModifyRequestBody 在转发申请之前批改原始申请体内容 批改后的申请体内容
ModifyResponseBody 批改原始响应体的内容 批改后的响应体内容
9.6.1.1.2、部分过滤器的应用
server:
  port: 9000
spring:
  application:
    name: api-gateway
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
    gateway:
      discovery:
        locator:
          enabled: true # 让gateway能够发现nacos中的微服务
      routes:
        - id: product_route # 路由的名字
          uri: lb://product-service # lb指的是从nacos中依照名称获取微服务,并遵循负载平衡策略
          predicates:
            - Path=/product-serv/** # 合乎这个规定的才进行1转发
          filters:
            - StripPrefix=1 # 将第一层去掉
            - SetStatus=2000 # 这里应用内置的过滤器，批改返回状态
复制代码

9.6.1.2、自定义部分过滤器

    很多的时候，内置过滤器没方法满足咱们的需要，这个时候就必须自定义部分过滤器。咱们假设一个需要是：统计订单服务调用耗时。

编写一个类，用于实现逻辑

    名称是有固定格局xxxGatewayFilterFactory

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

  private static final String BEGIN_TIME = "beginTime";

  //构造函数
  public TimeGatewayFilterFactory() {
    super(TimeGatewayFilterFactory.Config.class);
  }

  //读取配置文件中的参数 赋值到 配置类中
  @Override
  public List<String> shortcutFieldOrder() {
    return Arrays.asList("show");
  }

  @Override
  public GatewayFilter apply(Config config) {
    return new GatewayFilter() {
      @Override
      public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        if (!config.show){
          // 如果配置类中的show为false，示意放行
          return chain.filter(exchange);
        }
        exchange.getAttributes().put(BEGIN_TIME, System.currentTimeMillis());
        /**
         *  pre的逻辑
         * chain.filter().then(Mono.fromRunable(()->{
         *     post的逻辑
         * }))
         */
        return chain.filter(exchange).then(Mono.fromRunnable(()->{
          Long startTime = exchange.getAttribute(BEGIN_TIME);
          if (startTime != null) {
            System.out.println(exchange.getRequest().getURI() + "申请耗时: " + (System.currentTimeMillis() - startTime) + "ms");
          }
        }));
      }
    };
  }

  @Setter
  @Getter
  static class Config{
    private boolean show;
  }

}
复制代码

编写application.xml

server:
  port: 9000
spring:
  application:
    name: api-gateway
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
    gateway:
      discovery:
        locator:
          enabled: true # 让gateway能够发现nacos中的微服务
      routes:
        - id: product_route # 路由的名字
          uri: lb://product-service # lb指的是从nacos中依照名称获取微服务,并遵循负载平衡策略
          predicates:
            - Path=/product-serv/** # 合乎这个规定的才进行1转发
          filters:
            - StripPrefix=1 # 将第一层去掉
        - id: order_route
          uri: lb://order-service
          predicates:
            - Path=/order-serv/**
          filters:
            - StripPrefix=1
            - Time=true
复制代码

拜访门路：http://localhost:9000/order-serv/getById?o=1&pid=1

9.6.2、全局过滤器

    全局过滤器作用于所有路由, 无需配置。通过全局过滤器能够实现对权限的对立校验，安全性验证等性能。SpringCloud Gateway外部也是通过一系列的内置全局过滤器对整个路由转发进行解决。

    开发中的鉴权逻辑：

  • 当客户端第一次申请服务时，服务端对用户进行信息认证（登录）。
  • 认证通过，将用户信息进行加密造成token，返回给客户端，作为登录凭证。
  • 当前每次申请，客户端都携带认证的token。
  • 服务端对token进行解密，判断是否无效。

    咱们来模仿一个需要：实现对立鉴权的性能,咱们须要在网关判断申请中是否蕴含token且，如果没有则不转发路由，有则执行失常逻辑。

编写全局过滤器

@Component
public class AuthGlobalFilter implements GlobalFilter {

  @Override
  public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    String token = exchange.getRequest().getQueryParams().getFirst("token");
    if (StringUtils.isBlank(token)) {
      System.out.println("鉴权失败");
      exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
      return exchange.getResponse().setComplete();
    }
    return chain.filter(exchange);
  }
}
复制代码

9.6.3、网关限流

    网关是所有申请的公共入口，所以能够在网关进行限流，而且限流的形式也很多，咱们本次采纳后面学过的Sentinel组件来实现网关的限流。Sentinel反对对SpringCloud Gateway、Zuul等支流网关进行限流。

    从1.6.0版本开始，Sentinel提供了SpringCloud Gateway的适配模块，能够提供两种资源维度的限流：

  • route维度：即在Spring配置文件中配置的路由条目，资源名为对应的routeId
  • 自定义API维度：用户能够利用Sentinel提供的API来自定义一些API分组

9.6.3.1、网关集成Sentinel

增加依赖

<dependency>
    <groupId>com.alibaba.csp</groupId>
    sentinel-spring-cloud-gateway-adapter
</dependency>
复制代码

编写配置类进行限流

    配置类的实质是用代码代替nacos图形化界面限流。

@Configuration
public class GatewayConfiguration {
    private final List<ViewResolver> viewResolvers;
    private final ServerCodecConfigurer serverCodecConfigurer;

    public GatewayConfiguration(ObjectProvider<List<ViewResolver>> viewResolversProvider,
                                ServerCodecConfigurer serverCodecConfigurer) {
        this.viewResolvers = viewResolversProvider.getIfAvailable(Collections::emptyList);
        this.serverCodecConfigurer = serverCodecConfigurer;
    }
    // 配置限流的异样处理器
    @Bean
    @Order(Ordered.HIGHEST_PRECEDENCE)
    public SentinelGatewayBlockExceptionHandler sentinelGatewayBlockExceptionHandler() {
        // Register the block exception handler for Spring Cloud Gateway.
        return new SentinelGatewayBlockExceptionHandler(viewResolvers, serverCodecConfigurer);
    }
    // 初始化一个限流的过滤器
    @Bean
    @Order(Ordered.HIGHEST_PRECEDENCE)
    public GlobalFilter sentinelGatewayFilter() {
        return new SentinelGatewayFilter();
    }
    //减少对商品微服务的限流
     @PostConstruct
    private void initGatewayRules() {
        Set<GatewayFlowRule> rules = new HashSet<>();
        rules.add(new GatewayFlowRule("product_route")
                .setCount(3) // 三次
                .setIntervalSec(1) // 一秒，示意一秒钟1超过了三次就会限流
        );
        GatewayRuleManager.loadRules(rules);
    }
}
复制代码

批改限流默认返回格局

    如果咱们不想在限流的时候返回默认的谬误，那么就须要自定义谬误，指定自定义的返回格局。咱们只需在类中增加一段配置即可。

@PostConstruct
public void initBlockHandlers() {
    BlockRequestHandler blockRequestHandler = new BlockRequestHandler() {
    public Mono<ServerResponse> handleRequest(ServerWebExchange serverWebExchange, Throwable throwable) {
        Map map = new HashMap<>();
        map.put("code", 0);
        map.put("message", "接口被限流了");
            return ServerResponse.status(HttpStatus.OK).
                contentType(MediaType.APPLICATION_JSON).
                body(BodyInserters.fromValue(map));
            }
};
    GatewayCallbackManager.setBlockHandler(blockRequestHandler);
}
复制代码

测试

9.6.3.2、自定义API分组

    咱们能够发现，下面的这种定义，对整个服务进行了限流，粒度不够细。自定义API分组是一种更细粒度的限流规定定义，它能够实现某个办法的细粒度限流。

在Shop-order-server我的项目中增加ApiController

@RestController
@RequestMapping("/api")
public class ApiController {
    @RequestMapping("/hello")
    public String api1(){
        return "api";
    }
}
复制代码

在GatewayConfiguration中增加配置

@PostConstruct
private void initCustomizedApis() {
    Set<ApiDefinition> definitions = new HashSet<>();
    ApiDefinition api1 = new ApiDefinition("order_api")
                .setPredicateItems(new HashSet<ApiPredicateItem>() {{
                    add(new ApiPathPredicateItem().setPattern("/order-serv/api/**").                 setMatchStrategy(SentinelGatewayConstants.URL_MATCH_STRATEGY_PREFIX));
                }});
    definitions.add(api1);
    GatewayApiDefinitionManager.loadApiDefinitions(definitions);
}
@PostConstruct
private void initGatewayRules() {
    Set<GatewayFlowRule> rules = new HashSet<>();
    rules.add(new GatewayFlowRule("product_route")
                .setCount(3)
                .setIntervalSec(1)
    );
    rules.add(new GatewayFlowRule("order_api").
                setCount(1).
                setIntervalSec(1));
    GatewayRuleManager.loadRules(rules);
}
复制代码

测试

    间接拜访http://localhost:8082/api/hello 是不会产生限流的，拜访http://localhost:9000/order-serv/api/hello 就会呈现限流了。

作者：XiaoLin_Java
链接：https://juejin.cn/post/700181…
起源：稀土掘金
著作权归作者所有。商业转载请分割作者取得受权，非商业转载请注明出处。
微信公众号【程序员黄小斜】作者是前蚂蚁金服Java工程师，专一分享Java技术干货和求职成长心得，不限于BAT面试，算法、计算机根底、数据库、分布式、spring全家桶、微服务、高并发、JVM、Docker容器，ELK、大数据等。关注后回复【book】支付精选20本Java面试必备精品电子书。

​

评论

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

这个站点使用 Akismet 来减少垃圾评论。了解你的评论数据如何被处理。

更多文章