重新定义cloud 第18章 spring cloud gateway下篇.md

刺骨的言语ヽ痛彻心扉 2022-12-24 14:54 178阅读 0赞

# gateway 基于服务发现的 路由规则 #

*  服务名 必须大写 (zookeeper,consul时，默认是小写)
 *  如果要小写，配置
    
        spring:
          application:
            name: sc-gateway-server
          cloud:
            gateway:
              discovery:
                locator:
                  enabled: true
                  lowerCaseServiceId: true

## gateway server ##

<dependencies>
            
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-gateway</artifactId>
            </dependency>
    
            
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            </dependency>
        </dependencies>

spring:
      application:
        name: sc-gateway-server
      cloud:
        gateway:
          discovery:
            locator:
              enabled: true #与服务发现组件 进行结合。开启基于服务发现的路由规则
              lowerCaseServiceId: true
    
    server:
      port: 9000 #网关服务监听 9000 端口
    eureka:
      client:
        service-url: #指定注册中心的地址，以便使用服务发现功能
          defaultZone: http://localhost:8761/eureka/
    
    logging:
      level: #调整相关包的 log 级别，以便排查问题
        org.springframework.cloud.gateway: debug

## provider ##

@RestController
    public class HelloController { 
    
        @GetMapping("/hello")
        public String hello(@RequestParam String name) { 
            return "Hello, " + name + "!";
        }
    }

## consumer ##

@RequestMapping("/hello")
    @RestController
    public class HelloController { 
    
        @Autowired
        HelloFeignService helloRemote;
    
        @GetMapping("/{name}")
        public String index(@PathVariable("name") String name)  { 
            return helloRemote.hello(name) + "\n" + new Date().toString();
        }
    }

@FeignClient(name = "sc-producer")
    public interface HelloFeignService { 
    
        @GetMapping("/hello/")
        String hello(@RequestParam(value = "name") String name);
    
    }

## 测试 ##

*  http://localhost:9000/sc-consumer/hello/zhangsan （访问的是网关的地址）
 *  访问 consumer 项目，hello接口
 *  通过feign 到 provider接口， @FeignClient(name = “sc-producer”) @GetMapping("/hello/")
 *  provider进行了返回：return helloRemote.hello(name) + “\\n” + new Date().toString();
 *  结果为：Hello, zhangsan! Tue Nov 17 16:50:03 CST 2020

# gateway filter 和 global filter #

*  filter分这两种
 *  gateway filter 概述
    
     *  从 web filter 中 复制过来，相当于一个 filter过滤器
        
         *  URL过滤
         *  横切处理（切面处理）
         *  超时
         *  安全
 *  global filter
    
     *  全局的 filter，作用于 所有 路由
 *  区别
    
     *  gateway filter 应用到 单个路由 或者 一个分组的路由上
     *  都是 Mono filter()
     *  gatewayFilter 继承 ShortcutConfigurable
     *  globalFilter没有任何继承

## 自定义 gateway filter 案例 ##

### 自定义filter (重要，统计网关响应时间) ###

/** * 统计某个或者某种路由的的处理时长 * @author xujin */
    public class CustomGatewayFilter implements GatewayFilter, Ordered { 
    
        private static final Log log = LogFactory.getLog(GatewayFilter.class);
        private static final String COUNT_Start_TIME = "countStartTime";
    
        @Override
        public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) { 
            //放入当前的时间戳
            exchange.getAttributes().put(COUNT_Start_TIME, System.currentTimeMillis());
            return chain.filter(exchange).then(//过滤后的执行
                    Mono.fromRunnable(() -> { 
                        //获取放入的时间戳
                        Long startTime = exchange.getAttribute(COUNT_Start_TIME);
                        //当前时间 - 以前放入的时间
                        Long endTime=(System.currentTimeMillis() - startTime);
                        //如果当前时间buweinull，这里判断应该放前面
                        if (startTime != null) { 
                            //打印。请求的 url ： 用了多少秒
                            log.info(exchange.getRequest().getURI().getRawPath() + ": " + endTime + "ms");
                        }
                    })
            );
        }
    
        //最后加载
        @Override
        public int getOrder() { 
            return Ordered.LOWEST_PRECEDENCE;
        }
    }

### 配置到 路由上 ###

*  Java 的 流式 API 绑定 gateway filter 和 路由

