重新定义cloud 第17章 spring cloud gateway上篇

最新推荐文章于 2020-12-19 19:30:01 发布

天海华兮

最新推荐文章于 2020-12-19 19:30:01 发布

阅读量145

点赞数

分类专栏：重新定义SpringCloud 文章标签： gateway 过滤器网关 hystrix

本文链接：https://blog.csdn.net/qq120631157/article/details/109718106

版权

重新定义SpringCloud 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

gateway 概述

基于 spring 5.0
spring boot 2.0
project reactor
提供简单，有效且统一， api路由管理方式
基于 filter 链的方式提供了网关基本的功能
- 安全
- 监控/埋点
- 限流
- 协议适配
- 协议转发
- 安全策略 waf
- 防刷
- 流量
- 监控日志
网关的核心 Filter 以及filter chain （filter 责任链）
路由 route（包含）
- id
- 目的 url
- 断言工厂
- 一组filter
- 断言为真，则说明url和配置的路由匹配
断言 predicate
- spring 5.0 的 serverWebExchange
- 允许开发者去定义匹配来自于 http Request中的任何信息（请求头，参数）
过滤器 filter
- 一个标准的spring filter
- gateWay filter
- globbal filter
- 过滤器 filter 将会对请求和响应进行修改处理。

工作原理

默认端口，80，https 443
启动容器只支持 netty
gateway client
spring cloud gateway
- HttpWebHandlerAdapter 组装网关上下文
- DispatcheerHandler 分发处理器，循环遍历 Mapping，获取 Handler
- Route Predicate Handler Mapping 断言处理器，判断是否可用
- 断言成功
- Filtering Web Handler 创建过滤器，调用过滤链
  - pre filter
  - post filter
proxied service 代理服务器

入门案例

协议适配
- 路由信息转发
协议转发
本案例演示，Path路由断言工厂实现 url 直接转发

xml

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

主启动类

@SpringBootApplication
public class SpringCloudGatewayApplication {

	/**
	 * 基本的转发
	 * 当访问http://localhost:8080/jd
	 * 转发到http://jd.com
	 * @param builder
	 * @return
	 */
	@Bean // Locator n. 定位器，探测器
	public RouteLocator custom Route Locator(RouteLocatorBuilder builder) {
		return builder.routes()
				//basic proxy
				.route(r ->r.path("/jd")
						.uri("http://jd.com:80/").id("jd_route")
				).build();
	} //第一种配置

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

第二种配置。application.yml

spring:
  cloud:
    gateway:
      routes: #当访问http://localhost:8080/baidu,直接转发到https://www.baidu.com/
        - id: baidu_route
          uri: http://baidu.com:80/
          predicates:
            - Path=/baidu

application.yml

server:
  port: 8080
  
spring:
  application:
    name: spring-cloud-gateway
  cloud:
    gateway:
      routes: #当访问http://localhost:8080/baidu,直接转发到https://www.baidu.com/
        - id: baidu_route
          uri: http://baidu.com:80/
          predicates:
            - Path=/baidu

logging: ## Spring Cloud Gateway的日志配置
  level:
    org.springframework.cloud.gateway: TRACE
    org.springframework.http.server.reactive: DEBUG
    org.springframework.web.reactive: DEBUG
    reactor.ipc.netty: DEBUG


management:
  endpoints:
    web:
      exposure:
        include: '*'
  security:
    enabled: false

trace 
英 /treɪs/  美 /treɪs/  
v. （通过调查）找到；追溯；追踪；沿（特定路径）走；映描；（尤指用手指、脚趾）画；勾画出轮廓
n. 痕迹；踏出来的小路；（大脑上的学习或记忆）痕迹；语迹；跟踪；微量；丝毫；描记线；交线；缰绳

开启端点

如上配置
提供了 gateway actuator
关于 filter和 routes 信息查询，制定 route信息更新的 Rest API

http://localhost:8080/actuator/gateway/routes

[{
	"route_id": "jd_route", //jd的转发 断言是这个类
	"route_object": {
		"predicate": "org.springframework.cloud.gateway.support.ServerWebExchangeUtils$$Lambda$293/70528019@27137286"
	},
	"order": 0
}, {
	"route_id": "baidu_route",
	"route_definition": {
		"id": "baidu_route",
		"predicaates": [{
			"name": "Path",
			"args": {
				"_genkey_0": "/baidu" //本地的请求
			}
		}],
		"filters": [],
		"uri": "http://baidu.com:80/", //转发的路径
		"order": 0
	},
	"order": 0
}]

路由断言

路由匹配是 spring webFlux的 Handler Mapping 为基础实现的
有许多的路由断言工厂
路由断言工厂会根据配置的路由规则，对请求进行断言匹配
匹配成功进行下一步处理，否则断言失败，返回错误信息

after路由器断言工厂

after route predicate factory
取UTC 时间格式 UTC一般指协调世界时。协调世界时，又称世界统一时间、世界标准时间、国际协调时间。
当请求进来的当前时间在配置的 UTF 时间之后，会匹配成功。否则失败。
当前请求在，配置时间之后。才会成功、

路由配置代码

@SpringBootApplication
public class SCGatewayApplication {

