Request Marking

Java chassis implements the request marker-based governance capability using Handler. The Provider implements rate limiting, circuit breaker, and bulkhead, and the Consumer implements retry.
1. To use the request marker-based governance capability, you need to introduce the following dependencies to the code:
```
<dependency>
  <groupId>org.apache.servicecomb</groupId>
  <artifactId>handler-governance</artifactId>
</dependency>
```
2. Configure the Handler chain.
```
servicecomb:
  handler:
    chain:
      Consumer:
        default: governance-consumer,loadbalance
      Provider:
        default: governance-provider
```
Java chassis is a REST/RPC framework based on open APIs. The model is different from the REST framework. Java chassis provides REST-based and RPC-based matching. You can use the servicecomb.governance.{operation}.matchType configuration item to specify the matching rule. By default, REST-based matching is used. If the highway protocol in Java chassis is used for calling, set matchType to rpc. For example,
```
servicecomb:
  governance:
    matchType: rest #Set the global default matching mode to REST and set the highway protocol to rpc.
    GovernanceEndpoint.helloRpc:
      matchType: rpc # Set the interface helloRpc on the server to use RPC-based matching.
```
In REST-based matching, apiPath uses a URL, for example,
```
servicecomb:
  matchGroup:
    userLoginAction: |
      matches:
        - apiPath:
            exact: "/user/login"
```
In RPC-based matching, apiPath uses an operation, for example,
```
servicecomb:
  matchGroup:
    userLoginAction: |
      matches:
        - apiPath:
            exact: "UserSchema.login"
```
For server governance, such as rate limiting, the header is obtained from HTTP in REST-based matching. For client governance, such as retry, the header is obtained from InvocationContext in REST-based matching.

The following describes how to configure different governance policies and add dependencies to the POM file.

One request corresponds to one key. For example, userLoginAction is the name of a key. Multiple marking rules can be defined for one request. In each marking rule, the matching rules for apiPath, method, and headers can be defined. The relationship between marking rules is OR, and the relationship between matching rules is AND.

A series of operators are provided in match to match apiPath or headers.
- exact: exact match
- prefix: prefix match
- suffix: suffix match
- contains: whether the target string contains the scheme string
- compare: supporting the match in >, <, >=, <=, =, or != mode During the processing, the scheme string and the target string are converted into the Double type for comparison. The supported data range is the Double data range. If the difference between the values of = and != is less than 1e-6, the two values are considered equal. For example, if the scheme string is > –10, the target string greater than –10 is matched.
Request marking can be implemented at different application layers. For example, on the server that provides REST APIs, request information can be obtained through the HttpServletRequest API. The client called by the RestTemplate can obtain request information from the RestTemplate.

The methods for information extraction vary with frameworks and application layers. The implementation layer shields differences by mapping features to GovernanceRequest. In this way, the governance capability can be used in different frameworks and application layers.
```
public class GovernanceRequest {
  private Map<String, String> headers;

  private String uri;

  private String method;}
```
Spring Cloud uses Aspect to intercept the RequestMappingHandlerAdapter class to implement rate limiting, circuit breaker, and bulkhead, and intercept RestTemplate and FeignClient to implement retry.
To use the request marker-based governance capability, you need to introduce the following dependencies to the code:
```
<dependency>
  <groupId>com.huaweicloud</groupId>
  <artifactId>spring-cloud-starter-huawei-governance</artifactId>
</dependency>
```
Spring Cloud is based on the REST framework and can better match the matching semantics of marker-based governance. apiPath and headers correspond to the HTTP protocol:
```
servicecomb:
  matchGroup:
    userLoginAction: |
      matches:
        - apiPath:
            exact: "/user/login"
          method:
            - POST
        - headers:
          Authentication:             
		    prefix: Basic
```