/** * @author xujin */
    @SpringBootApplication
    public class GatewayServerApplication { 
    
        @Bean
        public RouteLocator customerRouteLocator(RouteLocatorBuilder builder) { 
            return builder.routes()
                    // /test的过滤器，为 CustomeGatewayFilter uri为 这个请求，拦截顺序为0，id为
                    .route(r -> r.path("/test")
                            .filters(f -> f.filter(new CustomGatewayFilter()))
                            .uri("http://localhost:8001/customFilter?name=xujin")
                            .order(0)
                            .id("custom_filter")
                    )
                    .build();
        }
        public static void main(String[] args) { 
            SpringApplication.run(GatewayServerApplication.class, args);
        }
    }

### 配置鉴权 ###

/** * 调用鉴权 */
    @Component
    public class AuthSignatureFilter implements GlobalFilter, Ordered { 
    
        @Override
        public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) { 
            //获取 authToken 参数
            String token = exchange.getRequest().getQueryParams().getFirst("authToken");
            //如果不存在，响应401
            if (null==token  || token.isEmpty()) { 
                //当请求不携带Token或者token为空时，直接设置请求状态码为401，返回
                exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
                return exchange.getResponse().setComplete();
            }
            //否则 放行
            return chain.filter(exchange);
        }
    
        @Override
        public int getOrder() { 
            return -400;
        }
    }

### 请求到的地址 ###

@RestController
    public class HelloController { 
    
        @GetMapping("/customFilter")
        public String customFilter(@RequestParam String name) { 
            return "customFilter, " + name + "!";
        }
    }

*  测试
    
     *  http://localhost:9000/test?authToken=token

## 自定义 Global Filter 案例 ##

*  全局过滤器，对网关的 URL进行 权限校验
 *  从 上下文 ServerWebExchange对象中 获取 authToken

# Spring Cloud Gateway 实战 #

## 权重路由 ##

*  Weight Route Predicate Factory 路由断言工厂
 *  V1，和 V2 。灰度的时候，网关动态实时推送路由权重。 95% 走 V1，5% 走 V2

## gateway项目 ##

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

### yaml 配置 ###

server.port: 8080
    spring:
      application:
        name: ch18-3-gateway
      cloud:
        gateway:
          routes:
          - id: service1_v1
            uri: http://localhost:8081/v1
            predicates:
            - Path=/test #test，95
            - Weight=service1, 95
            
          - id: service1_v2
            uri: http://localhost:8081/v2
            predicates:
            - Path=/test #test, 5
            - Weight=service1, 5
    
    logging:
      level:
        org.springframework.cloud.gateway: TRACE
        org.springframework.http.server.reactive: DEBUG
        org.springframework.web.reactive: DEBUG
        reactor.ipc.netty: DEBUG

## 请求到的项目 ##

@RestController
    public class ServiceController { 
    
    	@GetMapping(value = "/v1")
    	public String v1() { 
    		return "v1";
    	}
    
    	@GetMapping(value = "/v2")
    	public String v2() { 
    		return "v2";
    	}
    }

*  访问：
    
     *  会出现权重：http://localhost:8080/test ，有很小的比例 访问v2

# https的使用技巧 #

*  Nginx 配置 SSL 证书
 *  gateway 支持 https
 *  将生成的 https 证书，放在 gateway 应用的类路径下面即可。

## gateway ##

### application.yml ###

server.port: 8080
    
    spring:
      application:
          name: sc-gateway-server
      cloud:
        gateway:
          discovery:
            locator:
               enabled: true
               lowerCaseServiceId: true
    
    server:
      ssl:
        key-alias: spring
        enabled: true
        key-password: spring
        key-store: classpath:selfsigned.jks
        key-store-type: JKS
        key-store-provider: SUN
        key-store-password: spring
    
    eureka:
      client:
        service-url:
          defaultZone: http://localhost:8761/eureka/
    
    
    logging:
      level:
        org.springframework.cloud.gateway: TRACE
        org.springframework.http.server.reactive: DEBUG
        org.springframework.web.reactive: DEBUG
        reactor.ipc.netty: DEBUG

*  selfsigned.jks 放在同目录下

## service-a 和 b 的action ##

@RestController
    public class TestController { 
    
    	@GetMapping("/test")
    	public String prefixpath(){ 
    		return "https to Http";
    	}
    }

*  访问： https://localhost:8080/service-provider/test
 *  报错： not an ssl/tls record
 *  请求进来的协议是： https，后端代理的服务是 http
 *  gateway 对外的请求是 https，对后端代理 请求是 http

## 在 LoadBalancerClienntFilter执行之前 ##

*  将 https修改为 http

