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
          

package com.tongda.filter;

import jdk.nashorn.internal.parser.Token;
import lombok.extern.slf4j.Slf4j;
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.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

/**
 *
 * @Version 1.0
 */
@Component
@Slf4j
public class GlobalfilterConfig implements GlobalFilter, Ordered {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        log.info("进入我自己的全局过滤器");
        String token = exchange.getRequest().getQueryParams().getFirst("token");
        if (token == null) {
            log.error("token为空，没有认证");
            exchange.getResponse().setStatusCode(HttpStatus.NOT_ACCEPTABLE);
            return exchange.getResponse().setComplete();
        }
        log.info("验证通过");
        
        return chain.filter(exchange);
    }

    /**
     * order 越小越先执行
     * @param  
     * @return {@link int}
     * 
     **/
    @Override
    public int getOrder() {
        return 0;
    }
}

package com.tongda.filter;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.bouncycastle.util.Bytes;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

import java.util.HashMap;

/**
 * 这个及时过滤的方法
 * 过滤器链模式
 * 责任链模式
 *
 *
 */
@Component
public class MyGlobalFilter implements GlobalFilter, Ordered {

 @Override
 public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
  // 针对请求的过滤，拿到请求header url参数。。。。
  ServerHttpRequest request = exchange.getRequest();
  // HttpServletRequest 这个是web里面的
  // ServerHttpRequest webFlux里面，响应式里面的
  String path = request.getURI().getPath();
  System.out.println(path);
  HttpHeaders headers = request.getHeaders();
  System.out.println(headers);
  String methodName = request.getMethod().name();
  System.out.println(methodName);
  String hostName = request.getRemoteAddress().getHostName();
  System.out.println(hostName);

  // 响应相关的数据
  ServerHttpResponse response = exchange.getResponse();
  // 用了微服务，肯定是前后端分离的，前后端分离，一般前后通过json
  // {"code":200,"msg":"ok"}
  // 设置编码，响应头里面设置
  response.getHeaders().set("content-type","application/json;charset=utf-8");
  // 组装业务返回值
  HashMap<String, Object> map = new HashMap<>(4);
  map.put("code", HttpStatus.UNAUTHORIZED.value());// 取状态码
  map.put("msg","你未授权");
  ObjectMapper objectMapper = new ObjectMapper();
  // 把一个map转成字节
  byte[] bytes = new byte[0];
  try {
   bytes = objectMapper.writeValueAsBytes(map);
  } catch (JsonProcessingException e) {
   e.printStackTrace();
  }
  // 通过buffer工厂将字节数组包装成一个数据包
  DataBuffer wrap = response.bufferFactory().wrap(bytes);
  return response.writeWith(Mono.just(wrap));

  // 传入exchange放行,到下一个过滤器
  // return chain.filter(exchange);


 }
 /**
  * 排序
  * 指定顺序的方法，越小越先执行，如-1 ~ -500
  * @param
  * @return {@link int}
  * @throws
  *
  **/
 @Override
 public int getOrder() {
  return 0;
 }
}

package com.tongda.filter;

import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

import java.util.HashMap;
import java.util.Map;

/**
 * 
 * @Version 1.0
 */
@Component
@Slf4j
public class IPGlobalFilter implements GlobalFilter, Ordered {
    @SneakyThrows
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        String ip = exchange.getRequest().getHeaders().getHost().getHostName();
        //这里写死，只做演示
        if (ip.equals("localhost")){
            //说明是黑名单里面的ip
            ServerHttpResponse response = exchange.getResponse();
            response.setStatusCode(HttpStatus.UNAUTHORIZED);
            Map<String, Object> map = new HashMap<>();
            map.put("conde",HttpStatus.UNAUTHORIZED);
            map.put("msg","非法访问");
            response.getHeaders().add("content-type","application/json;charset=UTF-8");
            ObjectMapper objectMapper = new ObjectMapper();
            byte[] bytes = objectMapper.writeValueAsBytes(map);
            DataBuffer wrap = response.bufferFactory().wrap(bytes);
            return response.writeWith(Mono.just(wrap));

        }
        return chain.filter(exchange);
    }

    // 设置此过滤器的执行顺序
    @Override
    public int getOrder() {
        return 1;
    }
}

