WARNING

This Project Is Archives,Can't catch up the spring-cloud-version.But the code and the thought is much more useful for who want adapt spring-cloud-gateway to his own project

spring-cloud-gateway-plugin

Spring Cloud Gateway Extra Plugin

Current Version

Gateway Version	Plugin Version
Greenwich.SR1	2.1.SR1.3.RELEASE
Greenwich.SR2	2.1.SR2.2.RELEASE

More Detail See Wiki

This Plugin Support Below Features:

• Cache Request Body And Form Body
• Add Request Log Filter To Log Request And Response
• Add Read Json Response Body And Log Response Body
• Add Global Exception Handler With Json
• Add Custom Exception Handler
• Add Grey Route With Ribbon And Eureka
• Each Route Use different Hystrix CommandKey
• Support Dynamic Predicate With Existing Routes

How To Use This Feature

Note:

• This Dependency Base Spring Cloud Gateway[Greenwich.SR1],Suggest To Update To This SpringCloud Version,Official Resolve Some Issues , Fix Some Bugs.
• The SpringBoot Version need to update to [2.1.6.RELEASE],It fix reactor-netty issues
• This Dependency Is Now In Maven Central.
• The Feature To Read Request And Response Json Data Will Loss A Lot Of Performance,It Will Reduce The Gateway Traffic.

Step

• 1 . Include Dependency

  Spring Cloud Gateway

  <dependencies>
      <dependency>
          <groupId>org.springframework.cloud</groupId>
          <artifactId>spring-cloud-starter-gateway</artifactId>
      </dependency>
      <!--If you need to use grey route,you should add next dependency ,but grey route only can be used with eureka discover-->
      <dependency>
          <groupId>org.springframework.cloud</groupId>
          <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
      </dependency>
  </dependencies>
  
  <dependencyManagement>
      <dependencies>
          <dependency>
              <groupId>org.springframework.cloud</groupId>
              <artifactId>spring-cloud-dependencies</artifactId>
              <version>Greenwich.SR1</version>
              <type>pom</type>
              <scope>import</scope>
          </dependency>
      </dependencies>
  </dependencyManagement>

  Gateway Plugin

  <dependency>
      <groupId>pro.chenggang</groupId>
      <artifactId>spring-cloud-gateway-plugin</artifactId>
      <version>2.1.SR1.1.RELEASE</version>
  </dependency>

• 2 . Add Enable Annotation To You Application

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

  Note: If You User SpringBoot 2.1.0+,You should set allow-bean-definition-overriding to true

  spring:
    main:
      allow-bean-definition-overriding: true

• 3 . Choose Plugin Feature To Use

  By use this annotation @EnableGatewayPlugin to enable the plugin,the plugin support switch to choose feature By default,the GatewayContext Filter is always into system

  spring:
    profiles:
      active: dev
    cloud:
      gateway:
        plugin:
          config:
            log-request: true
            read-request-data: true # this setting will read all request data
            read-response-data: true
            exception-json-handler: true
            enable-dynamic-route: true
          grey:
            enable: false
            grey-ribbon-rule: weight_response