/** * 在LoadBalancerClientFilter执行之前将Https修改为Http * https://github.com/spring-cloud/spring-cloud-gateway/issues/378 */
    @Component
    public class HttpsToHttpFilter implements GlobalFilter, Ordered { 
    
        private static final int HTTPS_TO_HTTP_FILTER_ORDER = 10099;
    
        @Override
        public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) { 
            //原来的请求uri对象
            URI originalUri = exchange.getRequest().getURI();
            //得到 request
            ServerHttpRequest request = exchange.getRequest();
            //构建 mutate
            ServerHttpRequest.Builder mutate = request.mutate();
            //得到 uri 请求
            String forwardedUri = request.getURI().toString();
            //如果是 https 请求
            if (forwardedUri != null && forwardedUri.startsWith("https")) { 
                //创建 http请求
                try { 
                    //属性都取原来的值
                    URI mutatedUri = new URI("http",
                            originalUri.getUserInfo(),
                            originalUri.getHost(),
                            originalUri.getPort(),
                            originalUri.getPath(),
                            originalUri.getQuery(),
                            originalUri.getFragment());
                    //放入 mutate
                    mutate.uri(mutatedUri);
                } catch (Exception e) { 
                    throw new IllegalStateException(e.getMessage(), e);
                }
            }
            //构建 request
            ServerHttpRequest build = mutate.build();
            //放行
            return chain.filter(exchange.mutate().request(build).build());
        }
    
        /** * 由于LoadBalancerClientFilter的order是10100， * 要在LoadBalancerClientFilter执行之前将Https修改为Http，需要设置 * order为10099 * @return */
        @Override
        public int getOrder() { 
            return HTTPS_TO_HTTP_FILTER_ORDER;
        }
    }

## 在 LoadBalancerClientFilter执行之后 ##

*  将 https修改成 http

/** * 在LoadBalancerClientFilter执行之后将Https修改为http */
    @Component
    public class HttpSchemeFilter implements GlobalFilter, Ordered { 
    
        private static final int HTTPS_TO_HTTP_FILTER_ORDER = 10101;
    
    
        @Override
        public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) { 
            //获取：gatewayRequestUrl 对象
            Object uriObj = exchange.getAttributes().get(GATEWAY_REQUEST_URL_ATTR);
            //如果 不为null
            if (uriObj != null) { 
                //强转为 uri
                URI uri = (URI) uriObj;
                //uri再次赋值，应该是 转成 http 类型的
                uri = this.upgradeConnection(uri, "http");
                //再次放入
                exchange.getAttributes().put(GATEWAY_REQUEST_URL_ATTR, uri);
            }
            return chain.filter(exchange);
        }
    
        private URI upgradeConnection(URI uri, String scheme) { 
            //活的到 uriComponent
            UriComponentsBuilder uriComponentsBuilder = UriComponentsBuilder.fromUri(uri).scheme(scheme);
            if (uri.getRawQuery() != null) { 
                // When building the URI, UriComponentsBuilder verify the allowed characters and does not
                // support the '+' so we replace it for its equivalent '%20'.
                // See issue https://jira.spring.io/browse/SPR-10172
                //如果不为null，就替换一些东西
                uriComponentsBuilder.replaceQuery(uri.getRawQuery().replace("+", "%20"));
            }
            //放回 uri对象
            return uriComponentsBuilder.build(true).toUri();
        }
    
        /** * 由于LoadBalancerClientFilter的order是10100， * 所以设置HttpSchemeFilter的的order是10101, * 在LoadBalancerClientFilter之后将https修改为http * @return */
        @Override
        public int getOrder() { 
            return HTTPS_TO_HTTP_FILTER_ORDER;
        }
    }

## 测试 ##

*  访问：https://localhost:8080/service-provider/test
 *  返回：https to Http，http请求，就不行了。

# 继承 swagger #

*  gateway 底层 webFlux
 *  webFlux和 swagger 不兼容

## gateway ##

### xml ###

<dependencies>
            
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-gateway</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
            </dependency>
    
            //swagger-ui
            <dependency>
                <groupId>io.springfox</groupId>
                <artifactId>springfox-swagger-ui</artifactId>
                <version>2.9.2</version>
            </dependency>
            //swagger2核心
            <dependency>
                <groupId>io.springfox</groupId>
                <artifactId>springfox-swagger2</artifactId>
                <version>2.9.2</version>
            </dependency>
        </dependencies>

### 编写 swaggerProvider ###

*  用于获取 SwaggerResources

