SpringCloud 微服务网关 Gateway 组件

大家都都知道在微服务架构中，一个系统会被拆分为很多个微服务。那么作为客户端要如何去调用这么多的微服务呢？如果没有网关的存在，我们只能在客户端记录每个微服务的地址，然后分别去用。Copy

<!--gateway 依赖-->
<dependency>
  <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>Copy

server:
  port: 8088
spring:
  application:
    name: api-gateway
  cloud:
    # gateway 配置
    gateway:
      # 路由规则
      routes:
        # 路由唯一标识，路由到订单
        - id: order_route
          # 需要转发的地址
          uri: http://localhost:8020
          # 断言规则，用于路由规则的匹配
          predicates:
            - Path=/order-server/**
            # http://localhost:8088/order-server/order/add 路由到
            # http://localhost:8020/order-server/order/add
          filters:
            # 转发之前，去掉第一层的路径
            # http://localhost:8020/order/add
            - StripPrefix=1
        #- id: stock_routeCopy

<!--nacos 服务注册与发现-->
<dependency>
  <groupId>com.alibaba.cloud</groupId>
 <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>Copy

server:
  port: 8088
spring:
  application:
    name: api-gateway
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.33.62:8847
        username: nacos
        password: nacos
    # gateway 配置
    gateway:
      # 路由规则
      routes:
        # 路由唯一标识，路由到订单
        - id: order_route
          # lb 指的是从 nacos 中按照名称获取微服务，并遵循负载均衡策略
          uri: lb://order-server
          # 断言规则，用于路由规则的匹配
          predicates:
            - Path=/order-server/**
          filters:
            - StripPrefix=1Copy

server:
  port: 8088
spring:
  application:
    name: api-gateway
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.33.62:8847
        username: nacos
        password: nacos
    # gateway 配置
    gateway:
      discovery:
        locator:
          # 是否启动自动识别 nacos 服务
          enabled: trueCopy

- After=2022-08-12T15:00:00.000+08:00[Asia/Shanghai]Copy

server:
  port: 8088
spring:
  application:
    name: api-gateway
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.33.62:8847
        username: nacos
        password: nacos
    # gateway 配置
    gateway:
      # 路由规则
      routes:
        # 路由唯一标识，路由到订单
        - id: order_route
          # lb 指的是从 nacos 中按照名称获取微服务，并遵循负载均衡策略
          uri: lb://order-server
          # 断言规则，用于路由规则的匹配
          predicates:
            - Path=/order/**
            - After=2022-08-12T15:00:00.000+08:00[Asia/Shanghai]Copy

- RemoteAddr=192.168.1.1/24Copy

- Cookie=chocolate,ch.Copy

- Header=X-Request-Id,\d+Copy

- Host=**.testhost.orgCopy

- Method=GETCopy

# 效果类似于 url 中 /foo/xxx
- Path=/foo/{segment}Copy

# 效果类似于 url 中 ?baz=xxx
- Query=name,ba.Copy

routes:
  - id: weight_route1
    uri: host1
    predicates:
      - Path=/order/**
      - weitht=group3,1
  - id: weight_route2
    uri: host2
    predicates:
      - Path=/order/**
      - Weight=group3,9Copy

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

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

    @Override
    public List<String> shortcutFieldOrder() {
        return Arrays.asList("name");
    }

    @Override
    public Predicate<ServerWebExchange> apply(Config config) {
        return new GatewayPredicate() {
            @Override
            public boolean test(ServerWebExchange exchange) {
                if (config.getName().equals("hudu")) {
                    return true;
                }
                return false;
            }
        };
    }

    /**
     * 用于接收配置文件中 断言的信息
     */
    @Validated
    public static class Config {
        private String name;

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }
}Copy

server:
  port: 8088