	@Bean
	public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
		//生成比当前时间早一个小时的UTC时间
		ZonedDateTime minusTime = LocalDateTime.now().minusHours(1).atZone(ZoneId.systemDefault());
		return builder.routes()
				.route("after_route", r -> r.after(minusTime)
						.uri("http://baidu.com"))
				.build();
	}
	public static void main(String[] args) {
		SpringApplication.run(SCGatewayApplication.class, args);
	}
}

如果：.plusHours(1) 就会失败，因为当前请求的时间，在之前了。

或者

spring:
  cloud:
    gateway:
      routes: #当访问http://localhost:8080/baidu,直接转发到https://www.baidu.com/
        - id: baidu_route
          uri: http://baidu.com:80/
          predicates:
            - Path=/baidu #要加百度的访问
            - After=2020-11-13T14:26:38.584+08:00[Asia/Shanghai]

UTC工具类

/**
 * 生成UTC时间
 */
public class UtcTimeUtil {

    public static void main(String[] args) {
        ZonedDateTime time=  ZonedDateTime.now();
        System.out.println("zonedDateTime:"+time);

        String  maxTime=ZonedDateTime.now().plusHours(1).format(DateTimeFormatter.ISO_ZONED_DATE_TIME);
        System.out.println("maxTime："+maxTime);
        //用这个会出现：Handler Terminated 处理程序终止 无法跳转

        String  minTime=ZonedDateTime.now().minusHours(1).format(DateTimeFormatter.ISO_ZONED_DATE_TIME);
        System.out.println("minTime:"+minTime);


        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String str=time.format(formatter);
        System.out.println(str);
    }

}

测试

如果使用类配置，直接访问：http://localhost:8081
如果用类配置，不会配置请求http://localhost:8081/baidu

r.path("/baidu")
      .uri("http://baidu.com").id("aaa")

before 路由器断言工厂

当请求进来的时间，在路由器断言工厂之前，会匹配成功

	@Bean
	public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
		//加一天，保证当前的请求，是在 之前的。
        //Handler Terminated(如果当前的请求在 之后)
		ZonedDateTime datetime = LocalDateTime.now().plusDays(1).atZone(ZoneId.systemDefault());
		return builder.routes()
				.route("before_route", r -> r.before(datetime)
						.uri("http://baidu.com"))

				.build();
	}

http://localhost:8080 会转发到baidu

Between断言工厂

代码控制

@SpringBootApplication
public class SCGatewayApplication {