/** * @Primary注解的实例优先于其他实例被注入 * @author xujin */
    @Component
    @Primary //实现SwaggerResourcesProvider方法
    public class GatewaySwaggerProvider implements SwaggerResourcesProvider { 
        public static final String API_URI = "/v2/api-docs";
    
        //定义这两个对象，并且 构造赋值
        private final RouteLocator routeLocator;
        private final GatewayProperties gatewayProperties;
        public GatewaySwaggerProvider(RouteLocator routeLocator, GatewayProperties gatewayProperties) { 
            this.routeLocator = routeLocator;
            this.gatewayProperties = gatewayProperties;
        }
    
        @Override
        public List<SwaggerResource> get() { 
            List<SwaggerResource> resources = new ArrayList<>();
    
            //对routes赋值
            List<String> routes = new ArrayList<>();
    
            //取出Spring Cloud Gateway中的route
            routeLocator.getRoutes().subscribe(route -> routes.add(route.getId()));
    
    
            //结合application.yml中的路由配置，只获取有效的route节点
            gatewayProperties.getRoutes().stream().filter(routeDefinition -> routes.contains(routeDefinition.getId()))
                    .forEach(routeDefinition -> routeDefinition.getPredicates().stream()
                            .filter(predicateDefinition -> ("Path").equalsIgnoreCase(predicateDefinition.getName()))
                            .forEach(predicateDefinition -> resources.add(swaggerResource(routeDefinition.getId(),
                                    predicateDefinition.getArgs().get(NameUtils.GENERATED_NAME_PREFIX + "0")
                                            .replace("/**", API_URI)))));
            return resources;
        }
    
        private SwaggerResource swaggerResource(String name, String location) { 
            SwaggerResource swaggerResource = new SwaggerResource();
            swaggerResource.setName(name);
            swaggerResource.setLocation(location);
            swaggerResource.setSwaggerVersion("2.0");
            return swaggerResource;
        }
    }

### 创建 swagger-Resource端点 ###

*  运行 swagger-UI的时候 需要依赖一些接口，需要建立相应的 swagger-Resource端点

@RestController
    @RequestMapping("/swagger-resources")
    public class SwaggerHandler { 
        @Autowired(required = false)
        private SecurityConfiguration securityConfiguration;
        @Autowired(required = false)
        private UiConfiguration uiConfiguration;
        private final SwaggerResourcesProvider swaggerResources;
    
        @Autowired
        public SwaggerHandler(SwaggerResourcesProvider swaggerResources) { 
            this.swaggerResources = swaggerResources;
        }
    
    
        @GetMapping("/configuration/security")
        public Mono<ResponseEntity<SecurityConfiguration>> securityConfiguration() { 
            return Mono.just(new ResponseEntity<>(
                    Optional.ofNullable(securityConfiguration).orElse(SecurityConfigurationBuilder.builder().build()), HttpStatus.OK));
        }
    
        @GetMapping("/configuration/ui")
        public Mono<ResponseEntity<UiConfiguration>> uiConfiguration() { 
            return Mono.just(new ResponseEntity<>(
                    Optional.ofNullable(uiConfiguration).orElse(UiConfigurationBuilder.builder().build()), HttpStatus.OK));
        }
    
        @GetMapping("")
        public Mono<ResponseEntity> swaggerResources() { 
            return Mono.just((new ResponseEntity<>(swaggerResources.get(), HttpStatus.OK)));
        }
    }

*  运行 swagger-UI 需要依赖一些接口，所以 需要建立 Swagger-Resourece端点
 *

### 创建 SwaggerHearFilter ###

*  admin/test/\{a\}/\{b\}
 *  swagger界面上会显示 test/\{a\}/\{b\}
 *  swagger会根据 X-Forwarded-Prefix这个 Header来获取 BasePath
 *  需要将它添加到 接口路径与Host之前才能正常工作
 *  Gateway 并没有将 Header添加到 Request上，导致接口出现404
 *  所以编写 过滤器来添加这个 header

@Component
    public class GwSwaggerHeaderFilter extends AbstractGatewayFilterFactory { 
        private static final String HEADER_NAME = "X-Forwarded-Prefix";
    
        @Override
        public GatewayFilter apply(Object config) { 
            return (exchange, chain) -> { 
                //获取到request
                ServerHttpRequest request = exchange.getRequest();
                //获取到 path
                String path = request.getURI().getPath();
                //如果这个 path 不包含/v2/api-docs
                if (!StringUtils.endsWithIgnoreCase(path, GatewaySwaggerProvider.API_URI)) { 
                    //就直接放行
                    return chain.filter(exchange);
                }
                //截取第一个 X-Forwarded-Prefix
                String basePath = path.substring(0, path.lastIndexOf(GatewaySwaggerProvider.API_URI));
                //重新放入 这个request里
                ServerHttpRequest newRequest = request.mutate().header(HEADER_NAME, basePath).build();
                //new 一个新的 Exchange
                ServerWebExchange newExchange = exchange.mutate().request(newRequest).build();
                //使用这个传递给 filter
                return chain.filter(newExchange);
            };
        }
    }

