1
private Product getProductFromRemoteWithLoadBalancerAnnotation(Long productId) {
2
    // 给远程发送请求：service-product 会被动态替换
3
    String url = "http://service-product/product/" + productId;
4
    log.info("远程请求: {}", url);
5
    // 给远程发送请求
6
    return restTemplate.getForObject(url, Product.class);
7
}

1
<dependency>
2
    <groupId>org.springframework.cloud</groupId>
3
    <artifactId>spring-cloud-starter-openfeign</artifactId>
4
</dependency>

1
@EnableFeignClients

1
logging:
2
  level:
3
    # 指定 feign 接口所在的包的日志级别为 debug 级别
4
    indi.mofan.order.feign: debug

1
@Bean
2
public Logger.Level feignlogLevel() {
3
    // 指定 OpenFeign 发请求时，日志级别为 FULL
4
    return Logger.Level.FULL;
5
}

1
spring:
2
  cloud:
3
    openfeign:
4
      client:
5
        config:
6
          # 默认配置
7
          default:
8
            logger-level: full
9
            connect-timeout: 1000
10
            read-timeout: 2000
11
          # 具体 feign 客户端的超时配置
12
          service-product:
13
            logger-level: full
14
            # 连接超时，3000 毫秒
15
            connect-timeout: 3000
16
            # 读取超时，5000 毫秒
17
            read-timeout: 5000

1
@Bean
2
public Retryer retryer() {
3
    return new Retryer.Default();
4
}

1
public Default() {
2
    this(100L, TimeUnit.SECONDS.toMillis(1L), 5);
3
}

1
package indi.mofan.order.interceptor;
2

3
public class XTokenRequestInterceptor implements RequestInterceptor {
4
    /**
5
     * 请求拦截器
6
     *
7
     * @param template 封装本次请求的详细信息
8
     */
9
    @Override
10
    public void apply(RequestTemplate template) {
11
        System.out.println("XTokenRequestInterceptor ...");
12
        template.header("X-Token", UUID.randomUUID().toString());
13
    }
14
}

1
<dependency>
2
    <groupId>com.alibaba.cloud</groupId>
3
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
4
</dependency>

1
feign:
2
  sentinel:
3
    enabled: true

1
@Component
2
public class ProductFeignClientFallback implements ProductFeignClient {
3
    @Override
4
    public Product getProductById(Long id) {
5
        System.out.println("Fallback...");
6
        Product product = new Product();
7
        product.setId(id);
8
        product.setPrice(new BigDecimal("0"));
9
        product.setProductName("未知商品");
10
        product.setNum(0);
11
        return product;
12
    }
13
}

1
@FeignClient(value = "service-product", fallback = ProductFeignClientFallback.class)
2
public interface ProductFeignClient {
3

4
    @GetMapping("/product/{id}")
5
    Product getProductById(@PathVariable("id") Long id);
6
}

1
java -jar sentinel-dashboard-1.8.8.jar

1
<dependency>
2
    <groupId>com.alibaba.cloud</groupId>
3
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
4
</dependency>

1
spring:
2
  application:
3
    name: service-product
4
  cloud:
5
    sentinel:
6
      transport:
7
        # 控制台地址
8
        dashboard: localhost:8080
9
      # 立即加载服务
10
      eager: true

1
@Component
2
public class MyBlockExceptionHandler implements BlockExceptionHandler {
3

4
    private final ObjectMapper objectMapper;
5

6
    public MyBlockExceptionHandler(ObjectMapper objectMapper) {
7
        this.objectMapper = objectMapper;
8
    }
9

10
    @Override
11
    public void handle(HttpServletRequest request,
12
                       HttpServletResponse response,
13
                       String resourceName,
14
                       BlockException e) throws Exception {
15
        response.setContentType("application/json;charset=utf-8");
16
        PrintWriter writer = response.getWriter();
17

18
        R error = R.error(500, resourceName + " 被 Sentinel 限制了, 原因: " + e.getClass());
19

20
        String json = objectMapper.writeValueAsString(error);
21
        writer.write(json);
22

23
        writer.flush();
24
        writer.close();
25
    }
26
}

1
{
2
    "code": 500,
3
    "message": "/create 被 Sentinel 限制了, 原因: class com.alibaba.csp.sentinel.slots.block.flow.FlowException",
4
    "data": null
5
}