package com.tongda.filter;

import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.SneakyThrows;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

import java.util.Arrays;
import java.util.HashMap;
import java.util.List;

/**
 * IP黑名单拦截
 * 网关里面 过滤器
 * IP拦截，请求都有一个源头
 * 电话 144 027 010
 * 请求--->gateway--->service
 * 根据数量，像具体的业务服务，一般黑名单
 * 黑名单：black_list
 * 白名单：white_list 数据库
 *
 */

@Component
public class IPCheckFilter implements GlobalFilter, Ordered {
    /**
     * 网关的并发比较高，不要再网关里面直接操作mysql
     * 后台系统可以查询数据库，用户量，并发量不大
     * 如果并发量大，可以查redis或者在内存中写好
     *      *
     * @param exchange
     * @param chain
     * @return {@link Mono< Void>}
     *
     * @date 2023/12/3 8:11
     **/
    public static final List<String> BLACK_LIST = Arrays.asList("127.0.0.1","115.128.232.147");

    // 拿到IP
    // 校验ip合法
    // 放行/拦截
    @SneakyThrows
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();// 获取请求头
        String ip = request.getHeaders().getHost().getHostString();// 获取ip
        // 查询数据库，看这个ip是否存在黑名单里面。
        // 只要是能存储数据的地方都叫数据库redis mysql
        if (!BLACK_LIST.contains(ip)) {
            // 符合放行
            return chain.filter(exchange);
        }
        // 拦截
        ServerHttpResponse response = exchange.getResponse(); // 响应
        response.getHeaders().set("content-type","application/json;charset=utf-8");
        HashMap<Object, Object> map = new HashMap<>(4);
        map.put("code",438);// 状态码438
        map.put("msg","你是黑名单");
        // 转换器
        ObjectMapper mapper = new ObjectMapper();
        byte[] bytes = mapper.writeValueAsBytes(map);// 字节数组
        DataBuffer wrap = response.bufferFactory().wrap(bytes);


        return response.writeWith(Mono.just(wrap));
    }


    @Override
    public int getOrder() {
        return 0;
    }
}

package com.tongda.domain;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 *
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private Integer id;
    private String name;
    private String pwd;
    private Integer age;
}

<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-data-redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <version>3.2.0</version>
        </dependency>

package com.tongda.controller;

import com.tongda.domain.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.time.Duration;
import java.util.UUID;


@RestController
public class LoginController {

    @Resource
    public StringRedisTemplate stringRedisTemplate;

    @GetMapping("doLogin")
    public String doLogin(String name,String pwd){
        System.out.println(name);
        System.out.println(pwd);
        // 假设去做了登录
        User user = new User(1,name,pwd,18);

        // token 登录获取
        String token = UUID.randomUUID().toString();

        // 存起来,set设置token,user.toString,时间小时3600，1天是86400秒
        stringRedisTemplate.opsForValue().set(token,user.toString(), Duration.ofSeconds(7200));

        return token;
    }

}

package com.tongda.filter;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

import java.io.StringReader;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;

/**
 * 前提是？和前端约定好，一般放在请求头里面，一般key:Authorization授权 value:bearer前缀token中
 * 1.拿到请求url
 * 2.判断放行
 * 3.拿到请求头
 * 4.拿到token
 * 5.校验
 * 6.放行/拦截
 *
 */
public class TokenCheckFilter implements GlobalFilter, Ordered {
    // 由于很多地址，只放允许的路径。
    public static final List<String> ALLOW_URL = Arrays.asList("/login-service/doLogin","myUrl");

    @Autowired
    private StringRedisTemplate redisTemplate;

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 拿请求url,路径
        ServerHttpRequest request = exchange.getRequest();
        String path = request.getURI().getPath();
        // 判断，是否包含匹配路径
        if (ALLOW_URL.contains(path)) {
            return chain.filter(exchange); // 包含就放行
        }
        // 检查
        HttpHeaders headers = request.getHeaders(); // 拿请求头
        List<String> authorization = headers.get("Authorization"); // 与前端约定好的
        // 判断
        if (!CollectionUtils.isEmpty(authorization)){ // 非空时
            String token = authorization.get(0); // 非空，取索引0
            if (StringUtils.hasText(token)){ // 再判断value中有前端约定
                // 约定好的前缀的bearer token
                String realToken = token.replaceFirst("bearer", "");
                // 判断，值不为空，并且redis有相同值
                if (StringUtils.hasText(realToken)&& redisTemplate.hasKey(realtoken)){
                    return chain.filter(exchange);
                }
            }
        }
        // 拦截
        ServerHttpResponse response = exchange.getResponse();
        response.getHeaders().set("content-type","application/json;charset=utf-8");