### applicaton.yml ###

server:
      port: 8081
    
    spring:
      application:
        name: sc-gateway
      cloud:
          gateway:
            locator:
              enabled: true #开启eureka配合
            routes:
            - id: sc-service
              uri: lb://sc-service
              predicates:
              - Path=/admin/** #访问admin
              filters:
              - GwSwaggerHeaderFilter #过滤器
              - StripPrefix=1 #除去前缀
    
    eureka:
      instance:
        prefer-ip-address: true #更喜欢ip
      client:
        service-url:
          defaultZone: http://localhost:8761/eureka/ #eureka 配置

## service ##

### xml和配置 ###

<dependencies>
            
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            
            //swagger2 核心
            <dependency>
                <groupId>io.springfox</groupId>
                <artifactId>springfox-swagger2</artifactId>
                <version>2.9.2</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
            </dependency>
        </dependencies>

bootstrap.yml
    
    server:
      port: 8055
    
    spring:
      application:
        name: sc-service
    # 注册中心配置
    eureka:
      instance:
        prefer-ip-address: true
      client:
        service-url:
          defaultZone: http://localhost:8761/eureka/

### swaggerConfig ###

@Configuration
    @EnableSwagger2
    public class SwaggerConfig { 
    
        @Bean
        public Docket createRestApi() { 
    
            return new Docket(DocumentationType.SWAGGER_2)
                    .apiInfo(apiInfo())
                    .select()
                    .apis(RequestHandlerSelectors.withMethodAnnotation(ApiOperation.class))
                    .paths(PathSelectors.any())
                    .build();
        }
    
        private ApiInfo apiInfo() { 
            return new ApiInfoBuilder()
                    .title("Swagger API")
                    .description("test")
                    .termsOfServiceUrl("")
                    .contact(new Contact("Spring Cloud China", "http://springcloud.cn", ""))
                    .version("2.0")
                    .build();
        }
    
    }

### action ###

@RestController
    @RequestMapping("/test")
    @Api("测试集成Swagger")
    public class TestController { 
    
        @ApiOperation(value = "计算+", notes = "加法")
        @ApiImplicitParams({ 
                @ApiImplicitParam(name = "a",  value = "数字a", required = true, dataType = "Long"),
                @ApiImplicitParam(name = "b",  value = "数字b", required = true, dataType = "Long")
        })
        @GetMapping("/{a}/{b}")
        public Integer get(@PathVariable Integer a, @PathVariable Integer b) { 
            return a + b;
        }
    }

*  访问，gateway的端口
    
     *  http://localhost:8081/swagger-ui.html
 *  service 接口地址[/test/\{a\}/\{b\}][test_a_b]

# gateway 限流 #

高并发

*  缓存
 *  降级
 *  限流

秒杀，抢购，评论，下单

*  限流：一旦达到限制速率，定向到友好页面。

限流框架

*  控制速率 和 控制并发

限流算法

*  令牌桶
 *  漏桶
 *  计数器：粗暴限流实现

## gateway ##

### xml ###

<dependencies>
            
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-gateway</artifactId>
            </dependency>
            
            <dependency>
                <groupId>com.github.vladimir-bukhtoyarov</groupId>
                <artifactId>bucket4j-core</artifactId>
                <version>4.0.0</version>
            </dependency>
        </dependencies>

### 自定义过滤器 对特定资源限流 ###

/** * 自定义过滤器进行限流 * @author xujin */
    public class GatewayRateLimitFilterByIp implements GatewayFilter, Ordered { 
    
        private final Logger log = LoggerFactory.getLogger(GatewayRateLimitFilterByIp.class);
    
        /** * 单机网关限流用一个ConcurrentHashMap来存储 bucket， * 如果是分布式集群限流的话，可以采用 Redis等分布式解决方案 */
        private static final Map<String, Bucket> LOCAL_CACHE = new ConcurrentHashMap<>();
    
        /** * 桶的最大容量，即能装载 Token 的最大数量 */
        int capacity;
        /** * 每次 Token 补充量 */
        int refillTokens;
        /** *补充 Token 的时间间隔 */
        Duration refillDuration;
    
        public GatewayRateLimitFilterByIp() { 
        }
    
        public GatewayRateLimitFilterByIp(int capacity, int refillTokens, Duration refillDuration) { 
            this.capacity = capacity;
            this.refillTokens = refillTokens;
            this.refillDuration = refillDuration;
        }
    
        private Bucket createNewBucket() { 
            Refill refill = Refill.of(refillTokens, refillDuration);
            Bandwidth limit = Bandwidth.classic(capacity, refill);
            return Bucket4j.builder().addLimit(limit).build();
        }
    
        @Override
        public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) { 
            String ip = exchange.getRequest().getRemoteAddress().getAddress().getHostAddress();
            Bucket bucket = LOCAL_CACHE.computeIfAbsent(ip, k -> createNewBucket());
            log.debug("IP:{} ,令牌通可用的Token数量:{} " ,ip,bucket.getAvailableTokens());
            if (bucket.tryConsume(1)) { 
                return chain.filter(exchange);
            } else { 
               //当可用的令牌书为0是，进行限流返回429状态码
                exchange.getResponse().setStatusCode(HttpStatus.TOO_MANY_REQUESTS);
                return exchange.getResponse().setComplete();
            }
        }
    
        @Override
        public int getOrder() { 
            return -1000;
        }
    
        public static Map<String, Bucket> getLocalCache() { 
            return LOCAL_CACHE;
        }
    
        public int getCapacity() { 
            return capacity;
        }
    
        public void setCapacity(int capacity) { 
            this.capacity = capacity;
        }
    
        public int getRefillTokens() { 
            return refillTokens;
        }
    
        public void setRefillTokens(int refillTokens) { 
            this.refillTokens = refillTokens;
        }
    
        public Duration getRefillDuration() { 
            return refillDuration;
        }
    
        public void setRefillDuration(Duration refillDuration) { 
            this.refillDuration = refillDuration;
        }
    }