spring:
  application:
    name: api-gateway
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.33.62:8847
        username: nacos
        password: nacos
    # gateway 配置
    gateway:
      # 路由规则
      routes:
        # 路由唯一标识，路由到订单
        - id: order_route
          # lb 指的是从 nacos 中按照名称获取微服务，并遵循负载均衡策略
          uri: lb://order-server
          # 断言规则，用于路由规则的匹配
          predicates:
            - Path=/order/**
            - CheckAuth=huduCopy

spring:
    # gateway 配置
    gateway:
      # 路由规则
      routes:
        # 路由唯一标识，路由到订单
        - id: order_route
          # lb 指的是从 nacos 中按照名称获取微服务，并遵循负载均衡策略
          uri: lb://order-server
          # 断言规则，用于路由规则的匹配
          predicates:
            - Path=/order/**
          filters:
            # 添加请求头
            - AddRequestHeader=X-Request-color,redCopy

@RequestMapping("/header")
public String header(@RequestHeader("X-Request-color") String color) {
  return color;
}Copy

spring:
    # gateway 配置
    gateway:
      # 路由规则
      routes:
        # 路由唯一标识，路由到订单
        - id: order_route
          # lb 指的是从 nacos 中按照名称获取微服务，并遵循负载均衡策略
          uri: lb://order-server
          # 断言规则，用于路由规则的匹配
          predicates:
            - Path=/order/**
          filters:
            # 添加请求参数
            - AddRequestParameter=color,blueCopy

@GetMapping("/parameter")
public String parameter(@RequestParam("color")String color) {
  return color;
}Copy

filters:
  # 添加请求参数
  - PrefixPath=/order-serverCopy

server:
  servlet:
    context-path: order-serverCopy

filters:
  # 重定向
  - RedirectTo=302,https://www.baidu.comCopy

@Component
public class CheckAuthGatewayFilterFactory extends AbstractGatewayFilterFactory<CheckAuthGatewayFilterFactory.Config> {


    private static final Log log = LogFactory
            .getLog(CheckAuthGatewayFilterFactory.class);

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

    @Override
    public List<String> shortcutFieldOrder() {
        return Arrays.asList("key","value");
    }

    @Override
    public GatewayFilter apply(CheckAuthGatewayFilterFactory.Config config) {
        return (exchange, chain) -> {
            // 获取 key value 值
            String key = exchange.getRequest().getQueryParams().getFirst(config.getKey());
            // 如果 key value 等于对应的值 成功
            if (StringUtils.hasText(key)) {
                if (config.getValue().equals(key)) {
                    return chain.filter(exchange);
                }
            }
            // 否则访问 404
            exchange.getResponse().setStatusCode(HttpStatus.NOT_FOUND);
            return exchange.getResponse().setComplete();
        };
    }

    public static class Config {

        private String key;

        private String value;

        public String getKey() {
            return key;
        }

        public void setKey(String key) {
            this.key = key;
        }

        public String getValue() {
            return value;
        }

        public void setValue(String value) {
            this.value = value;
        }
    }

}Copy

filters:
  - CheckAuth=name,huduCopy

spring:
  cloud:
    gateway:
      routes:
        - id: order_route
          uri: lb://mall-order
          predicates:
            - Path=/order/**Copy

@Component
public class MyGlobalFilter implements GlobalFilter {

    Logger log = LoggerFactory.getLogger(this.getClass());

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        log.info(exchange.getRequest().getPath().value());
        return chain.filter(exchange);
    }
}Copy

<appender name="accessLog" class="ch.qos.logback.core.FileAppender">
  <file>access_log.log</file>
    <encoder>
    <pattern>%msg%n</pattern>
  </encoder>
</appender>

<appender name="async" class="ch.qos.logback.classic.AsyncAppender">
  <appender-ref ref="accessLog" />
</appender>

<logger name="reactor.netty.http.server.AccessLog" level="INFO" additivity="false">
  <appender-ref ref="async"/>
</logger>Copy

spring:
  cloud:
    gateway:
      globalcors:
        cors-configurations:
          # 允许跨域访问的资源
          '[/**]':
            # 跨域允许来源
            allowedOrigins: "*"
            allowedMethods:
              - GET
              - POST
              - DELETE
              - PUT
              - OPTOINCopy

@Configuration
public class SystemCorsFilter {
    @Bean
    public CorsWebFilter corsWebFilter() {
        CorsConfiguration corsConfiguration = new CorsConfiguration();
        // 允许的 method
        corsConfiguration.addAllowedMethod("*");
        // 允许的来源
        corsConfiguration.addAllowedOrigin("*");
        // 允许的请求头
        corsConfiguration.addAllowedHeader("*");

        //由于是通过 webflux 的方式，需要额外添加此配置
        // 访问的资源
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource(new PathPatternParser());
        source.registerCorsConfiguration("/**",corsConfiguration);
        return new CorsWebFilter(source);
    }
}Copy

<!--sentinel 整合 gateway-->
<dependency>
  <groupId>com.alibaba.cloud</groupId>
 <artifactId>spring-cloud-alibaba-sentinel-gateway</artifactId>
</dependency>
<!--sentinel 依赖-->
<dependency>
  <groupId>com.alibaba.cloud</groupId>
 <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>Copy

# 配置 sentinel
sentinel:
  transport:
    dashboard: 127.0.0.1:8858Copy

@RequestMapping("/hello")
public String hello() {
  System.out.println("下单成功！");
  return "Hello World ";
}

@RequestMapping("/flow")
  public String flow() {
  return "正常访问";
}

@RequestMapping("/flowThread")
public String flowThread() throws InterruptedException {
  TimeUnit.SECONDS.sleep(2);
  return "正常访问";
}

@RequestMapping("/get")
public String get() {
  return "查询订单";
}

@RequestMapping("/err")
public String err() {
  int i = 1 / 0;
  return "hello";
}

@RequestMapping("/get/{id}")
public String getById(@PathVariable("id")Integer id) {
  System.out.println("正常访问");
  return "正常访问";
}Copy

spring:
  cloud:
    sentinel:
      transport:
        dashboard: 127.0.0.1:8858
      scg:
        fallback:
          mode: response
          response-body: '{"code":403,"msg":"限流了"}'Copy

@Configuration
public class GatewayConfig {

    Logger log = LoggerFactory.getLogger(this.getClass());

    @PostConstruct
    public void init() {
        BlockRequestHandler blockRequestHandler = new BlockRequestHandler() {
            @Override
            public Mono<ServerResponse> handleRequest(ServerWebExchange serverWebExchange, Throwable throwable) {
                // 打印异常
                log.error(throwable.getMessage());

                HashMap<String, String> map = new HashMap<>();
                map.put("code", HttpStatus.TOO_MANY_REQUESTS.toString());
                if (throwable instanceof FlowException) {
                    map.put("msg", "接口限流了");
                } else if (throwable instanceof DegradeException) {
                    map.put("msg", "服务降级了");
                } else if (throwable instanceof ParamFlowException) {
                    map.put("msg", "热点参数限流了");
                } else if (throwable instanceof SystemBlockException) {
                    map.put("msg", "触发系统保护规则了");
                } else if (throwable instanceof AuthorityException) {
                    map.put("msg", "授权规则不通过");
                }
                // 自定义异常处理
                return ServerResponse
                        // 响应状态码
                        .status(HttpStatus.OK)
                        // 响应类型
                        .contentType(MediaType.APPLICATION_JSON)
                        // 响应内容
                        .body(BodyInserters.fromValue(map));
            }
        };

        GatewayCallbackManager.setBlockHandler(blockRequestHandler);
    }
}Copy

@Configuration
public class GatewayConfig {

    Logger log = LoggerFactory.getLogger(this.getClass());

    @PostConstruct
    public void doInit() {
        // 初始化自定义的 API
        initCustomizedApis();
        // 初始化网关限流规则
        initGatewayRules();
        // 自定义限流异常处理器
        initBlockRequestHandler();
    }

    private void initCustomizedApis() {
        HashSet<ApiDefinition> definitions = new HashSet<>();
        ApiDefinition api = new ApiDefinition("user_service_api")
                .setPredicateItems(new HashSet<ApiPredicateItem>() {{
                    add(new ApiPathPredicateItem().setPattern("/user/**").setMatchStrategy(SentinelGatewayConstants.URL_MATCH_STRATEGY_PREFIX));
                }});
        definitions.add(api);
        GatewayApiDefinitionManager.loadApiDefinitions(definitions);
    }

    private void initGatewayRules() {
        HashSet<GatewayFlowRule> rules = new HashSet<>();
        // resource：资源名称，可以是网关中的 route 名称，或者是自定义的 API 分组名称
        // count：限流阈值
        // intervalSec：统计时间窗口，单位是 秒，默认是 1 秒
        rules.add(new GatewayFlowRule("order_route")
                .setCount(2)
                .setIntervalSec(1));
        rules.add(new GatewayFlowRule("user_service_api").setCount(2).setIntervalSec(1));
        // 加载网关规则
        GatewayRuleManager.loadRules(rules);
    }

    @PostConstruct
    public void initBlockRequestHandler() {
        BlockRequestHandler blockRequestHandler = new BlockRequestHandler() {
            @Override
            public Mono<ServerResponse> handleRequest(ServerWebExchange serverWebExchange, Throwable throwable) {
                // 打印异常
                log.error(throwable.getMessage());

                HashMap<String, String> map = new HashMap<>();
                map.put("code", HttpStatus.TOO_MANY_REQUESTS.toString());
                if (throwable instanceof FlowException) {
                    map.put("msg", "接口限流了");
                } else if (throwable instanceof DegradeException) {
                    map.put("msg", "服务降级了");
                } else if (throwable instanceof ParamFlowException) {
                    map.put("msg", "热点参数限流了");
                } else if (throwable instanceof SystemBlockException) {
                    map.put("msg", "触发系统保护规则了");
                } else if (throwable instanceof AuthorityException) {
                    map.put("msg", "授权规则不通过");
                }
                // 自定义异常处理
                return ServerResponse
                        // 响应状态码
                        .status(HttpStatus.OK)
                        // 响应类型
                        .contentType(MediaType.APPLICATION_JSON)
                        // 响应内容
                        .body(BodyInserters.fromValue(map));
            }
        };

        GatewayCallbackManager.setBlockHandler(blockRequestHandler);
    }
}Copy