1
@SentinelResource(value = "createOrder", blockHandler = "createOrderFallback")
2
public Order createOrder(Long productId, Long userId) {
3
    // --snip--
4
}

1
/**
2
 * 指定兜底回调
3
 */
4
public Order createOrderFallback(Long productId, Long userId, BlockException e) {
5
    Order order = new Order();
6
    order.setId(0L);
7
    order.setTotalAmount(new BigDecimal("0"));
8
    order.setUserId(userId);
9
    order.setNickname("未知用户");
10
    order.setAddress("异常信息: " + e.getClass());
11
    return order;
12
}

1
{
2
    "id": 0,
3
    "totalAmount": 0,
4
    "userId": 666,
5
    "nickname": "未知用户",
6
    "address": "异常信息: class com.alibaba.csp.sentinel.slots.block.flow.FlowException",
7
    "productList": null
8
}

1
@GetMapping("/seckill")
2
@SentinelResource(value = "seckill-order", fallback = "seckillFallback")
3
public Order seckill(@RequestParam(value = "userId", required = false) Long userId,
4
                     @RequestParam(value = "productId", defaultValue = "1000") Long productId) {
5
    Order order = orderService.createOrder(productId, userId);
6
    order.setId(Long.MAX_VALUE);
7
    return order;
8
}
9

10
public Order seckillFallback(Long userId,
11
                             Long productId,
12
                             // 使用 fallback，而不是 blockHandler
13
                             // 最后一个参数类型是 Throwable，而不是 BlockException
14
                             Throwable throwable) {
15
    System.out.println("seckillFallback...");
16
    Order order = new Order();
17
    order.setId(productId);
18
    order.setUserId(userId);
19
    order.setAddress("异常信息: " + throwable.getClass());
20
    return order;
21
}

1
@GetMapping("/seckill")
2
@SentinelResource(value = "seckill-order", fallback = "seckillFallback")
3
public Order seckill(@RequestParam(value = "userId", defaultValue = "888") Long userId,
4
                     @RequestParam(value = "productId", defaultValue = "1000") Long productId) {
5
    // --snip--
6
}

1
@GetMapping("/seckill")
2
@SentinelResource(value = "seckill-order", fallback = "seckillFallback")
3
public Order seckill(@RequestParam(value = "userId", required = false) Long userId,
4
                     @RequestParam(value = "productId", defaultValue = "1000") Long productId) {
5
    // --snip--
6
}

1
spring:
2
  cloud:
3
    gateway:
4
      server:
5
        webflux:
6
          routes:
7
            - id: bing-route
8
              uri: https://cn.bing.com
9
              predicates:
10
                - Path=/**
11
              order: 10
12

13
            - id: order-route
14
              uri: lb://service-order
15
              predicates:
16
                - Path=/api/order/**
17
              order: 1
18

19
            - id: product-route
20
              uri: lb://service-product
21
              predicates:
22
                - Path=/api/product/**
23
              order: 2

1
spring:
2
  cloud:
3
    gateway:
4
      server:
5
        webflux:
6
          routes:
7
              # id 全局唯一
8
            - id: order-route
9
              # 指定服务名称
10
              uri: lb://service-order
11
              # 指定断言规则，即路由匹配规则
12
              # Fully Expanded Arguments
13
              predicates:
14
                - name: Path
15
                  args:
16
                    patterns: /api/order/**
17
                    matchTrailingSlash: true
18
            - id: product-route
19
              uri: lb://service-product
20
              # Shortcut Configuration
21
              predicates:
22
                - Path=/api/product/**

1
spring:
2
  cloud:
3
    gateway:
4
      server:
5
        webflux:
6
          routes:
7
            - id: bing-route
8
              uri: https://cn.bing.com
9
              predicates:
10
                - name: Path
11
                  args:
12
                    patterns: /search
13
                - name: Query
14
                  args:
15
                    param: q
16
                    regexp: haha

1
spring:
2
  cloud:
3
    gateway:
4
      server:
5
        webflux:
6
          routes:
7
            - id: bing-route
8
              uri: https://cn.bing.com
9
              predicates:
10
                - name: Path
11
                  args:
12
                    patterns: /search
13
                - name: Query
14
                  args:
15
                    param: q
16
                    regexp: haha
17
                - Vip=user,mofan

1
/**
2
 * @author mofan
3
 * @date 2025/4/29 22:49
4
 */
