Spring Cloud Gateway Predict

Spring Cloud Gateway workflow

In the initial experience of Spring Cloud Gateway in the previous article, you have a preliminary understanding of the functions of Spring Cloud Gateway. As an entrance to the traffic of a system, the Gateway plays an important role, which is usually as follows:

• Protocol translation, routing and forwarding
• Aggregates traffic, monitors traffic, and outputs logs
• As a front-end engineering of the entire system, the flow of control, the role of limited flow
• As the front-end boundary of the system, external traffic can only access the system through the gateway
• Permission can be determined at the gateway layer
• Caching can be done at the gateway layer

As the second generation Gateway of Spring Cloud framework, Spring Cloud Gateway is more powerful and has better performance than Zuul. As Spring Cloud releases, there is an official intention to abandon Zuul. In the author called the use and function of Spring Cloud Gateway, the cost of Spring Cloud Gateway to replace Zuul is very low, almost seamless switching. Spring Cloud Gateway includes almost all of Zuul’s features.

Note: This picture is from the official website

As shown in the figure above, the client makes a request to the Spring Cloud Gateway. If the Gateway Handler Mapping determines that the request matches the route (predicate is used in this case), it is sent to the Gateway Web Handler for processing. The Gateway Web Handler processes requests through a chain of filters. The reason the filter chain is divided by a dotted line is that the filter chain can perform the filtering logic before or after sending the proxy request. All the “pre” filter logic is executed and then the proxy request is made. After the proxy request is made, the “POST” filter logic is executed upon receiving the response from the proxy service. This is very similar to zuul’s process. When all the pre filter logic is executed, functions such as authentication, traffic limiting, log output, request header change, and protocol conversion are performed. After forwarding and receiving the response, all the logic of the “POST” filter is executed, where the response data can be modified, such as the response header, protocol transformation, and so on.

An important aspect of this process is the matching of requests and routes. In this case, predicate is used, which determines which route a request goes to.

Introduction of predicate

Predicate of actual combat

Now, predicate will be explained in the form of cases. The cases in this article are basically from the official documents, and the official document address is: http://cloud.spring.io/spring-cloud-static/spring-cloud-gateway/2.0.0.RELEASE/single/spring-cloud-gateway.html; If you have any questions, please let me know and discuss with me.

Create a project and import the Spring Cloud Gateway in the project POM file to start with the spring-cloud-starter- Gateway, spring Cloud version and Spring Boot version, code as follows:

<parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.0.5. </version> </parent> <dependencyManagement> <dependencies> <dependencies> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-dependencies</artifactId> <version>Finchley.SR1</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-gateway</artifactId> </dependency>Copy the code

After Route Predicate Factory

server: port: 8081 spring: profiles: active: after_route --- spring: cloud: gateway: routes: - id: after_route uri: http://httpbin.org:80/get predicates: T17 - After = 2017-01-20:42:47. 789 - from America/Denver profiles: after_routeCopy the code

Header Route Predicate Factory

Header Route Predicate Factory takes two arguments, one is the name of the Header, and the other is the value of the Header, which can be a regular expression. When this assertion matches the request header name and value, the assertion passes into the router’s rule.

Add the following configuration to the project configuration file:

spring:
  profiles:
    active: header_route

---
spring:
  cloud:
    gateway:
      routes:
      - id: header_route
        uri: http://httpbin.org:80/get
        predicates:
        - Header=X-Request-Id, \d+
  profiles: header_route


Copy the code

In the above configuration, if the Request Header contains the x-request-id Header and the Header value is a number, the Request will be routed to the configured URI. Using curl, run the following command:

$ curl -H 'X-Request-Id:1' localhost:8081

Copy the code

After the command is executed, the correct request result is returned, but the result is omitted. If the x-request-id header is not included in the Request and the value is not a number, the Request will report 404 and the route will not be forwarded correctly.

Cookie Route Predicate Factory

spring:
  profiles:
    active: cookie_route


---
spring:
  cloud:
    gateway:
      routes:
      - id: cookie_route
        uri: http://httpbin.org:80/get
        predicates:
        - Cookie=name, forezp
  profiles: cookie_route

Copy the code

$ curl -H 'Cookie:name=forezp' localhost:8081

Copy the code

Host Route Predicate Factory

The Host Route Predicate Factory takes a parameter called hostname, which can use. * to match the Host. This parameter matches the value of host in the request header, and if it does, the request is forwarded correctly.

In the project configuration file, add the following configuration:

spring:
  profiles:
    active: host_route
---
spring:
  cloud:
    gateway:
      routes:
      - id: host_route
        uri: http://httpbin.org:80/get
        predicates:
        - Host=**.fangzhipeng.com
  profiles: host_route
Copy the code

In the above configuration, requests with Host fangzhipeng.com in the request header will be routed to the configured URI. Start the project, execute the following curl command, and the request will return the correct result:

curl -H 'Host:www.fangzhipeng.com' localhost:8081

Copy the code

Method Route Predicate Factory

spring:
  profiles:
    active: method_route

---
spring:
  cloud:
    gateway:
      routes:
      - id: method_route
        uri: http://httpbin.org:80/get
        predicates:
        - Method=GET
  profiles: method_route


Copy the code

$ curl localhost:8081

Copy the code

$ curl -XPOST localhost:8081

Copy the code

Path Route Predicate Factory

The Path Route Predicate Factory takes one argument: a SPEL expression that applies the matching Path.

In the project configuration file application.yml, do the following:

spring:
  profiles:
    active: path_route
---
spring:
  cloud:
    gateway:
      routes:
      - id: path_route
        uri: http://httpbin.org:80/get
        predicates:
        - Path=/foo/{segment}
  profiles: path_route

Copy the code

In the above configuration, all requests that meet /foo/{segment} will be matched and routed, such as /foo/1, /foo/bar, will be matched and forwarded successfully.

Use curl to simulate a request localhost:8081/foo/dew and return the correct request result.

$ curl localhost:8081/foo/dew

Copy the code

Query Route Predicate Factory

spring:
  profiles:
    active: query_route
---
spring:
  cloud:
    gateway:
      routes:
      - id: query_route
        uri: http://httpbin.org:80/get
        predicates:
        - Query=foo, ba.
  profiles: query_route

Copy the code

$ curl localhost:8081? foo=barCopy the code

spring:
  cloud:
    gateway:
      routes:
      - id: query_route
        uri: http://httpbin.org:80/get
        predicates:
        - Query=foo
  profiles: query_route

Copy the code

conclusion

In this article, we first introduced the workflow and principles of Spring Cloud Gateway, then introduced the Gateway framework built into predict and its classification, and finally highlighted several important predicts using case studies. As an assertion, Predict determines which router the request will be routed to. After the assertion, the request is entered into the logic of the Filter filter, which the next article will cover in relation to Spring Cloud Gateway filters.

The resources

Download the source code

https://github.com/forezp/SpringCloudLearning/tree/master/sc-f-gateway-predicate

Welcome to follow my public account



Scan code to pay attention to the public number has a surprise

(Please note the author and source of the article on the blog of Fang Zhipeng)

This article is [original] article, reprint please indicate the source.


This paper links: https://www.fangzhipeng.com/springcloud/2018/12/05/sc-f-gateway2/


This article from the
Fang Zhipeng’s blog