	@Bean
	public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {

		ZonedDateTime datetime1 = LocalDateTime.now().minusDays(1).atZone(ZoneId.systemDefault());
		ZonedDateTime datetime2 = LocalDateTime.now().plusDays(1).atZone(ZoneId.systemDefault());
		return builder.routes()
				.route("between_route", r -> r.between(datetime1,datetime2)
						.uri("http://baidu.com"))

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

yaml控制

spring:
  cloud:
    gateway:
      routes:
      - id: between_route
        uri: http://xujin.org
        predicates:
        - name: Between
          args:
            datetime1: 2018-03-15T00:02:48.513+08:00[Asia/Shanghai]
            datetime2: 2018-03-15T02:02:48.516+08:00[Asia/Shanghai]

cookie 断言工厂

会取， key 和 value
当请求携带的 cookie 和 cookied 断言工厂中配置的 cookie 一致，匹配成功

代码控制

	@Bean
	public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
		return builder.routes()
				.route("cookie_route", r -> r.cookie("chocolate", "ch.p")
						.uri("http://localhost:8071/test/cookie"))
				.build();
	}

yaml 控制

server:
  port: 8080
spring:
  application:
    name: spring-cloud-gateway
  cloud:
    gateway:
      routes:
        - id: between_route
          uri: http://xujin.org
          predicates:
            - Cookie=chocolate, ch.p

请求到的代码

	@GetMapping("/test/cookie")
	public String testGateway(HttpServletRequest request, HttpServletResponse response){
		Cookie[] cookies = request.getCookies();
		if (cookies != null) {
			for (Cookie cookie : cookies) {
				System.out.println(cookie.getName()+":"+cookie.getValue());
			}
		}
		return "Spring Cloud Gateway,Hello world!";
	}

测试

http://localhost:8080/
header 增加：key为：Cookie ，value: chocolate=ch.p
只有用这个headr头才能访问

header 路由断言工厂

header 断言的两种方法

根据路由的 header 信息断言

	@Bean
	public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
		return builder.routes()
				.route("header_route", r -> r.header("X-Request-Id", "xujin")
						.uri("http://localhost:8071/test/head"))
				.build();
	}

或者

spring:
  cloud:
    gateway:
      routes:
      - id: header_route
        uri: http://localhost:8071/test/head
        predicates:
        - Header=X-Request-Id, xujin

被请求的项目

	/**
	 * 测试Head路由断言工厂
	 * @param request
	 * @param response
	 * @return
	 */
	@GetMapping("/test/head")
	public String testGatewayHead(HttpServletRequest request, HttpServletResponse response){
		String head=request.getHeader("X-Request-Id");
		return "return head info:"+head;
	}

Host 路由断言工厂

对请求中的 Host 进行断言处理，断言成功则进行路由转发。


	@Bean
	public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
		return builder.routes()
				.route("host_route", r -> r.host("**.baidu.com:8080")
						.uri("http://jd.com"))
				.build();
	}

server:
  port: 8080
spring:
  application:
    name: spring-cloud-gateway
  cloud:
    gateway:
      routes:
        - id: header_route
          uri: http://jd.com
          predicates:
          - Host=**.baidu.com:8080

更改host文件，把vip.baidu.com映射到：127.0.0.1
访问：http://vip.baidu.com:8080 即可跳转到京东

Method 断言工厂

根据路由信息配置的 method对请求方法是 Get 或者 Post 等进行断言

	@Bean
	public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
		return builder.routes()
				.route("method_route", r -> r.method("GET")
						.uri("http://jd.com"))
				.build();
	}

server:
  port: 8080
spring:
  application:
    name: spring-cloud-gateway
  cloud:
    gateway:
      routes:
        - id: header_route
          uri: http://jd.com
          predicates:
            - Method=GET

访问：http://localhost:8080/ 即可。

Query 断言工厂

从请求中获取两个参数，和 Query 断言路由器中的配置进行匹配
http://localhost:8080/?foo=baz 和 r.query(“foo”,“baz”) 配置对比

	@Bean
	public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
		return builder.routes()
				.route("query_route", r -> r.query("foo","baz")
						.uri("http://baidu.com"))
				.build();
	}

server:
  port: 8080
spring:
  application:
    name: spring-cloud-gateway
  cloud:
    gateway:
      routes:
        - id: header_route
          uri: http://jd.com
          predicates:
            - Query=foo, baz

RemoteAddr 路由器断言工厂

ipv4 或 v6 网段，或者IP
当请求的 IP 在网段内，匹配成功，否则失败

	@Bean
	public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
		return builder.routes()
				.route("remoteaddr_route", r -> r.remoteAddr("127.0.0.1")
						.uri("http://baidu.com"))
				.build();
	}