        HashMap<Object, Object> map = new HashMap<>(4);
        // 返回401
        map.put("code", HttpStatus.UNAUTHORIZED.value());
        map.put("msg","未授权");
        ObjectMapper objectMapper = new ObjectMapper();
        byte[] bytes = new byte[0];
        try {
            bytes = objectMapper.writeValueAsBytes(map);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        DataBuffer wrap = response.bufferFactory().wrap(bytes);
        return response.writeWith(Mono.just(wrap));
    }

    @Override
    public int getOrder() {
        return 0;
    }
}

package com.tongda.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 
@RestController
public class TeacherController {

    @GetMapping("teacher")
    public String Teacher() {
        return "教书学习";
    }
}

<!-- 限流https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-data-redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
            <version>3.2.0</version>
        </dependency>

package com.tongda.config;

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;

/**
 * 
 */
@Configuration
public class RequestLimitConfig {

    // 针对某一个接口ip来限流 /doLogin，每一个ip10s只能访问3次
    // keyResolver：key解析器
    @Bean("ipKeyResolver") // bean的名字默认就是方法名
    public KeyResolver ipkeyResolver() {
        // 获取IP地址
        return exchange -> Mono.just(exchange.getRequest().getHeaders().getHost().getHostString());
    }

    // 针对这个路径来限制 /doLogin 10秒内只能被访问3次，3次后只能到下一个10s
    // api,就是接口，外面一般把gateway叫api网关、新一代网关
    @Bean
    public KeyResolver apiKeyResolver(){
        return exchange -> Mono.just(exchange.getRequest().getPath().value());
    }
} 

server:
  port: 80  # 网关一般是80