5
@Component
6
public class VipRoutePredicateFactory extends AbstractRoutePredicateFactory<VipRoutePredicateFactory.Config> {
7

8

9
    public VipRoutePredicateFactory() {
10
        super(Config.class);
11
    }
12

13
    @Override
14
    public List<String> shortcutFieldOrder() {
15
        return List.of("param", "value");
16
    }
17

18
    @Override
19
    public Predicate<ServerWebExchange> apply(Config config) {
20
        return (GatewayPredicate) serverWebExchange -> {
21
            // localhost/search?q=haha&user=mofan
22
            ServerHttpRequest request = serverWebExchange.getRequest();
23
            String first = request.getQueryParams().getFirst(config.param);
24
            return StringUtils.hasText(first) && first.equals(config.value);
25
        };
26
    }
27

28
    @Validated
29
    @Getter
30
    @Setter
31
    public static class Config {
32
        @NotEmpty
33
        private String param;
34
        @NotEmpty
35
        private String value;
36
    }
37
}

1
spring:
2
  cloud:
3
    gateway:
4
      server:
5
        webflux:
6
          routes:
7
              # id 全局唯一
8
            - id: order-route
9
              # 指定服务名称
10
              uri: lb://service-order
11
              # 指定断言规则，即路由匹配规则
12
              # Fully Expanded Arguments
13
              predicates:
14
                - name: Path
15
                  args:
16
                    patterns: /api/order/**
17
                    matchTrailingSlash: true
18
              filters:
19
                # 类似把 /api/order/a/bc 重写为 /a/bc，移除路径前的 /api/order/
20
                - RewritePath=/api/order/?(?<segment>.*), /$\{segment}
21
              order: 1
22
            - id: product-route
23
              uri: lb://service-product
24
              # Shortcut Configuration
25
              predicates:
26
                - Path=/api/product/**
27
              filters:
28
                - RewritePath=/api/product/?(?<segment>.*), /$\{segment}
29
              order: 2

1
spring:
2
  cloud:
3
    gateway:
4
      server:
5
        webflux:
6
          default-filters:
7
            # 为所有路由添加响应头过滤器
8
            - AddResponseHeader=X-Response-Abc, 123

1
/**
2
 * @author mofan
3
 * @date 2025/5/1 13:49
4
 */
5
@Slf4j
6
@Component
7
public class RtGlobalFilter implements GlobalFilter, Ordered {
8
    @Override
9
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
10
        ServerHttpRequest request = exchange.getRequest();
11
        String uri = request.getURI().toString();
12
        long start = System.currentTimeMillis();
13
        log.info("请求 [{}] 开始，时间：{}", uri, start);
14
        return chain.filter(exchange)
15
                .doFinally(res -> {
16
                    long end = System.currentTimeMillis();
17
                    log.info("请求 [{}] 结束，时间：{}，耗时：{}ms", uri, start, end - start);
18
                });
19
    }
20

21
    @Override
22
    public int getOrder() {
23
        return 0;
24
    }
25
}

1
/**
2
 * @author mofan
3
 * @date 2025/5/1 14:24
4
 */
5
@Component
6
public class OnceTokenGatewayFilterFactory extends AbstractNameValueGatewayFilterFactory {
7
    @Override
8
    public GatewayFilter apply(NameValueConfig config) {
9
        return (exchange, chain) -> chain.filter(exchange).then(Mono.fromRunnable(() -> {
10
            ServerHttpResponse response = exchange.getResponse();
11

12
            String value = switch (config.getValue().toLowerCase()) {
13
                case "uuid" -> UUID.randomUUID().toString();
14
                case "jwt" -> "Test Token";
15
                default -> "";
16
            };
17

18
            HttpHeaders headers = response.getHeaders();
19
            headers.add(config.getName(), value);
20
        }));
21
    }
22
}

1
spring:
2
  cloud:
3
    gateway:
4
      server:
5
        webflux:
6
          routes:
7
            - id: order-route
8
              uri: lb://service-order
9
              filters:
10
                # 自定义过滤器
11
                - OnceToken=X-Response-Token, uuid

1
spring:
2
  cloud:
3
    gateway:
4
      server:
5
        webflux:
6
          globalcors:
7
            cors-configurations:
8
              '[/**]':
9
                allowed-origin-patterns: '*'
10
                allowed-headers: '*'
11
                allowedMethods: '*'