SpringCloud（二）Gateway网关

<!-- 引入spring cloud gateway依赖 -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
<!-- 引入SpringCloud Eureka client依赖 -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

// @EnableEurekaClient: 声明一个Eureka客户端，只能注册到Eureka Server
// @EnableDiscoveryClient: 声明一个可以被发现的客户端，可以是其他注册中心
@EnableDiscoveryClient
@SpringBootApplication
public class UserApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserApplication.class, args);
    }
}

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder;
import org.springframework.context.annotation.Bean;
 
@SpringBootApplication
public class GatewayApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(GatewayApplication.class, args);
    }
 
    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()   // 参数分别为：路由 ID，断言（判断条件），目标服务地址
                .route("product-service", r -> r.path("/product/**").uri("http://localhost:9004"))
                .build();
    }
}

<!-- reactive redis依赖包（包含Lettuce客户端） -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
</dependency>

spring:
  application:
    name: api-gateway-server
  cloud:
    gateway:
      discovery:
        locator:
          enabled: true               # 开启从注册中心动态创建路由的功能，利用微服务名进行路由
          lower-case-service-id: true # 微服务名称以小写形式呈现
      routes:       # 配置路由： 路由id，路由到微服务的uri,断言（判断条件）
        - id: product-service       # 路由id
          uri: lb://service-product # 路由到微服务的uri。 lb://xxx，lb代表从注册中心获取服务列表，xxx代表需要转发的微服务的名称
          predicates:               # 断言（判断条件）
            - Path=/product-service/**
          filters:   # 配置路由过滤器
            - name: RequestRateLimiter                 # 使用的限流过滤器是Spring Cloud Gateway提供的
              args:
                key-resolver: '#{@pathKeyResolver}'   # 使用SpEL从容器中获取对象
                redis-rate-limiter.replenishRate: 1   # 令牌桶每秒填充平均速率，允许用户每秒处理多少个请求
                redis-rate-limiter.burstCapacity: 3   # 令牌桶的上限，令牌桶的容量，允许在一秒钟内完成的最大请求数

import org.springframework.cloud.gateway.filter.ratelimit.KeyResolver;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import reactor.core.publisher.Mono;
import java.util.Objects;

@Configuration
public class KeyResolverConfig {
    /**
     * 基于请求路径的限流
     */
    //@Bean
    public KeyResolver pathKeyResolver() {
        return exchange -> Mono.just(exchange.getRequest().getPath().toString());
    }

    /**
     * 基于请求参数的限流
     * 请求/abc?userId=1
     */
    //@Bean
    public KeyResolver useKeyResolver() {
        return exchange -> Mono.just(Objects.requireNonNull(exchange.getRequest().getQueryParams().getFirst("userId")));
    }

    /**
     * 基于请求IP地址的限流
     */
    @Bean
    public KeyResolver ipKeyResolver() {
        return exchange -> Mono.just(Objects.requireNonNull(exchange.getRequest().getHeaders().getFirst("x-Forwarded-For")));
    }
}

ServerWebExchangeUtils.isAlreadyRouted   //检查是否已被路由
ServerWebExchangeUtils.setAlreadyRouted  //设置routed状态

import org.apache.commons.lang.StringUtils;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

@Component
public class TokenFilter implements GlobalFilter, Ordered {

    /**
     * 是否携带token凭证
     * 对请求参数中的access-token进行判断
     */
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();

        String token = request.getHeaders().getFirst("access-token");
        //如果token为空
        if (StringUtils.isEmpty(token)) {
            //设置Http的状态码
            exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
            //请求结束
            return exchange.getResponse().setComplete();
        }
        //如果token存在，继续执行
        return chain.filter(exchange);
    }

    /**
     * 指定过滤器的执行顺序，返回值越小，优先级越高
     */
    @Override
    public int getOrder() {
        return 0;
    }
}