### main ###

@SpringBootApplication
    public class GatewayApplication { 
    
        @Bean
        public RouteLocator customerRouteLocator(RouteLocatorBuilder builder) { 
            return builder.routes()
                    .route(r -> r.path("/test/rateLimit")
                            .filters(f -> f.filter(new GatewayRateLimitFilterByIp(10,1,Duration.ofSeconds(1))))
                            .uri("http://localhost:8000/hello/rateLimit")
                            .id("rateLimit_route")
                    ).build();
        }
        public static void main(String[] args) { 
            SpringApplication.run(GatewayApplication.class, args);
        }
    }

### 目标：action ###

@RequestMapping("/hello")
    @RestController
    public class HelloController { 
    
    
        @GetMapping("/rateLimit")
        public String hello() { 
            return "Hello, spring cloud Gateway";
        }
    }

## 测试： ##

*  http://localhost:8080/test/rateLimit
 *  10次非常快的请求，会出现失败的情况。服务端返回：429

## gateway 内置过滤器工厂限流 ##

*  Request Rate Limiter Gateway Filter Factory 过滤器工厂，直接限流
 *  使用这个 lua脚本实现限流
    
        \maven\org\springframework\cloud\spring-cloud-gateway-core\2.0.0.RELEASE\spring-cloud-gateway-core-2.0.0.RELEASE.jar!\
        
        META-INF\scripts\request_rate_limiter.lua

### xml ###

*  实现依赖redis，所以要引入

<dependencies>
            
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-gateway</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
            </dependency>
        </dependencies>

### 限流配置 ###

server.port: 8081
    
    spring:
      application:
        name: ch18-6-1-gateway
      redis:
          host: localhost
          port: 6379
      cloud:
        gateway:
          routes:
            - id: rateLimit_route   #id
              uri: http://localhost:8000/hello/rateLimit #分发到的uri
              order: 0
              predicates:
                - Path=/test/rateLimit #暴露的接口
              filters:
                #filter名称必须是RequestRateLimiter
                - name: RequestRateLimiter 
                  args:
                    #使用 SpEL 按名称引用bean
                    key-resolver: "#{@remoteAddrKeyResolver}"
                    #允许用户每秒处理多少个请求
                    redis-rate-limiter.replenishRate: 1
                    #令牌桶的容量，允许在一秒钟内完成的最大请求数
                    redis-rate-limiter.burstCapacity: 5
    
    logging:
      level:
        #org.springframework.cloud.gateway: debug
        cn.springcloud.book.filter: debug

### key-resolver对应的 remoteAddrKeyResolver ###

public class RemoteAddrKeyResolver implements KeyResolver { 
    
        public static final String BEAN_NAME = "remoteAddrKeyResolver";
    
        @Override
        public Mono<String> resolve(ServerWebExchange exchange) { 
            return Mono.just(exchange.getRequest().getRemoteAddress().getAddress().getHostAddress());
        }
    }

### main ###

@SpringBootApplication
    public class GatewayApplication { 
    
    
        @Bean(name = RemoteAddrKeyResolver.BEAN_NAME)
        public RemoteAddrKeyResolver remoteAddrKeyResolver() { 
            return new RemoteAddrKeyResolver();
        }
    
        public static void main(String[] args) { 
            SpringApplication.run(GatewayApplication.class, args);
        }
    }