• 4 . Specific Setting To Enable Read Request Data

  spring:
    cloud:
      gateway:
        plugin:
          config:
            read-request-data-service-id-list:  #set specific serviceId from discover to read request Data
              - serviceId1
              - serviceId2
            read-request-data-path-list:        #set specific path to read request data
              - /service/path1/*
              - /service/path2/**
              - /service/path3  

• 5 . User GatewayContext

  You Can Use GatewayContext To Get Cache JsonBody Or Form Body,Just Use

  GatewayContext gatewayContext = exchange.getAttribute(GatewayContext.CACHE_GATEWAY_CONTEXT);

• 6 . The Deference Between GreyRibbonRule.DEFAULT And GreyRibbonRule.WeightResponse

  The Default GreyRibbonRule Just Use Round Rule As Base Ribbon Rule The WeightResponse GreyRibbonRule Use WeightResponse Rule As Base Ribbon Rule

• 7 . The Grey Route

  • Setup Gateway Properties

  spring:
    cloud:
      gateway:
        plugin:
            grey:
              grey-rule-list:
                - service-id: privider1
                  version: 2.0.0
                  operation: OR
                  rules:
                    - key: key1
                      value:
                        - value1
                        - value2
                        - value3
                    - key: key2
                      value:
                        - value4
                        - value5
                        - value6
                - service-id: provider2
                  version: 2.0.0
                  operation: AND
                  rules:
                    - key: keya
                      value:
                        - value1a
                        - value2a
                        - value3a
                    - key: keyb
                      value:
                        - value4b
                        - value5b
                        - value6b
      

  • Set Up Service MetaInfo

    #proiver1
    eureka:
      instance:
        metadata-map:
          version: 2.0.0 

  • The Properties Active Rule Principle

    When Request URL Route To Provider1,When The Request JsonBody Or Form Data Contain The Key ->Key1 And Match Any Of The Value->[value1,value2,value3] The Route The Request To The Service Which Setup The MetaInfo With Specific Version Which Match The Gateway Grey Setup

• 8 . How To Custom GlobalException Handler With Json

  In Order To Handle Other Exception,You Can Define Specific Bean Implements ExceptionHandlerStrategy By default,plugin supply DefaultExceptionHandlerStrategy In Case Of None Strategy Exist

  @Slf4j
  public class DefaultExceptionHandlerStrategy implements ExceptionHandlerStrategy {
  
      @Override
      public Class getHandleClass() {
          return Throwable.class;
      }
  
      @Override
      public ExceptionHandlerResult handleException(Throwable throwable) {
          ResponseResult<String> responseResult = new ResponseResult<>(SystemResponseInfo.GATEWAY_ERROR,throwable.getMessage());
          ExceptionHandlerResult result = new ExceptionHandlerResult(HttpStatus.INTERNAL_SERVER_ERROR, JSON.toJSONString(responseResult));
          log.debug("[DefaultExceptionHandlerStrategy]Handle Exception:{},Result:{}",throwable.getMessage(),result);
          log.error("[DefaultExceptionHandlerStrategy]Log Exception In Error Level,Exception Message:{}",throwable.getMessage());
          return result;
      }
  }

  Or You Can Use @ExceptionHandler just like below,

  The@ResponseStatus is optional,if you don't add @ResponseStatus,the default HttpStatus is HttpStatus.BAD_GATEWAY

  @Component
  public class DemoExceptionHandler {
  
      @ExceptionHandler({NotFoundException.class})
      @ResponseStatus(HttpStatus.NOT_FOUND)
      public Map handlerException(ServerWebExchange exchange,TimeoutException throwable){
          LinkedHashSet<URI> originalRequestUris = exchange.getAttributeOrDefault(ServerWebExchangeUtils.GATEWAY_ORIGINAL_REQUEST_URL_ATTR,null);
          Map map = Maps.newHashMapWithExpectedSize(2);
          map.put("URI",originalRequestUris);
          map.put("ExceptionMessage",throwable.getClass().getSimpleName());
          return map;
      }
    
      @ExceptionHandler({ClientException.class, TimeoutException.class})
      @ResponseStatus(HttpStatus.BAD_GATEWAY)
      public Map handlerException(ServerWebExchange exchange,TimeoutException throwable){
            LinkedHashSet<URI> originalRequestUris = exchange.getAttributeOrDefault(ServerWebExchangeUtils.GATEWAY_ORIGINAL_REQUEST_URL_ATTR,null);
            Map map = Maps.newHashMapWithExpectedSize(2);
            map.put("URI",originalRequestUris);
            map.put("ExceptionMessage",throwable.getClass().getSimpleName());
            return map;
      }
  }

• 9 . How To Use Dynamic Predicate With Existing Routes

  • Define A Component Implements DynamicRouteProcessor,this processor process serverWebExchange for dynamic route predicate

  the DynamicRouteProcessor definition

  /**
   * Process ServerWebExchange for dynamic route predicate
   * @author chenggang
   * @date 2019/07/17
   */
  public interface DynamicRouteProcessor<T> {
  
      /**
       * preprocess action
       * @param exchange ServerWebExchange
       * @return process Result ,if result is Optional.empty(),then dynamic predicate not working
       */
      Optional<PreprocessResult<T>> preprocess(ServerWebExchange exchange);
  
      /**
       * process to unify config for predicate
       * @param preprocessResult pre process result
       * @param route current route
       * @return
       */
      Optional<DynamicRouteConfig> processConfig(PreprocessResult<T> preprocessResult, Route route);
  
      /**
       * target predicate bean 's class
       * @return RoutePredicateFactory Class
       */
      Optional<Class< ? extends AbstractRoutePredicateFactory>> targetPredicateBeanClass();
  }

  custom dynamic route processor

  @Component
  public class CustomDynamicRouteProcessor implements DynamicRouteProcessor {
  
      @Override
      public Optional<PreprocessResult> preprocess(ServerWebExchange exchange) {
          String route = exchange.getRequest().getHeaders().getFirst("route");
          if(StringUtils.isBlank(route)){
              return Optional.of(PreprocessResult.builder().result(false).build());
          }
          return Optional.of(PreprocessResult.builder().result(true).resultData(route).build());
      }
  
      @Override
      public Optional<DynamicRouteConfig> processConfig(PreprocessResult preprocessResult, Route route) {
          if(!preprocessResult.getResult()){
              return Optional.empty();
          }
          Object resultData = preprocessResult.getResultData();
          if(!(resultData instanceof String)){
              return Optional.empty();
          }
          String data = (String) resultData;
          DemoDynamicRoutePredicateFactory.Config config = DemoDynamicRoutePredicateFactory.Config.builder().header(data).route(route).build();
          return Optional.of(config);
      }
  
      @Override
      public Optional<Class<? extends AbstractRoutePredicateFactory>> targetPredicateBeanClass() {
          return Optional.of(DemoDynamicRoutePredicateFactory.class);
      }
  }

  Define a AbstractRoutePredicateFactory ,the Config Class Must Implements DynamicRouteConfig

  @Slf4j
  @Component
  public class DemoDynamicRoutePredicateFactory extends AbstractRoutePredicateFactory<DemoDynamicRoutePredicateFactory.Config> {
  
      public DemoDynamicRoutePredicateFactory() {
          super(Config.class);
      }
  
      @Override
      public Predicate<ServerWebExchange> apply(Config config) {
          return exchange -> {
              Route route = config.getRoute();
              if(Objects.isNull(route.getUri())){
                  log.debug("Route Uri Is NUll Return False,RouteID:{}",route.getId());
                  return false;
              }
              String routeUriHost = route.getUri().getHost();
              String headerData = config.getHeader();
              if(StringUtils.isBlank(routeUriHost) || StringUtils.isBlank(headerData)){
                  log.debug("Route Uri Host Or HeaderData Is Blank Return False,RouteID:{}",route.getId());
                  return false;
              }
              if(routeUriHost.equalsIgnoreCase(headerData)){
                  log.debug("Route Uri Host Matched Header Data Return True,RouteID:{}",route.getId());
                  route.getFilters();
                  return true;
              }
              log.debug("Route Uri Not Matched Return False,RouteID:{}",route.getId());
              return false;
          };
      }
  
      @Getter
      @Setter
      @Builder
      @ToString
      @AllArgsConstructor
      public static class Config implements DynamicRouteConfig {
  
          private Route route;
          private String header;
  
      }
  }

  This Feature Support dynamic predicate with existing routes,Fox example: You can according the custom header to match the loadbalance route,

  • More logical detail to see DynamicRoutePredicateHandlerMapping