重学SpringCloud系列九微服务网关-GateWay

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

server:
  port: 8777

spring:
  application:
    name: zimug-server-gateway
  cloud:
    gateway:
      routes:
        - id: dhy           # 路由 ID，唯一
          uri: http://baidu.com/   # 目标 URI，路由到微服务的地址
          predicates:              # 请求转发判断条件
            - Path=/baidu/**    # 匹配对应 URL 的请求，将匹配到的请求追加在目标 URI 之后

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
</dependency>

http://localhost:8777/baidu/course

http://baidu.com/baidu/course

spring:
  cloud:
    gateway:
      routes:
      - id: after_route
        uri: http://www.dhy.com
        predicates:
        - After=2020-05-17T16:31:47.789+08:00

spring:
  cloud:
    gateway:
      routes:
      - id: before_route
        uri: http://www.dhy.com
        predicates:
        - Before=2020-05-17T19:53:42.789+08:00

spring:
  cloud:
    gateway:
      routes:
      - id: between_route
        uri: http://www.dhy.com
        predicates:
        - Between=2020-05-17T16:31:47.789+08:00, 2020-05-17T19:53:42.789+08:00

spring:
  cloud:
    gateway:
      routes:
      - id: cookie_route
        uri: http://www.dhy.com
        predicates:
        - Cookie=cookiename, cookievalue

spring:
  cloud:
    gateway:
      routes:
      - id: header_route
        uri: http://www.dhy.com
        predicates:
        - Header=X-Request-Id, \d+

spring:
  cloud:
    gateway:
      routes:
      - id: host_route
        uri: http://www.dhy.com
        predicates:
        - Host=**.somehost.org,**.anotherhost.org

spring:
  cloud:
    gateway:
      routes:
      - id: method_route
        uri: http://www.dhy.com
        predicates:
        - Method=GET

spring:
  cloud:
    gateway:
      routes:
      - id: query_route
        uri: http://www.dhy.com
        predicates:
        - Query=foo, ba.

spring:
  cloud:
    gateway:
      routes:
      - id: remoteaddr_route
        uri: https://www.dhy.org
        predicates:
        - RemoteAddr=192.168.1.1/24

spring:
  cloud:
    gateway:
      routes:
      - id: weight_high
        uri: https://weighthigh.org
        predicates:
        - Weight=group1, 8
      - id: weight_low
        uri: https://weightlow.org
        predicates:
        - Weight=group1, 2

spring:
  cloud:
    gateway:
      routes:
        - id: multi-predicate
          uri: https://www.dhy.com
          order: 0
          predicates:
            - Host=**.foo.org
            - Path=/headers
            - Method=GET
            - Header=X-Request-Id, \d+
            - Query=foo, ba.
            - Query=baz
            - Cookie=chocolate, ch.p

@Component
public class RbacAuthRoutePredicateFactory
        extends AbstractRoutePredicateFactory<RbacAuthRoutePredicateFactory.Config> {


  public RbacAuthRoutePredicateFactory() {
    super(Config.class);
  }

  @Override
  public Predicate<ServerWebExchange> apply(Config config) {
    return exchange -> {
      String requestURI = exchange.getRequest().getURI().getPath();
      if (config.getFlag().equals("rbac")
        &&(requestURI.startsWith("/sysuser")
          ||requestURI.startsWith("/sysorg")
          ||requestURI.startsWith("/sysrole")
          ||requestURI.startsWith("/sysmenu")
          ||requestURI.startsWith("/sysdict")
          ||requestURI.startsWith("/sysapi"))) {

        return true;  //表示匹配成功
      }
      return false;   //表示匹配失败
    };
  }
  //自定义参数args配置类
  public static class Config {
    private String flag; //该参数对应配置文件的args

    public String getFlag() {
      return flag;
    }

    public void setFlag(String flag) {
      this.flag = flag;
    }
  }
}

spring:
  application:
    name: zimug-server-gateway
  cloud:
    gateway:
      routes:
        - id: rbsc-service
          uri: http://localhost:8401/
          predicates:
            - name: RbacAuth
              args:
                flag: rbac

server:
  port: 8777

spring:
  application:
    name: dhy-server-gateway
  cloud:
    gateway:
      routes:
        - id: dhy           # 路由 ID，唯一
          uri: http://baidu.com/   # 目标 URI，路由到微服务的地址
          predicates:              # 请求转发判断条件
            - Path=/baidu/**    # 匹配对应 URL 的请求，将匹配到的请求追加在目标 URI 之后

@Bean
public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
   return builder.routes()
         .route("dhy", r -> r.path("/baidu/**")
         .uri("http://baidu.com"))
         .build();
}

spring:
  cloud:
    gateway:
      routes:
      - id: add_request_header_route
        uri: http://httpbin.org:80/get
        filters:
        - AddRequestHeader=X-Request-Foo, Bar
        predicates:
        - Method=GET

spring:
  cloud:
    gateway:
      routes:
      - id: rewritepath_route
        uri: http://httpbin.org
        predicates:
        - Path=/foo/**
        filters:
        - RewritePath=/foo/(?<segment>.*), /$\{segment}

@Configuration
public class GlobalGatewayFilterConfig
{
    @Bean
    @Order(-100)
    public GlobalFilter apiGlobalFilter()
    {
        return (exchange, chain) -> {
            //获取请求处理之前的时间
            Long startTime = System.currentTimeMillis();
            //请求处理完成之后
            return chain.filter(exchange).then().then(Mono.fromRunnable(() -> {
                //获取请求处理之后的时间
                Long endTime = System.currentTimeMillis();
                //这里可以将结果进行持久化存储，我们暂时简单处理打印出来
                System.out.println(
                    exchange.getRequest().getURI().getRawPath() + 
                            ", cost time : "
                            + (endTime - startTime) + "ms");
            }));
        };
    }
}

@Component
public class ApiGlobalFilter implements GlobalFilter, Ordered {

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

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        //获取请求处理之前的时间
        Long startTime = System.currentTimeMillis();
        //请求处理完成之后
        return chain.filter(exchange).then().then(Mono.fromRunnable(() -> {
            //获取请求处理之后的时间
            Long endTime = System.currentTimeMillis();
            //这里可以将结果进行持久化存储，我们暂时简单处理打印出来
            System.out.println(
                exchange.getRequest().getURI().getRawPath() + 
                        ", cost time : "
                        + (endTime - startTime) + "ms");
        }));
    }
}

@Component
@Order(99)
public class IPForbidGatewayFilterFactory
    extends AbstractGatewayFilterFactory<IPForbidGatewayFilterFactory.Config> {

    public IPForbidGatewayFilterFactory()
    {
        super(Config.class);
    }

    @Override
    public List<String> shortcutFieldOrder()
    {
        return Arrays.asList("permitIp");  //对应config类的参数
    }

    @Override
    public GatewayFilter apply(Config config)
    {
        return (exchange, chain) -> {
            //获取服务访问的客户端ip
            String ip = exchange.getRequest().getRemoteAddress().getAddress().getHostAddress();
            if (config.getPermitIp().equals(ip)) {
                //如果客户端ip=permitIp，继续执行过滤器链允许继续访问
                return chain.filter(exchange);
            }
            //否则返回，拒绝请求
            exchange.getResponse().setStatusCode(HttpStatus.FORBIDDEN);
            return exchange.getResponse().setComplete();
        };
    }

    static public class Config
    {
        private String permitIp;

        public String getPermitIp() {
            return permitIp;
        }

        public void setPermitIp(String permitIp) {
            this.permitIp = permitIp;
        }
    }
}

<dependency>
   <groupId>com.alibaba.cloud</groupId>
   <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

@EnableDiscoveryClient

<dependency>
   <groupId>com.alibaba.cloud</groupId>
   <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>

server:
  port: 8777

spring:
  application:
    name: zimug-server-gateway
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.161.6:8848
      config:
        server-addr: ${spring.cloud.nacos.discovery.server-addr}
        file-extension: yaml
        group: ZIMUG_GROUP  #配置分组，默认分组是DEFAULT_GROUP

spring:
  cloud:
    gateway:
      discovery:
        locator:
          enabled: true
      routes:
        - id: rbsc-service
          uri: lb://aservice-rbac
          predicates:
            - name: RbacAuth
              args:
                flag: rbac
          filters:
            - name: IPForbid
              args:
                permitIp: 127.0.0.1

http://localhost:8777/category/course

http://www.zimug.com/category/course

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>

spring:
  cloud:
    sentinel:
      transport:
        port: 8719
        dashboard: 192.168.161.3:8774  

public class MySentinelBlockHandler implements BlockRequestHandler {

  @Override
  public Mono<ServerResponse> handleRequest(ServerWebExchange exchange, Throwable t) {
    ErrorResult errorResult = new MySentinelBlockHandler.ErrorResult(
            HttpStatus.TOO_MANY_REQUESTS.value(),
            "系统繁忙，请稍后再试！");
    // JSON result by default.
    return ServerResponse.status(HttpStatus.TOO_MANY_REQUESTS)
            .contentType(MediaType.APPLICATION_JSON_UTF8)
            .body(fromObject(errorResult));
  }


  private static class ErrorResult {
    private final int code;
    private final String message;

    ErrorResult(int code, String message) {
      this.code = code;
      this.message = message;
    }

    public int getCode() {
      return code;
    }

    public String getMessage() {
      return message;
    }
  }
}

spring:
  cloud:
    gateway:
      globalcors:
        cors-configurations:
          '[/**]':
            allowCredentials: true
            exposedHeaders: "*"
            allowedHeaders: "*"
            allowedOrigins: "http://localhost:8080"
            allowedMethods:
            - GET
            - POST

spring.cloud.gateway.globalcors.corsConfigurations.[/**].allowedOrigins=http://localhost:8080
spring.cloud.gateway.globalcors.corsConfigurations.[/**].allowedHeaders[0]=*
spring.cloud.gateway.globalcors.corsConfigurations.[/**].allowedMethods[0]=GET
spring.cloud.gateway.globalcors.corsConfigurations.[/**].allowedMethods[1]=POST

@Bean
public CorsWebFilter corsFilter() {
    CorsConfiguration config = new CorsConfiguration();
    config.setAllowedMethods(Arrays.asList(
            HttpMethod.POST.name(),
            HttpMethod.GET.name()
    ));
    config.addAllowedOrigin("Http://localhost:8080");
    config.addAllowedHeader("*");

    UrlBasedCorsConfigurationSource source
            = new UrlBasedCorsConfigurationSource(new PathPatternParser());
    source.registerCorsConfiguration("/**", config);

    return new CorsWebFilter(source);
}

@Configuration
public class CrosConfig {
    @Bean
    public CorsWebFilter corsWebFilter(){
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();

        CorsConfiguration corsConfiguration = new CorsConfiguration();
        //1.配置跨域
        //允许哪种请求头跨域
        corsConfiguration.addAllowedHeader("*");
        //允许哪种方法类型跨域 get post delete put
        corsConfiguration.addAllowedMethod("*");
        // 允许哪些请求源跨域
        corsConfiguration.addAllowedOrigin("*");
        // 是否携带cookie跨域
        corsConfiguration.setAllowCredentials(true);

        //允许跨域的路径
        source.registerCorsConfiguration("/**",corsConfiguration);
        return new CorsWebFilter((CorsConfigurationSource) source);
    }
}

@Configuration
@AutoConfigureAfter(GlobalCorsProperties.class)
public class CorsConfig {

  @Resource
  private  GlobalCorsProperties globalCorsProperties;

  @Bean
  public CorsWebFilter corsFilter() {
    UrlBasedCorsConfigurationSource source
            = new UrlBasedCorsConfigurationSource(new PathPatternParser());
    globalCorsProperties.getCorsConfigurations()
            .forEach(source::registerCorsConfiguration);
    return new CorsWebFilter(source);
  }

}

public class ExceptionHandlingWebHandler extends WebHandlerDecorator {

   //持有若干的WebExceptionHandler
   private final List<WebExceptionHandler> exceptionHandlers;


   public ExceptionHandlingWebHandler(WebHandler delegate, List<WebExceptionHandler> handlers) {
      super(delegate);
      this.exceptionHandlers = Collections.unmodifiableList(new ArrayList<>(handlers));
   }

   public List<WebExceptionHandler> getExceptionHandlers() {
      return this.exceptionHandlers;
   }

   @Override
   public Mono<Void> handle(ServerWebExchange exchange) {

      Mono<Void> completion;
      try {
         completion = super.handle(exchange);
      }catch (Throwable ex) {
         completion = Mono.error(ex);
      }
      //当出现异常的时候onErrorResume，使用WebExceptionHandler进行异常处理
      for (WebExceptionHandler handler : this.exceptionHandlers) {
         completion = completion.onErrorResume(ex -> handler.handle(exchange, ex));
      }

      return completion;
   }
}

@Override
protected RouterFunction<ServerResponse> getRoutingFunction(
      ErrorAttributes errorAttributes) {
   return route(acceptsTextHtml(), this::renderErrorView).andRoute(all(),
         this::renderErrorResponse);
}

package org.springframework.boot.web.reactive.error;
import org.springframework.web.server.WebExceptionHandler;

@FunctionalInterface
public interface ErrorWebExceptionHandler extends WebExceptionHandler {

}

@Slf4j
@Order(-1)
@Component
@RequiredArgsConstructor
public class JsonExceptionHandler implements ErrorWebExceptionHandler {

    @Override
    public Mono<Void> handle(ServerWebExchange exchange, Throwable ex) {

        ServerHttpResponse response = exchange.getResponse();
        if (response.isCommitted()) {
            //对于已经committed(提交)的response，就不能再使用这个response向缓冲区写任何东西
            return Mono.error(ex);
        }

        // header set 响应JSON类型数据，统一响应数据结构（适用于前后端分离JSON数据交换系统）
        response.getHeaders().setContentType(MediaType.APPLICATION_JSON);

        // 按照异常类型进行翻译处理，翻译的结果易于前端理解
        String message;
        if (ex instanceof NotFoundException) {
            response.setStatusCode(HttpStatus.NOT_FOUND);
            message = "您请求的服务不存在";
        } else if (ex instanceof ResponseStatusException) {
            ResponseStatusException responseStatusException = (ResponseStatusException) ex;
            response.setStatusCode(responseStatusException.getStatus());
            message = responseStatusException.getMessage();
        } else if (ex instanceof GateWayException) {
            response.setStatusCode(HttpStatus.FORBIDDEN);
            message = ex.getMessage();
        } else {
            response.setStatusCode(HttpStatus.INTERNAL_SERVER_ERROR);
            message = "服务器内部错误";
        }

        //全局通用响应数据结构，可以自定义。通常包含请求结果code、message、data
        AjaxResponse result = AjaxResponse.error(
                response.getStatusCode().value(),
                message);

        writeLog(exchange, ex);

        return response.writeWith(Mono.fromSupplier(() -> {
            DataBufferFactory bufferFactory = response.bufferFactory();
            return bufferFactory.wrap(JSON.toJSONBytes(result));
        }));

    }

    //将错误信息以日志的形式记录下来
    private void writeLog(ServerWebExchange exchange, Throwable ex) {
        ServerHttpRequest request = exchange.getRequest();
        URI uri = request.getURI();
        String host = uri.getHost();
        int port = uri.getPort();
        log.error("[gateway]-host:{} ,port:{}，url:{},  errormessage:",
                host,
                port,
                request.getPath(),
                ex);
    }
}