<dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-gateway</artifactId>
    </dependency>
  </dependencies>

@SpringBootApplication
public class GateWayApplication {

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

  @Bean
  @Order(-1)
  public GlobalFilter a() {
    return (exchange, chain) -> {

      return chain.filter(exchange).then(Mono.fromRunnable(() -> {
        System.out.println(-1);
      }));
    };
  }

  @Bean
  @Order(0)
  public GlobalFilter b() {
    return (exchange, chain) -> {

      return chain.filter(exchange).then(Mono.fromRunnable(() -> {
        System.out.println(0);
      }));
    };
  }

  @Bean
  @Order(1)
  public GlobalFilter c() {
    return (exchange, chain) -> {

      return chain.filter(exchange).then(Mono.fromRunnable(() -> {
        System.out.println(1);
      }));
    };
  }
}

server.port: 7777
spring:
 application:
  name: gateway
 cloud:
  gateway:
   discovery:
    locator:
     enabled: true
     lower-case-service-id: true
   routes:
   - id: method_route
    uri: http://127.0.0.1:9999
    predicates:
    - Method=GET
   - id: method_route
    uri: http://127.0.0.1:8006
    predicates:
    - Method=GET

spring.cloud.gateway.discovery.locator.predicates[0].name: Path
spring.cloud.gateway.discovery.locator.predicates[0].args[pattern]: "'/'+serviceId+'/**'"
spring.cloud.gateway.discovery.locator.predicates[1].name: Host
spring.cloud.gateway.discovery.locator.predicates[1].args[pattern]: "'**.foo.com'"
spring.cloud.gateway.discovery.locator.filters[0].name: Hystrix
spring.cloud.gateway.discovery.locator.filters[0].args[name]: serviceId
spring.cloud.gateway.discovery.locator.filters[1].name: RewritePath
spring.cloud.gateway.discovery.locator.filters[1].args[regexp]: "'/' + serviceId + '/(?<remaining>.*)'"
spring.cloud.gateway.discovery.locator.filters[1].args[replacement]: "'/${remaining}'"

public class DBRouteDefinitionRepository implements RouteDefinitionRepository

public class DBRouteDefinitionRepository implements RouteDefinitionRepository {
  //保存路由
  private final Map<String, RouteDefinition> routes = synchronizedMap(new LinkedHashMap<String, RouteDefinition>());
  
  private Logger log = LoggerFactory.getLogger(DBRouteDefinitionRepository.class);
  //初始標(biāo)準(zhǔn)
  private boolean init_flag = true;
  //
  private final GatewayProperties properties;
  private DynamicRouteServiceImpl service;
  

  public DBRouteDefinitionRepository(GatewayProperties properties) {
    this.properties = properties;
    this.service = new DynamicRouteServiceImpl();

  }
  
  @Override
  public Flux<RouteDefinition> getRouteDefinitions() {
    if(init_flag) {
      List<RouteDefinition> routeDefinitions = new ArrayList<>();
      List<RouteDefinition> rs = new ArrayList<>();
      try {
        routeDefinitions = service.quertAllRoutes();//從數(shù)據(jù)庫中加載route
        rs = this.properties.getRoutes();//獲得配置文件的route
        for (RouteDefinition rse : rs) {
          routeDefinitions.add(rse);
        }
        routes.clear();
        routeDefinitions.forEach(x->routes.put(x.getId(), x));
        init_flag=false;
      } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
        log.error("Init Route Fail,Can't get Routes.",e);
      }
      return Flux.fromIterable(routeDefinitions);
    }else {
      return Flux.fromIterable(routes.values());
    }
    
  }

  @Override
  public Mono<Void> delete(Mono<String> routeId) {
    return routeId.flatMap(id -> {
      if (routes.containsKey(id)) {
        routes.remove(id);
        return Mono.empty();
      }
      return Mono.defer(() -> Mono.error(new NotFoundException("RouteDefinition not found: "+routeId)));
    });
  }

  @Override
  public Mono<Void> save(Mono<RouteDefinition> route) {
    return route.flatMap( r -> {
      routes.put(r.getId(), r);
      return Mono.empty();
    });
  }
}

@Validated
public class RouteDefinition {

  @NotEmpty
  private String id = UUID.randomUUID().toString();

  @NotEmpty
  @Valid
  private List<PredicateDefinition> predicates = new ArrayList<>();

  @Valid
  private List<FilterDefinition> filters = new ArrayList<>();

  @NotNull
  private URI uri;

  private int order = 0;

  public RouteDefinition() {
  }

  public RouteDefinition(String text) {
    int eqIdx = text.indexOf('=');
    if (eqIdx <= 0) {
      throw new ValidationException("Unable to parse RouteDefinition text '" + text
          + "'" + ", must be of the form name=value");
    }

    setId(text.substring(0, eqIdx));

    String[] args = tokenizeToStringArray(text.substring(eqIdx + 1), ",");

    setUri(URI.create(args[0]));

    for (int i = 1; i < args.length; i++) {
      this.predicates.add(new PredicateDefinition(args[i]));
    }
  }

  public String getId() {
    return id;
  }

  public void setId(String id) {
    this.id = id;
  }

  public List<PredicateDefinition> getPredicates() {
    return predicates;
  }

  public void setPredicates(List<PredicateDefinition> predicates) {
    this.predicates = predicates;
  }

  public List<FilterDefinition> getFilters() {
    return filters;
  }

  public void setFilters(List<FilterDefinition> filters) {
    this.filters = filters;
  }

  public URI getUri() {
    return uri;
  }

  public void setUri(URI uri) {
    this.uri = uri;
  }

  public int getOrder() {
    return order;
  }

  public void setOrder(int order) {
    this.order = order;
  }

  @Override
  public boolean equals(Object o) {
    if (this == o) {
      return true;
    }
    if (o == null || getClass() != o.getClass()) {
      return false;
    }
    RouteDefinition routeDefinition = (RouteDefinition) o;
    return Objects.equals(id, routeDefinition.id)
        && Objects.equals(predicates, routeDefinition.predicates)
        && Objects.equals(order, routeDefinition.order)
        && Objects.equals(uri, routeDefinition.uri);
  }

  @Override
  public int hashCode() {
    return Objects.hash(id, predicates, uri);
  }

  @Override
  public String toString() {
    return "RouteDefinition{" + "id='" + id + '\'' + ", predicates=" + predicates
        + ", filters=" + filters + ", uri=" + uri + ", order=" + order + '}';
  }

}