spring:
  application:
    name: gateway-server
  cloud:
    gateway: # 如服务里有100个路径，但做负载均衡，要配动态路由结合Eureka注册中心
      enabled: true # 开启网关只要加载依赖，默认开启
      routes: # 设置路由，注意是数组，可以设置多个，按照id做隔离,
        - id: login-server-route # 这个是路由的ID，保持唯一即可
          uri: http://localhost:8081 # 此处设置真正的服务ip:port,uri：统一资源定位符，url：统一资源标识符
          predicates: # 断言匹配,断言是给某一路由来设定的
            - path=/doLogin # 匹配规则，和服务中的路径匹配，正则匹配规则模式，只要你path匹配上了/doLogin就往uri转发，并且uri路径后：IP:8081/doLogin
        - id: login2-server-route # 路由id,没有要求，保持唯一即可
          uri: http://localhost:8082
          predicates:  # 断言是给某一路由来设定的，如服务中有100个路径
            - path=/dologin2/** # 如果匹配到第一个路由，则第二个就不会走了，注意这不是负载均衡。
            - After=2020-01-20T17:42:47.789-07:00[Asia/Shanghai] #此断言匹配发生在指定日期时间之后的请求，ZonedDateTime dateTime=ZonedDateTime.now()获得
#            - Before=2020-06-18T21:26:26.711+08:00[Asia/Shanghai] #此断言匹配发生在指定日期时间之前的请求
#            - Between=2020-06-18T21:26:26.711+08:00[Asia/Shanghai],2020-06-18T21:32:26.711+08:00[Asia/Shanghai]
            #此断言匹配发生在指定日期时间之间的请求
#            - Cookie=name,xiaobai #Cookie 路由断言工厂接受两个参数，Cookie 名称和 regexp(一 个 Java 正则表达式)。此断言匹配具有给定名称且其值与正则表达式匹配的 cookie
#            - Header=token,123456 #头路由断言工厂接受两个参数，头名称和 regexp(一个 Java 正则表达式)。此断言与具有给定名称的头匹配，该头的值与正则表达式匹配。
#            - Host=**.bai*.com:* #主机路由断言工厂接受一个参数:主机名模式列表。该模式是一个 ant 样式的模式。作为分隔符。此断言匹配与模式匹配的主机头
            - Method=GET,POST #方法路由断言工厂接受一个方法参数，该参数是一个或多个参数:要匹配的 HTTP 方法
#            - Query=username,cxs #查询路由断言工厂接受两个参数:一个必需的 param 和一个可选的 regexp(一个 Java 正则表达式)。
#            - RemoteAddr=192.168.1.1/24 #RemoteAddr 路由断言工厂接受一个源列表(最小大小 1)，这些源是 cidr 符号(IPv4 或 IPv6)字符串，比如 192.168.1.1/24(其中 192.168.1.1 是 IP 地址，24 是子网掩码)。
          filters:
            - name: RequestRatelimiter # 这个是过滤器的名称
              ages: # 这个过滤器的参数
                key-resolver: '#{@hostAddrKeyResolver}'  # 通过spel表达式取ioc容器中bean的值
                redis-rate-limiter.replenishRate: 1 # 生成令牌的速度
                redis-rate-limiter.burstCapacity: 3 # 桶容量

      discovery:
        locator:
          enabled: true #开启动态路由，开启通用应用名称，找到服务的功能
          lower-case-service-id: true #开启服务名称小写
# eureka 的配置
eureka:
  instance:
    instance-id: ${spring.application.name}:${server.port}
    prefer-ip-address: true
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/
    registry-fetch-interval-seconds: 3 #网关拉取服务列表的时间缩短

server:
  port: 80
spring:
  application:
    name: gateway-80
  cloud:
    gateway:
    enabled: true
    routes:
      - id: user-service
        uri: lb://consumer-user-service
        predicates:
          - Path=/info/**
        filters:
          - name: RequestRatelimiter # 这个是过滤器的名称
            ages: # 这个过滤器的参数
              key-resolver: '#{@hostAddrKeyResolver}'  # 通过spel表达式取ioc容器中bean的值
              redis-rate-limiter.replenishRate: 1 # 生成令牌的速度
              redis-rate-limiter.burstCapacity: 3 # 桶容量
  redis: #redis 的配置
    host: 192.168.226.128
    port: 6379
    database: 0
eureka:
    instance:
      instance-id: ${spring.application.name}:${server.port}
      prefer-ip-address: true
    client:
      service-url:
        defaultZone: http://localhost:8761/eureka/

package com.tongda.config;

import org.springframework.cloud.gateway.filter.ratelimit.KeyResolver;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Primary;
import reactor.core.publisher.Mono;


public class RequestLimitConfig1 {
    /*
     * IP限流
     * 把用户的IP作为限流的key
     * 
     * @param null 
     * @return {@link null}
     * 
     **/
    @Bean
    @Primary  // 主候选
    public KeyResolver hostAddrkeyResolver() {
        return (exchange -> Mono.just(exchange.getRequest().getRemoteAddress().getHostName()));
    }
    
    // 用户ID限流
    // 把用户id作为限流的key
    @Bean
    public KeyResolver userKeyResolver() {
        return exchange -> Mono.just(exchange.getRequest().getQueryParams().getFirst('userId'));
    }
    
    // 请求接口限流
    // 把请求的路径作为限流Key
    @Bean
    public KeyResolver apiKeyResolver() {
        return exchange -> Mono.just(exchange.getRequest().getPath().value());
    }
    
}

package com.tongda.filter;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.reactive.CorsWebFilter;
import org.springframework.web.cors.reactive.UrlBasedCorsConfigurationSource;
import org.springframework.web.util.pattern.PathPatternParser;


// 跨域：放开所有
// 第二种是在：yaml写跨域
@Configuration
public class CorsConfig {
    @Bean
    public CorsWebFilter corsFilter() {
        CorsConfiguration config = new CorsConfiguration();
        config.addAllowedMethod("*");
        config.addAllowedOrigin("*");
        config.addAllowedHeader("*");
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource(new PathPatternParser());
        source.registerCorsConfiguration("/**", config);
        return new CorsWebFilter(source);
    }
}

server:
  port: 80  # 网关一般是80