spring:
  cloud:
    gateway:
      routes:
      - id: remoteaddr_route
        uri: http://baidu.com
        predicates:
        - RemoteAddr=127.0.0.1

访问：http://localhost:8080/ 不行。
访问：http://127.0.0.1:8080/ 转发成功
或者配本地的IP，也是可以测试的。

Spring cloud gateway 的内置 filter

路由过滤器允许以某种方式修改请求进来的 http请求
或返回的 http 响应
主要作用：处理特定路由
过滤器将近20多个
分为7类
- Header
- Paramter
- Path
- Status
- Redirect跳转
- Hystrix熔断
- RateLimiter

AddRequestHeader 过滤器工厂

对匹配的请求加上 Header

	@Bean
	public RouteLocator testRouteLocator(RouteLocatorBuilder builder) {
		return builder.routes()
				.route("add_request_header_route", r ->
						r.path("/test").filters(f -> 
                                                f.addRequestHeader
                                                ("X-Request-Acme", "ValueB"))
								.uri("http://localhost:8071/test/head"))
				.build();
	}

	/**
	 * @param request
	 * @param response
	 * @return
	 */
	@GetMapping("/test/head")
	public String testGatewayHead(HttpServletRequest request, HttpServletResponse response){
		String head=request.getHeader("X-Request-Acme");
		return "return head info:"+head;
	}

访问：http://localhost:8080/test
返回：return head info:ValueB

AddRequestParameter过滤器

对匹配上的请求路由添加请求参数

	@Bean
	public RouteLocator testRouteLocator(RouteLocatorBuilder builder) {
		return builder.routes()
				.route("add_request_parameter_route", r ->
						r.path("/addRequestParameter").filters(f -> f.addRequestParameter("example", "ValueB"))
								.uri("http://localhost:8071/test/addRequestParameter"))
				.build();
	}

	@GetMapping("/test/addRequestParameter")
	public String addRequestParameter(HttpServletRequest request, HttpServletResponse response){
		String parameter=request.getParameter("example");
		return "return addRequestParameter info:"+parameter;
	}

访问：http://localhost:8080/addRequestParameter
返回：return addRequestParameter info:ValueB

RewritePath过滤器

RewritePath 替代 Zuul 的 StripPrefix