*  http://localhost:8080/test/rateLimit

# 基于CPU的使用率 进行限流 #

*  网络请求的连接数
 *  请求流量
 *  CPU使用率
 *  通过 Spring boot actuator 提供的 metrics 获取当前的CPU使用情况，当高于某个阈值开启限流
 *  actuator 1.X 使用 systemPublicMetrics
 *  Actuator 2.X 通过MetricsEndpoint来获取

Metrics 
    英 /ˈmetrɪks/  美 /ˈmetrɪks/
    简明 柯林斯 例句  百科
    n. 度量；作诗法；韵律学

## 自定义 filter ##

/** * 根据CPU的使用情况限流 * @author: xujin **/
    @Component
    public class GatewayRateLimitFilterByCpu implements GatewayFilter, Ordered { 
    
        private final Logger log = LoggerFactory.getLogger(GatewayRateLimitFilterByCpu.class);
    
        @Autowired
        private MetricsEndpoint metricsEndpoint;
    
        private static final String METRIC_NAME = "system.cpu.usage";
    
        private static final double MAX_USAGE = 0.50D;
    
        @Override
        public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) { 
            //获取网关所在机器的CPU使用情况
            Double systemCpuUsage = metricsEndpoint.metric(METRIC_NAME, null)
                    .getMeasurements()
                    .stream()
                    .filter(Objects::nonNull)
                    .findFirst()
                    .map(MetricsEndpoint.Sample::getValue)
                    .filter(Double::isFinite)
                    .orElse(0.0D);
            //如果大于 0.5 开启限流
            boolean isOpenRateLimit = systemCpuUsage >MAX_USAGE;
            log.debug("system.cpu.usage: {}, isOpenRateLimit:{} ",systemCpuUsage , isOpenRateLimit);
            if (isOpenRateLimit) { 
                //当CPU的使用超过设置的最大阀值开启限流 429
                exchange.getResponse().setStatusCode(HttpStatus.TOO_MANY_REQUESTS);
                return exchange.getResponse().setComplete();
            } else { 
                return chain.filter(exchange);
            }
        }
    
        @Override
        public int getOrder() { 
            return 0;
        }
    
    }

## java流式API的方式配置 ##

@SpringBootApplication
    public class GatewayApplication { 
    
        @Autowired
        private GatewayRateLimitFilterByCpu gatewayRateLimitFilterByCpu;
    
        @Bean
        public RouteLocator customerRouteLocator(RouteLocatorBuilder builder) { 
            return builder.routes()
                    .route(r -> r.path("/test/rateLimit")
                            .filters(f -> f.filter(gatewayRateLimitFilterByCpu))
                            .uri("http://localhost:8000/hello/rateLimit")
                            .id("rateLimit_route")
                    ).build();
        }
        public static void main(String[] args) { 
            SpringApplication.run(GatewayApplication.class, args);
        }
    }

*  http://localhost:8082/actuator/metrics/system.cpu.usage

{ 
    	"name": "system.cpu.usage",
    	"measurements": [{ 
    		"statistic": "VALUE",
    		"value": 0.0
    	}],
    	"availableTags": []
    }

# Spring Cloud Gateway 的 动态路由 #

*  路由配置
    
     *  配置某 请求路径路由 到指定的 目的地址
 *  路由规则
    
     *  匹配到路由配置后，根据路由规则 进行转发处理
 *  不重启网关 动态地 对应路由的配置 和 规则 进行增加，修改，和删除

## gateway 简单的动态路由实现 ##

*  GatewayControllerEndpoint 类中 提供了 动态配置的 Rest接口

### gateway项目 ###

<dependencies>
    		<dependency> //gateway
    			<groupId>org.springframework.cloud</groupId>
    			<artifactId>spring-cloud-starter-gateway</artifactId>
    		</dependency>
    
    		<dependency> //webflux
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-webflux</artifactId>
    		</dependency>
    
    		<dependency> //actuator
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-actuator</artifactId>
    		</dependency>
    
    		<dependency> //fastjson
    			<groupId>com.alibaba</groupId>
    			<artifactId>fastjson</artifactId>
    			<version>1.2.47</version>
    		</dependency>
    
    	</dependencies>

#### 定义数据传输模型 ####

/** * 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;
        
        //外加get set
    
    }

#### 创建过滤器定义模型 ####

/** * 过滤器定义模型 */
    public class GatewayFilterDefinition { 
    
        /** * Filter Name */
        private String name;
    
        /** * 对应的路由规则 */
        private Map<String, String> args = new LinkedHashMap<>();
        
    }