spring:
  application:
    name: gateway-server
  cloud:
    gateway: # 如服务里有100个路径，但做负载均衡，要配动态路由结合Eureka注册中心
      enabled: true # 开启网关只要加载依赖，默认开启
      routes: # 设置路由，注意是数组，可以设置多个，按照id做隔离,
        - id: login-server-route # 这个是路由的ID，保持唯一即可
          uri: http://localhost:8081 # 此处设置真正的服务ip:port,uri：统一资源定位符，url：统一资源标识符
          predicates: # 断言匹配,断言是给某一路由来设定的
            - path=/doLogin # 匹配规则，和服务中的路径匹配，正则匹配规则模式，只要你path匹配上了/doLogin就往uri转发，并且uri路径后：IP:8081/doLogin
        - id: login2-server-route # 路由id,没有要求，保持唯一即可
          uri: http://localhost:8082
          predicates:  # 断言是给某一路由来设定的，如服务中有100个路径
            - path=/dologin2/** # 如果匹配到第一个路由，则第二个就不会走了，注意这不是负载均衡。
            - After=2020-01-20T17:42:47.789-07:00[Asia/Shanghai] #此断言匹配发生在指定日期时间之后的请求，ZonedDateTime dateTime=ZonedDateTime.now()获得
#            - Before=2020-06-18T21:26:26.711+08:00[Asia/Shanghai] #此断言匹配发生在指定日期时间之前的请求
#            - Between=2020-06-18T21:26:26.711+08:00[Asia/Shanghai],2020-06-18T21:32:26.711+08:00[Asia/Shanghai]
            #此断言匹配发生在指定日期时间之间的请求
#            - Cookie=name,xiaobai #Cookie 路由断言工厂接受两个参数，Cookie 名称和 regexp(一 个 Java 正则表达式)。此断言匹配具有给定名称且其值与正则表达式匹配的 cookie
#            - Header=token,123456 #头路由断言工厂接受两个参数，头名称和 regexp(一个 Java 正则表达式)。此断言与具有给定名称的头匹配，该头的值与正则表达式匹配。
#            - Host=**.bai*.com:* #主机路由断言工厂接受一个参数:主机名模式列表。该模式是一个 ant 样式的模式。作为分隔符。此断言匹配与模式匹配的主机头
            - Method=GET,POST #方法路由断言工厂接受一个方法参数，该参数是一个或多个参数:要匹配的 HTTP 方法
#            - Query=username,cxs #查询路由断言工厂接受两个参数:一个必需的 param 和一个可选的 regexp(一个 Java 正则表达式)。
#            - RemoteAddr=192.168.1.1/24 #RemoteAddr 路由断言工厂接受一个源列表(最小大小 1)，这些源是 cidr 符号(IPv4 或 IPv6)字符串，比如 192.168.1.1/24(其中 192.168.1.1 是 IP 地址，24 是子网掩码)。
          filters:
            - name: RequestRatelimiter # 这个是过滤器的名称
              ages: # 这个过滤器的参数
                key-resolver: '#{@hostAddrKeyResolver}'  # 通过spel表达式取ioc容器中bean的值
                redis-rate-limiter.replenishRate: 1 # 生成令牌的速度
                redis-rate-limiter.burstCapacity: 3 # 桶容量

      discovery:
        locator:
          enabled: true #开启动态路由，开启通用应用名称，找到服务的功能
          lower-case-service-id: true #开启服务名称小写
      # 跨域设置
      globalcors: # 全局跨越配置
        cors-configurations:
          '[/**]':
            allowCredentials: true  # 可以携带cookie跨域
            allowedHeaders: # 头
              - '*'
            allowedMethods: # 方法
              - '*'
            allowedOrigins: # 源
              - '*'

# eureka 的配置
eureka:
  instance:
    instance-id: ${spring.application.name}:${server.port}
    prefer-ip-address: true
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/
    registry-fetch-interval-seconds: 3 #网关拉取服务列表的时间缩短

spring:
    cloud:
        gateway:
            globalcors:
                corsConfigurations:
                    '[/**]': // 针对哪些路径
                        allowCredentials: true // 这个是可以携带 cookie   
                        allowedHeaders: '*'
                        allowedMethods: '*'
                        allowedOrigins: '*'    

<!-- 健康检查的依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

management:
    endpoints:
        web:
            exposure:    
                include: '*' #暴露检查的端点