# sc-consul-demo

**Repository Path**: thlws/sc-consul-demo

## Basic Information

- **Project Name**: sc-consul-demo
- **Description**: SpringCloud、Consul、GateWay  示例项目
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2019-06-19
- **Last Updated**: 2020-12-19

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

## 网关说明

#### 参考资料
- [https://www.consul.io/](https://www.consul.io/)
- [http://www.ityouknow.com/springcloud/2018/12/12/spring-cloud-gateway-start.html](http://www.ityouknow.com/springcloud/2018/12/12/spring-cloud-gateway-start.html)
- [http://www.ityouknow.com/springcloud/2019/01/19/spring-cloud-gateway-service.html](http://www.ityouknow.com/springcloud/2019/01/19/spring-cloud-gateway-service.html)
- [https://windmt.com/2018/05/08/spring-cloud-14-spring-cloud-gateway-filter/](https://windmt.com/2018/05/08/spring-cloud-14-spring-cloud-gateway-filter/)
- [https://windmt.com/2018/05/11/spring-cloud-16-spring-cloud-gateway-others/](https://windmt.com/2018/05/11/spring-cloud-16-spring-cloud-gateway-others/)


#### 启动Consul
```
consul agent -dev
```

#### 配置网关
```
spring:
  cloud:
    gateway:
      routes:
      - id: neo_route
        uri: http://www.ityouknow.com
        predicates:
        - Path=/spring-cloud
```

等同于如下配置（path 转到 uri）

```java
@Bean
public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
    return builder.routes()
            .route("neo_route", r -> r.path("/spring-cloud")
            .uri("http://ityouknow.com"))
            .build();
}
```

#### 自定义网关
##### 单一网关
```java
/**
 * 单一过滤器，需与路由绑定
 * @author HanleyTang 2019-06-11
 */
public class MyFilter implements GatewayFilter , Ordered {

    private static final Log log = LogFactory.getLog(GatewayFilter.class);
    private static final String ELAPSED_TIME_BEGIN = "elapsedTimeBegin";

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {

        //添加参数并打印日志
        /**
         * 怎么来区分是 “pre” 还是 “post” 呢？
         * 其实就是chain.filter(exchange)之前的就是 “pre” 部分，之后的也就是then里边的是 “post” 部分
         */
        exchange.getAttributes().put(ELAPSED_TIME_BEGIN, System.currentTimeMillis());
        return chain.filter(exchange).then(
                Mono.fromRunnable(() -> {
                    Long startTime = exchange.getAttribute(ELAPSED_TIME_BEGIN);
                    if (startTime != null) {
                        log.info(exchange.getRequest().getURI().getRawPath() + ": " + (System.currentTimeMillis() - startTime) + "ms");
                    }
                })
        );
    }

    @Override
    public int getOrder() {
        return Ordered.LOWEST_PRECEDENCE;
    }
}

```

过滤器绑定到路由

```java
@Configuration
public class RouteConfig {

    @Autowired
    private MyFilter myFilter;

    @Bean
    public RouteLocator customerRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
                .route(r -> r.path("/mypath/**")
                        //若MyFilter 不受容器管理，这里可以直接 new MyFilter()
                        .filters(f -> f.filter(myFilter) 
                        .addResponseHeader("X-Response-Default-Foo", "Default-Bar"))
                        .uri("http://www.qq.com")
                        .order(0)
                        .id("my_filter_router")
                )
                .build();
    }

}
```

##### 全局网关
```java

/**
 * 全局过滤器,Spring容器中存在实例会自动启用
 * @author HanleyTang 2019-06-11
 */
@Component
public class MyGlobalFilter implements GlobalFilter, Ordered {

    private final Logger log = LoggerFactory.getLogger(getClass());

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {

        String token = exchange.getRequest().getQueryParams().getFirst("token");

        if (token == null || token.isEmpty()) {
            log.info("全局过滤器 MyGlobalFilter 检测到token为空，拒绝继续执行.");
            exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
            return exchange.getResponse().setComplete();
        }

        log.info("全局过滤器 MyGlobalFilter 拦截到 token:{} 放行请求",token);

        return chain.filter(exchange);
    }

    @Override
    public int getOrder() {
        return -10;
    }


    /**这种方式为官方示例，直接创建了全局过滤器，功能同上*/
    @Bean
    @Order(-1)
    public GlobalFilter a() {
        return (exchange, chain) -> {

            log.info("first pre filter");
            String token = exchange.getRequest().getQueryParams().getFirst("token");
            if (StringUtils.isEmpty(token)) {
                exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
                return exchange.getResponse().setComplete();
            }

            return chain.filter(exchange).then(Mono.fromRunnable(() -> {
                log.info("third post filter");
            }));
        };
    }
}
```



##### 限流算法
- [https://www.cnblogs.com/csts/p/10286378.html](https://www.cnblogs.com/csts/p/10286378.html)