#### 路由断言定义模型 ####

/** * 路由断言定义模型 */
    public class GatewayPredicateDefinition { 
    
        /** * 断言对应的Name */
        private String name;
    
        /** * 配置的断言规则 */
        private Map<String, String> args = new LinkedHashMap<>();
        
    }

#### 编写动态路由实现类 ####

@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;
        }
    
        /** * spring: cloud: gateway: routes: #当访问http://localhost:8080/baidu,直接转发到https://www.baidu.com/ - id: baidu_route uri: http://baidu.com:80/ predicates: - Path=/baidu * @param args */
    
        public static void main(String[] args) { 
            GatewayRouteDefinition definition = new GatewayRouteDefinition();
            GatewayPredicateDefinition predicate = new GatewayPredicateDefinition();
            Map<String, String> predicateParams = new HashMap<>(8);
            definition.setId("jd_route");
            predicate.setName("Path");
            predicateParams.put("pattern", "/jd");
            predicate.setArgs(predicateParams);
            definition.setPredicates(Arrays.asList(predicate));
            String uri="http://www.jd.com";
            //URI uri = UriComponentsBuilder.fromHttpUrl("http://www.baidu.com").build().toUri();
            definition.setUri(uri);
            System.out.println("definition:"+JSON.toJSONString(definition));
    
    
            RouteDefinition definition1 = new RouteDefinition();
            PredicateDefinition predicate1 = new PredicateDefinition();
            Map<String, String> predicateParams1 = new HashMap<>(8);
            definition1.setId("baidu_route");
            predicate1.setName("Path");
            predicateParams1.put("pattern", "/baidu");
            predicate1.setArgs(predicateParams1);
            definition1.setPredicates(Arrays.asList(predicate1));
            URI uri1 = UriComponentsBuilder.fromHttpUrl("http://www.baidu.com").build().toUri();
            definition1.setUri(uri1);
            System.out.println("definition1："+JSON.toJSONString(definition1));
    
        }
    
    
    }

#### 编写rest接口 ####

@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();
    
            // ID
            definition.setId(gwdefinition.getId());
    
            // Predicates
            List<PredicateDefinition> pdList = new ArrayList<>();
            for (GatewayPredicateDefinition gpDefinition: gwdefinition.getPredicates()) { 
                PredicateDefinition predicate = new PredicateDefinition();
                predicate.setArgs(gpDefinition.getArgs());
                predicate.setName(gpDefinition.getName());
                pdList.add(predicate);
            }
            definition.setPredicates(pdList);
    
            // Filters
            List<FilterDefinition> fdList = new ArrayList<>();
            for (GatewayFilterDefinition gfDefinition: gwdefinition.getFilters()) { 
                FilterDefinition filter = new FilterDefinition();
                filter.setArgs(gfDefinition.getArgs());
                filter.setName(gfDefinition.getName());
                fdList.add(filter);
            }
            definition.setFilters(fdList);
    
            // URI
            URI uri = UriComponentsBuilder.fromUriString(gwdefinition.getUri()).build().toUri();
            definition.setUri(uri);
    
            return definition;
        }
    
    }

#### application.yml ####

server.port: 8080
    spring:
      application:
        name: ch18-7-gateway
    
    # 配置输出日志
    logging:
      level:
        org.springframework.cloud.gateway: TRACE
        org.springframework.http.server.reactive: DEBUG
        org.springframework.web.reactive: DEBUG
        reactor.ipc.netty: DEBUG
    
    #开启端点
    management:
      endpoints:
        web:
          exposure:
            include: '*'
      security:
        enabled: false

*  http://localhost:8080/actuator/gateway/routes
    
        [] 路由信息为空
 *  post json请求如下： http://localhost:8080/route/add
    
        { 
            "filters":[],
            "id":"jd_route",
            "order":0,
            "predicates":[{ 
                "args":{ "pattern":"/jd"},
                "name":"Path"
            }],
            "uri":"http://www.jd.com"
        }
 *  再次查看routes
    
        [
            { 
                "route_id": "jd_route",
                "route_definition": { 
                    "id": "jd_route",
                    "predicates": [
                        { 
                            "name": "Path",
                            "args": { 
                                "pattern": "/jd"
                            }
                        }
                    ],
                    "filters": [],
                    "uri": "http://www.jd.com",
                    "order": 0
                },
                "order": 0
            }
        ]
 *  再次访问：http://localhost:8080/jd，将会成功跳转

[test_a_b]: http://localhost:8081/swagger-ui.html#/operations/test-controller/getUsingGET