path: /demo/**
stripPrefix: true
url: http://demo.com

所有 /demo/xxxx的请求转发给 http://demo.com/xxx ，去掉demo 前缀
gateway使用的是 RewritePath

	@Bean
	public RouteLocator testRouteLocator(RouteLocatorBuilder builder) {
		return builder.routes()
				.route("rewritepath_route", r ->
						r.path("/foo/**").filters(f -> f.rewritePath("/foo/(?<segment>.*)","/$\\{segment}"))
								.uri("http://www.baidu.com"))
				.build();
	}

访问：http://localhost:8080/foo/cache/sethelp/help.html
将会去掉：/foo。http://www.baidu.com/cache/sethelp/help.html
/foo/(?.*) 替换为 /$\{segment}

Add Response Header过滤器

对网关返回的响应添加 header

	@Bean
	public RouteLocator testRouteLocator(RouteLocatorBuilder builder) {
		return builder.routes()
				.route("add_request_header_route", r ->
						r.path("/test").filters(f -> f.addResponseHeader("X-Response-Foo", "Bar"))
								.uri("http://www.baidu.com"))
				.build();
	}
//很神奇，去掉www，后转发成功了，之后加上www也可以了。
//好吧，确实不能加 www，缓存问题

http://localhost:8080/test
转发的京东请写：http://jd.com:80/

StripPrefix过滤器

StripPrefix Gateway Filter Factory
针对请求 url前缀进行处理的 filter工厂，用于去除前缀
Prefix Path Gateway Filter Factory 是用于增加前缀

server:
  port: 8080
spring:
  application:
    name: spring-cloud-gateway

spring:
  cloud:
    gateway:
      routes:
      - id: baidu_route
        uri: http://www.baidu.com
        predicates:
        - Path=/baidu/test/**
        filters:
        - StripPrefix=2

logging:
  level:
    org.springframework.cloud.gateway: TRACE
    org.springframework.http.server.reactive: DEBUG
    org.springframework.web.reactive: DEBUG
    reactor.ipc.netty: DEBUG

访问：http://localhost:8080/baidu/test
跳转到: http://www.baidu.com 。去除：/baidu/test/

Retry过滤器

对网络请求进行重试
使用重试 filter 进行重试

	@Bean
	public RouteLocator retryRouteLocator(RouteLocatorBuilder builder) {
		return builder.routes()
				.route("retry_route", r -> r.path("/test/retry")
						.filters(f ->f.retry(config -> config.setRetries(2).setStatuses(HttpStatus.INTERNAL_SERVER_ERROR)))
						.uri("http://localhost:8071/retry?key=abc&count=2"))
				.build();
	}

设置重试次数为两次
代理服务调用失败时，设置返回的状态码为 500 （服务器内部错误）

重试到 action的代码

	
	ConcurrentHashMap<String, AtomicInteger> map = new ConcurrentHashMap<>();

@GetMapping("/retry")
	public String testRetryByException(@RequestParam("key") String key, @RequestParam(name = "count") int count) {
        
		AtomicInteger num = map.computeIfAbsent(key, s -> new AtomicInteger());
        
		//对请求或重试次数计数
		int i = num.incrementAndGet();
		log.warn("重试次数: "+i);
		//计数i小于重试次数2抛出异常，让Spring Cloud Gateway进行重试
		if (i < count) {
			throw new RuntimeException("Deal with failure, please try again!");
		}
		//当重试两次时候，清空计数，返回重试两次成功
		map.clear();
		return "重试"+count+"次成功！";
	}

测试

http://localhost:8080/test/retry
第一次：AtomicInteger num 为0，num.incrementAndGet(); 为1
第二次：AtomicInteger num 为1，num.incrementAndGet(); 为2
key=abc 作为：ConcurrentHashMap 的 key 统计计数

hystrix 过滤器

熔断，自我保护，服务降级，快速失败
gateway调用后端服务，后端服务一致异常。对服务进行降级。

xml

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

yaml


server:
 port: 8080
spring:
 application:
   name: spring-cloud-gateway

spring:
 cloud:
   gateway:
     routes:
     - id: prefix_route
       uri: http://localhost:8071/test/Hystrix?isSleep=true
       predicates:
       - Path=/test/Hystrix
       filters:
       - name: Hystrix # Hystrix Filter的名称
         args: # Hystrix配置参数
           name: fallbackcmd #HystrixCommand的名字
           fallbackUri: forward:/fallback #fallback对应的uri

#Hystrix的fallbackcmd的时间
hystrix.command.fallbackcmd.execution.isolation.thread.timeoutInMilliseconds: 5000

logging:
 level:
   org.springframework.cloud.gateway: TRACE
   org.springframework.http.server.reactive: DEBUG
   org.springframework.web.reactive: DEBUG
   reactor.ipc.netty: DEBUG

本项目的回退

@RestController
public class FallbackController {

    @GetMapping("/fallback")
    public String fallback() {
        return "Spring Cloud Gateway Fallback！";
    }

}

远程请求的接口

	@GetMapping("/test/Hystrix")
	public String index(@RequestParam("isSleep") boolean isSleep) throws InterruptedException {
		log.info("issleep is " + isSleep);
		//isSleep为true开始睡眠，睡眠时间大于Gateway中的fallback设置的时间
		if (isSleep) {
			TimeUnit.MINUTES.sleep(10); //这里怎么睡成分钟了
		}
		return "No Sleep";
	}

测试

http://localhost:8080/test/Hystrix
返回：Spring Cloud Gateway Fallback！
如果改成睡4秒，返回为：No Sleep

天海华兮

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
重新定义cloud 第17章 spring cloud gateway上篇

gateway 概述基于 spring 5.0spring boot 2.0project reactor提供简单，有效且统一， api路由管理方式基于 filter 链的方式提供了网关基本的功能安全监控/埋点限流协议适配协议转发安全策略 waf防刷流量监控日志网关的核心 Filter 以及filter chain （filter 责任链）路由 route（包含）id目的 url断言工厂一组filter断言为真，则说明u
复制链接

扫一扫