Spring Cloud Gateway
Spring Cloud Gateway 是 Spring Cloud 的一個全新專案，該專案是基於 Spring 5.0，Spring Boot 2.0 和 Project Reactor 等技術開發的閘道器，它旨在為微服務架構提供一種簡單有效的統一的 API 路由管理方式。
Spring Cloud Gateway 作為 Spring Cloud 生態系統中的閘道器，目標是替代 Netflix Zuul，其不僅提供統一的路由方式，並且基於 Filter 鏈的方式提供了閘道器基本的功能，例如：安全，監控/指標，和限流。
相關概念:
- Route（路由）：這是閘道器的基本構建塊。它由一個 ID，一個目標 URI，一組斷言和一組過濾器定義。如果斷言為真，則路由匹配。
- Predicate（斷言）：這是一個 Java 8 的 Predicate。輸入型別是一個 ServerWebExchange。我們可以使用它來匹配來自 HTTP 請求的任何內容，例如 headers 或引數。
- Filter（過濾器）：這是
org.springframework.cloud.gateway.filter.GatewayFilter的例項，我們可以使用它修改請求和響應。
工作流程：
客戶端向 Spring Cloud Gateway 發出請求。如果 Gateway Handler Mapping 中找到與請求相匹配的路由，將其傳送到 Gateway Web Handler。Handler 再通過指定的過濾器鏈來將請求傳送到我們實際的服務執行業務邏輯，然後返回。 過濾器之間用虛線分開是因為過濾器可能會在傳送代理請求之前（“pre”）或之後（“post”）執行業務邏輯。
Spring Cloud Gateway 的特徵：
- 基於 Spring Framework 5，Project Reactor 和 Spring Boot 2.0
- 動態路由
- Predicates 和 Filters 作用於特定路由
- 整合 Hystrix 斷路器
- 整合 Spring Cloud DiscoveryClient
- 易於編寫的 Predicates 和 Filters
- 限流
- 路徑重寫
快速上手
引入spring-boot 2.1.1.RELEASE ，springcloud的版本為 Greenwich.M3
<parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.1.1.RELEASE</version> <relativePath/> <!-- lookup parent from repository --> </parent> <properties> <java.version>1.8</java.version> <spring-cloud.version>Greenwich.M3</spring-cloud.version> </properties> <dependencyManagement> <dependencies> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-dependencies</artifactId> <version>${spring-cloud.version}</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement>
新增的依賴包如下
<dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-gateway</artifactId> </dependency> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-netflix-hystrix</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-webflux</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis-reactive</artifactId> </dependency>
注意springcloud gateway使用的web框架為webflux，和springMVC不相容。引入的限流元件是hystrix。redis底層不再使用jedis，而是lettuce。
路由斷言
接下來就是配置了，可以使用java程式碼硬編碼配置路由過濾器，也可以使用yml配置檔案配置。下面我們首先介紹配置檔案配置方式
application.yml
server.port: 8082
spring:
application:
name: gateway
cloud:
gateway:
routes:
- id: path_route
uri: http://localhost:8000
order: 0
predicates:
- Path=/foo/**
filters:
- StripPrefix=1
上面給出了一個根據請求路徑來匹配目標uri的例子，如果請求的路徑為/foo/bar，則目標uri為 http://localhost:8000/bar。如果上面例子中沒有加一個StripPrefix=1過濾器，則目標uri 為http://localhost:8000/foo/bar，StripPrefix過濾器是去掉一個路徑。
其他的路由斷言和過濾器使用方法請檢視官網
接下來我們來看一下設計一個閘道器應該需要的一些功能
修改介面返回報文
因為閘道器路由的介面返回報文格式各異，並且閘道器也有有一些限流、認證、熔斷降級的返回報文，為了統一這些報文的返回格式，閘道器必須要對介面的返回報文進行修改，過濾器程式碼如下：
package org.gateway.filter.global; import java.nio.charset.Charset; import org.gateway.response.Response; import org.reactivestreams.Publisher; import org.springframework.cloud.gateway.filter.GatewayFilterChain; import org.springframework.cloud.gateway.filter.GlobalFilter; import org.springframework.core.Ordered; import org.springframework.core.io.buffer.DataBuffer; import org.springframework.core.io.buffer.DataBufferFactory; import org.springframework.core.io.buffer.DataBufferUtils; import org.springframework.http.server.reactive.ServerHttpResponse; import org.springframework.http.server.reactive.ServerHttpResponseDecorator; import org.springframework.stereotype.Component; import org.springframework.web.server.ServerWebExchange; import com.alibaba.fastjson.JSON; import reactor.core.publisher.Flux; import reactor.core.publisher.Mono; @Component public class WrapperResponseFilter implements GlobalFilter, Ordered { @Override public int getOrder() { // -1 is response write filter, must be called before that return -2; } @Override public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) { ServerHttpResponse originalResponse = exchange.getResponse(); DataBufferFactory bufferFactory = originalResponse.bufferFactory(); ServerHttpResponseDecorator decoratedResponse = new ServerHttpResponseDecorator(originalResponse) { @Override public Mono<Void> writeWith(Publisher<? extends DataBuffer> body) { if (body instanceof Flux) { Flux<? extends DataBuffer> fluxBody = (Flux<? extends DataBuffer>) body; return super.writeWith(fluxBody.map(dataBuffer -> { // probably should reuse buffers byte[] content = new byte[dataBuffer.readableByteCount()]; dataBuffer.read(content); // 釋放掉記憶體 DataBufferUtils.release(dataBuffer); String rs = new String(content, Charset.forName("UTF-8")); Response response = new Response(); response.setCode("1"); response.setMessage("請求成功"); response.setData(rs); byte[] newRs = JSON.toJSONString(response).getBytes(Charset.forName("UTF-8")); originalResponse.getHeaders().setContentLength(newRs.length);//如果不重新設定長度則收不到訊息。 return bufferFactory.wrap(newRs); })); } // if body is not a flux. never got there. return super.writeWith(body); } }; // replace response with decorator return chain.filter(exchange.mutate().response(decoratedResponse).build()); } }
需要注意的是order需要小於-1，需要先於NettyWriteResponseFilter過濾器執行。
有了一個這樣的過濾器，我們就可以統一返回報文格式了。
認證
以下提供一個簡單的認證過濾器
package org.gateway.filter.global; import java.nio.charset.StandardCharsets; import org.gateway.response.Response; import org.springframework.cloud.gateway.filter.GatewayFilterChain; import org.springframework.cloud.gateway.filter.GlobalFilter; import org.springframework.core.io.buffer.DataBuffer; import org.springframework.http.HttpStatus; import org.springframework.http.server.reactive.ServerHttpResponse; import org.springframework.stereotype.Component; import org.springframework.web.server.ServerWebExchange; import com.alibaba.fastjson.JSON; import reactor.core.publisher.Mono; @Component public class AuthFilter implements GlobalFilter{ @Override public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) { String token = exchange.getRequest().getHeaders().getFirst("token"); if ("token".equals(token)) { return chain.filter(exchange); } ServerHttpResponse response = exchange.getResponse(); Response data = new Response(); data.setCode("401"); data.setMessage("非法請求"); byte[] datas = JSON.toJSONString(data).getBytes(StandardCharsets.UTF_8); DataBuffer buffer = response.bufferFactory().wrap(datas); response.setStatusCode(HttpStatus.UNAUTHORIZED); response.getHeaders().add("Content-Type", "application/json;charset=UTF-8"); return response.writeWith(Mono.just(buffer)); } }
限流
springcloud gateway 為我們提供了限流過濾器RequestRateLimiterGatewayFilterFactory，和限流的實現類RedisRateLimiter使用令牌桶限流。但是官方的不一定滿足我們的需求，所以我們重新寫一個過濾器（基本和官方一致），只是將官方的返回報文改了。
package org.gateway.limiter; import java.nio.charset.StandardCharsets; import java.util.Map; import org.gateway.response.Response; import org.springframework.cloud.gateway.filter.GatewayFilter; import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory; import org.springframework.cloud.gateway.filter.ratelimit.KeyResolver; import org.springframework.cloud.gateway.filter.ratelimit.RateLimiter; import org.springframework.cloud.gateway.route.Route; import org.springframework.cloud.gateway.support.ServerWebExchangeUtils; import org.springframework.core.io.buffer.DataBuffer; import org.springframework.http.HttpStatus; import org.springframework.http.server.reactive.ServerHttpResponse; import com.alibaba.fastjson.JSON; import reactor.core.publisher.Mono; /** * User Request Rate Limiter filter. See https://stripe.com/blog/rate-limiters and */ public class RateLimiterGatewayFilterFactory extends AbstractGatewayFilterFactory<RateLimiterGatewayFilterFactory.Config> { public static final String KEY_RESOLVER_KEY = "keyResolver"; private final RateLimiter defaultRateLimiter; private final KeyResolver defaultKeyResolver; public RateLimiterGatewayFilterFactory(RateLimiter defaultRateLimiter, KeyResolver defaultKeyResolver) { super(Config.class); this.defaultRateLimiter = defaultRateLimiter; this.defaultKeyResolver = defaultKeyResolver; } public KeyResolver getDefaultKeyResolver() { return defaultKeyResolver; } public RateLimiter getDefaultRateLimiter() { return defaultRateLimiter; } @SuppressWarnings("unchecked") @Override public GatewayFilter apply(Config config) { KeyResolver resolver = (config.keyResolver == null) ? defaultKeyResolver : config.keyResolver; RateLimiter<Object> limiter = (config.rateLimiter == null) ? defaultRateLimiter : config.rateLimiter; return (exchange, chain) -> { Route route = exchange.getAttribute(ServerWebExchangeUtils.GATEWAY_ROUTE_ATTR); return resolver.resolve(exchange).flatMap(key -> // TODO: if key is empty? limiter.isAllowed(route.getId(), key).flatMap(response -> { for (Map.Entry<String, String> header : response.getHeaders().entrySet()) { exchange.getResponse().getHeaders().add(header.getKey(), header.getValue()); } if (response.isAllowed()) { return chain.filter(exchange); } ServerHttpResponse rs = exchange.getResponse(); Response data = new Response(); data.setCode("101"); data.setMessage("訪問過快"); byte[] datas = JSON.toJSONString(data).getBytes(StandardCharsets.UTF_8); DataBuffer buffer = rs.bufferFactory().wrap(datas); rs.setStatusCode(HttpStatus.UNAUTHORIZED); rs.getHeaders().add("Content-Type", "application/json;charset=UTF-8"); return rs.writeWith(Mono.just(buffer)); })); }; } public static class Config { private KeyResolver keyResolver; private RateLimiter rateLimiter; private HttpStatus statusCode = HttpStatus.TOO_MANY_REQUESTS; public KeyResolver getKeyResolver() { return keyResolver; } public Config setKeyResolver(KeyResolver keyResolver) { this.keyResolver = keyResolver; return this; } public RateLimiter getRateLimiter() { return rateLimiter; } public Config setRateLimiter(RateLimiter rateLimiter) { this.rateLimiter = rateLimiter; return this; } public HttpStatus getStatusCode() { return statusCode; } public Config setStatusCode(HttpStatus statusCode) { this.statusCode = statusCode; return this; } } }
然後限流必須要有一個key，根據什麼來進行限流，ip，介面，或者使用者來進行限流，所以我們自定義一個KeyResolver
package org.gateway.limiter; import org.springframework.cloud.gateway.filter.ratelimit.KeyResolver; import org.springframework.web.server.ServerWebExchange; import com.alibaba.fastjson.JSON; import reactor.core.publisher.Mono; public class CustomKeyResolver implements KeyResolver { public static final String BEAN_NAME = "customKeyResolver"; @Override public Mono<String> resolve(ServerWebExchange exchange) { return Mono.just(getKey(exchange)); } /** * * @param exchange * @return */ private String getKey(ServerWebExchange exchange) { LimitKey limitKey = new LimitKey(); limitKey.setApi(exchange.getRequest().getPath().toString()); limitKey.setBiz(exchange.getRequest().getQueryParams().getFirst("biz")); return JSON.toJSONString(limitKey); } }
最後RedisRateLimiter我們也需要重寫，因為不支援多級限流，原生的只會判斷一個key。程式碼如下：
/** * This uses a basic token bucket algorithm and relies on the fact that Redis scripts * execute atomically. No other operations can run between fetching the count and * writing the new count. */ @Override public Mono<Response> isAllowed(String routeId, String id) { if (!this.initialized.get()) { throw new IllegalStateException("RedisRateLimiter is not initialized"); } LimitConfig limitConfig = getLimitConfig(routeId); if (limitConfig == null || limitConfig.getTokenConfig().size()==0) { return Mono.just(new Response(true,null)); } Map<String, Config> conf = limitConfig.getTokenConfig(); LimitKey limitKey = JSON.parseObject(id, LimitKey.class); //api限流 String api = limitKey.getApi(); Config apiConf = conf.get(api); //業務方限流 String biz = limitKey.getBiz(); Config bizConf = conf.get(biz); if (apiConf!=null) { return isSingleAllow(api,routeId,apiConf).flatMap(res -> { if (res.isAllowed()) { if(bizConf!=null) { return isSingleAllow(biz, routeId, bizConf); }else { return Mono.just(new Response(true,new HashMap<>())); } }else { return Mono.just(res); } } ); }else { if (bizConf!=null) { return isSingleAllow(biz, routeId, bizConf); }else { return Mono.just(new Response(true,new HashMap<>())); } } } /** * 單級限流 * @param api * @param routeId * @param apiConf * @return */ private Mono<Response> isSingleAllow(String key, String routeId, Config config) { // How many requests per second do you want a user to be allowed to do? int replenishRate = config.getReplenishRate(); // How much bursting do you want to allow? int burstCapacity = config.getBurstCapacity(); try { List<String> keys = getKeys(routeId+"$"+key); // The arguments to the LUA script. time() returns unixtime in seconds. List<String> scriptArgs = Arrays.asList(replenishRate + "", burstCapacity + "", Instant.now().getEpochSecond() + "", "1"); // allowed, tokens_left = redis.eval(SCRIPT, keys, args) Flux<List<Long>> flux = this.redisTemplate.execute(this.script, keys, scriptArgs); // .log("redisratelimiter", Level.FINER); return flux.onErrorResume(throwable -> Flux.just(Arrays.asList(1L, -1L))) .reduce(new ArrayList<Long>(), (longs, l) -> { longs.addAll(l); return longs; }) .map(results -> { boolean allowed = results.get(0) == 1L; Long tokensLeft = results.get(1); Response response = new Response(allowed, getHeaders(config, tokensLeft)); if (log.isDebugEnabled()) { log.debug("response: " + response); } return response; }); } catch (Exception e) { /* * We don`t want a hard dependency on Redis to allow traffic. Make sure to set * an alert so you know if this is happening too much. Stripe`s observed * failure rate is 0.01%. */ log.error("Error determining if user allowed from redis", e); } return Mono.just(new Response(true, getHeaders(config, -1L))); } private LimitConfig getLimitConfig(String routeId) { Map<String, LimitConfig> map = new HashMap<>(); LimitConfig limitConfig = new LimitConfig(); limitConfig.setRouteId("rateLimit_route"); Map<String, Config> tokenMap = new HashMap<>(); Config apiConfig = new Config(); apiConfig.setBurstCapacity(5); apiConfig.setReplenishRate(5); Config bizConfig = new Config(); bizConfig.setBurstCapacity(1); bizConfig.setReplenishRate(1); tokenMap.put("/hello/rateLimit", apiConfig); tokenMap.put("jieyin", bizConfig); limitConfig.setTokenConfig(tokenMap); map.put("rateLimit_route", limitConfig); return limitConfig; }
如上的程式碼是寫死的，但是我們可以根據我們的業務需求設計一個自定義key，自定義令牌桶容量和速率的限流規則。
bean配置和yml配置如下
@Bean @Primary public CustomRedisRateLimiter customRedisRateLimiter(ReactiveRedisTemplate<String, String> redisTemplate, @Qualifier(RedisRateLimiter.REDIS_SCRIPT_NAME) RedisScript<List<Long>> redisScript, Validator validator) { return new CustomRedisRateLimiter(redisTemplate, redisScript, validator); } @Bean public RateLimiterGatewayFilterFactory rateLimiterGatewayFilterFactory(CustomRedisRateLimiter customRedisRateLimiter, CustomKeyResolver customKeyResolver) { return new RateLimiterGatewayFilterFactory(customRedisRateLimiter, customKeyResolver); }
server.port: 8082 spring: application: name: gateway redis: host: localhost port: 6379 password: 123456 cloud: gateway: routes: - id: rateLimit_route uri: http://localhost:8000 order: 0 predicates: - Path=/foo/** filters: - StripPrefix=1 - name: RateLimiter
熔斷
當下遊介面負載很大，或者介面不通等其他原因導致超時，如果介面不熔斷的話將會影響到下游介面得不到喘息，閘道器也會因為超時連線一直掛起，很可能因為一個子系統的問題導致整個系統的雪崩。所以我們的閘道器需要設計熔斷，當因為熔斷器開啟時，閘道器將返回一個降級的應答。
熔斷配置如下：
server.port: 8082 spring: application: name: gateway redis: host: localhost port: 6379 password: 123456 cloud: gateway: routes: - id: rateLimit_route uri: http://localhost:8000 order: 0 predicates: - Path=/foo/** filters: - StripPrefix=1 - name: RateLimiter - name: Hystrix args: name: fallbackcmd fallbackUri: forward:/fallback
hystrix.command.fallbackcmd.execution.isolation.thread.timeoutInMilliseconds: 5000
package org.gateway.controller; import org.gateway.response.Response; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RestController; @RestController public class FallbackController { @GetMapping("/fallback") public Response fallback() { Response response = new Response(); response.setCode("100"); response.setMessage("服務暫時不可用"); return response; } }
注意需要設定commandKey的超時時間。其他的hystrix配置請訪問Hystrix wiki.
動態配置路由和過濾器
最後我們來看一下如何動態配置路由和過濾器。
定義路由實體
/** * Gateway的路由定義模型 */ public class GatewayRouteDefinition { /** * 路由的Id */ private String id; /** * 路由斷言集合配置 */ private List<GatewayPredicateDefinition> predicates = new ArrayList<>(); /** * 路由過濾器集合配置 */ private List<GatewayFilterDefinition> filters = new ArrayList<>(); /** * 路由規則轉發的目標uri */ private String uri; /** * 路由執行的順序 */ private int order = 0; }
路由斷言實體
/** * 路由斷言定義模型 */ public class GatewayPredicateDefinition { /** * 斷言對應的Name */ private String name; /** * 配置的斷言規則 */ private Map<String, String> args = new LinkedHashMap<>();
}
過濾器實體
/** * 過濾器定義模型 */ public class GatewayFilterDefinition { /** * Filter Name */ private String name; /** * 對應的路由規則 */ private Map<String, String> args = new LinkedHashMap<>(); }
路由增刪改controller
package org.gateway.controller; import java.net.URI; import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; import java.util.List; import java.util.Map; import org.gateway.model.GatewayFilterDefinition; import org.gateway.model.GatewayPredicateDefinition; import org.gateway.model.GatewayRouteDefinition; import org.gateway.route.DynamicRouteServiceImpl; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.cloud.gateway.filter.FilterDefinition; import org.springframework.cloud.gateway.handler.predicate.PredicateDefinition; import org.springframework.cloud.gateway.route.RouteDefinition; import org.springframework.util.CollectionUtils; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; import org.springframework.web.util.UriComponentsBuilder; @RestController @RequestMapping("/route") public class RouteController { @Autowired private DynamicRouteServiceImpl dynamicRouteService; /** * 增加路由 * @param gwdefinition * @return */ @PostMapping("/add") public String add(@RequestBody GatewayRouteDefinition gwdefinition) { try { RouteDefinition definition = assembleRouteDefinition(gwdefinition); return this.dynamicRouteService.add(definition); } catch (Exception e) { e.printStackTrace(); } return "succss"; } @GetMapping("/delete/{id}") public String delete(@PathVariable String id) { return this.dynamicRouteService.delete(id); } @PostMapping("/update") public String update(@RequestBody GatewayRouteDefinition gwdefinition) { RouteDefinition definition = assembleRouteDefinition(gwdefinition); return this.dynamicRouteService.update(definition); } private RouteDefinition assembleRouteDefinition(GatewayRouteDefinition gwdefinition) { RouteDefinition definition = new RouteDefinition(); List<PredicateDefinition> pdList=new ArrayList<>(); definition.setId(gwdefinition.getId()); List<GatewayPredicateDefinition> gatewayPredicateDefinitionList=gwdefinition.getPredicates(); for (GatewayPredicateDefinition gpDefinition: gatewayPredicateDefinitionList) { PredicateDefinition predicate = new PredicateDefinition(); predicate.setArgs(gpDefinition.getArgs()); predicate.setName(gpDefinition.getName()); pdList.add(predicate); } List<GatewayFilterDefinition> gatewayFilterDefinitions = gwdefinition.getFilters(); List<FilterDefinition> filterList = new ArrayList<>(); if (!CollectionUtils.isEmpty(gatewayFilterDefinitions)) { for (GatewayFilterDefinition gatewayFilterDefinition : gatewayFilterDefinitions) { FilterDefinition filterDefinition = new FilterDefinition(); filterDefinition.setName(gatewayFilterDefinition.getName()); filterDefinition.setArgs(gatewayFilterDefinition.getArgs()); filterList.add(filterDefinition); } } definition.setPredicates(pdList); definition.setFilters(filterList); URI uri = UriComponentsBuilder.fromHttpUrl(gwdefinition.getUri()).build().toUri(); definition.setUri(uri); return definition; } }
動態路由service
package org.gateway.route; import java.net.URI; import java.util.Arrays; import java.util.HashMap; import java.util.Map; import org.gateway.model.GatewayPredicateDefinition; import org.gateway.model.GatewayRouteDefinition; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.cloud.gateway.event.RefreshRoutesEvent; import org.springframework.cloud.gateway.handler.predicate.PredicateDefinition; import org.springframework.cloud.gateway.route.RouteDefinition; import org.springframework.cloud.gateway.route.RouteDefinitionWriter; import org.springframework.context.ApplicationEventPublisher; import org.springframework.context.ApplicationEventPublisherAware; import org.springframework.stereotype.Service; import org.springframework.web.util.UriComponentsBuilder; import com.alibaba.fastjson.JSON; import reactor.core.publisher.Mono; @Service public class DynamicRouteServiceImpl implements ApplicationEventPublisherAware { @Autowired private RouteDefinitionWriter routeDefinitionWriter; private ApplicationEventPublisher publisher; /** * 增加路由 * @param definition * @return */ public String add(RouteDefinition definition) { routeDefinitionWriter.save(Mono.just(definition)).subscribe(); this.publisher.publishEvent(new RefreshRoutesEvent(this)); return "success"; } /** * 更新路由 * @param definition * @return */ public String update(RouteDefinition definition) { try { this.routeDefinitionWriter.delete(Mono.just(definition.getId())); } catch (Exception e) { return "update fail,not find route routeId: "+definition.getId(); } try { routeDefinitionWriter.save(Mono.just(definition)).subscribe(); this.publisher.publishEvent(new RefreshRoutesEvent(this)); return "success"; } catch (Exception e) { return "update route fail"; } } /** * 刪除路由 * @param id * @return */ public String delete(String id) { try { this.routeDefinitionWriter.delete(Mono.just(id)); return "delete success"; } catch (Exception e) { e.printStackTrace(); return "delete fail"; } } @Override public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) { this.publisher = applicationEventPublisher; } }
上面 routeDefinitionWriter的實現預設是InMemoryRouteDefinitionRepository，將路由存在記憶體中，我們可以自己實現一個將路由存在redis中的repository。
this.publisher.publishEvent(new RefreshRoutesEvent(this));則會將CachingRouteLocator中的路由快取清空。
以上只是springcloud gateway支援的一小部分功能。
雖然springcloud gateway 才釋出不久，相關的文件還不是很完善，程式碼中充滿了TODO的地方，react程式碼友好性低。但是由於它的高效能而且是spring自己的框架，未來取代zuul不是沒有可能。