1
# Resilience4j CircuitBreaker 按照次数：COUNT_BASED 的例子
2
#  6次访问中当执行方法的失败率达到50%时CircuitBreaker将进入开启OPEN状态(保险丝跳闸断电)拒绝所有请求。
3
#  等待5秒后，CircuitBreaker 将自动从开启OPEN状态过渡到半开HALF_OPEN状态，允许一些请求通过以测试服务是否恢复正常。
4
#  如还是异常CircuitBreaker 将重新进入开启OPEN状态；如正常将进入关闭CLOSE闭合状态恢复正常处理请求。
5
resilience4j:
6
  circuitbreaker:
7
    configs:
8
      default:
9
        failureRateThreshold: 50 #设置50%的调用失败时打开断路器，超过失败请求百分⽐CircuitBreaker变为OPEN状态。
10
                slidingWindowType: COUNT_BASED # 滑动窗口的类型
11
                slidingWindowSize: 6 #滑动窗⼝的⼤⼩配置COUNT_BASED表示6个请求，配置TIME_BASED表示6秒
12
                minimumNumberOfCalls: 6 #断路器计算失败率或慢调用率之前所需的最小样本(每个滑动窗口周期)。如果minimumNumberOfCalls为10，则必须最少记录10个样本，然后才能计算失败率。如果只记录了9次调用，即使所有9次调用都失败，断路器也不会开启。
13
                automaticTransitionFromOpenToHalfOpenEnabled: true # 是否启用自动从开启状态过渡到半开状态，默认值为true。如果启用，CircuitBreaker将自动从开启状态过渡到半开状态，并允许一些请求通过以测试服务是否恢复正常
14
                waitDurationInOpenState: 5s #从OPEN到HALF_OPEN状态需要等待的时间
15
                permittedNumberOfCallsInHalfOpenState: 2 #半开状态允许的最大请求数，默认值为10。在半开状态下，CircuitBreaker将允许最多permittedNumberOfCallsInHalfOpenState个请求通过，如果其中有任何一个请求失败，CircuitBreaker将重新进入开启状态。
16
                recordExceptions:
17
          - java.lang.Exception
18
    instances:
19
      cloud-payment-service:
20
        baseConfig: default

1
# Resilience4j CircuitBreaker 按照时间：TIME_BASED 的例子
2
resilience4j:
3
  timelimiter:
4
    configs:
5
      default:
6
        timeout-duration: 10s #神坑的位置，timelimiter 默认限制远程1s，超于1s就超时异常，配置了降级，就走降级逻辑
7
  circuitbreaker:
8
    configs:
9
      default:
10
        failureRateThreshold: 50 #设置50%的调用失败时打开断路器，超过失败请求百分⽐CircuitBreaker变为OPEN状态。
11
        slowCallDurationThreshold: 2s #慢调用时间阈值，高于这个阈值的视为慢调用并增加慢调用比例。
12
        slowCallRateThreshold: 30 #慢调用百分比峰值，断路器把调用时间⼤于slowCallDurationThreshold，视为慢调用，当慢调用比例高于阈值，断路器打开，并开启服务降级
13
        slidingWindowType: TIME_BASED # 滑动窗口的类型
14
        slidingWindowSize: 2 #滑动窗口的大小配置，配置TIME_BASED表示2秒
15
        minimumNumberOfCalls: 2 #断路器计算失败率或慢调用率之前所需的最小样本(每个滑动窗口周期)。
16
        permittedNumberOfCallsInHalfOpenState: 2 #半开状态允许的最大请求数，默认值为10。
17
        waitDurationInOpenState: 5s #从OPEN到HALF_OPEN状态需要等待的时间
18
        recordExceptions:
19
          - java.lang.Exception
20
    instances:
21
      cloud-payment-service:
22
        baseConfig: default

1
<dependency>
2
    <groupId>io.github.resilience4j</groupId>
3
    <artifactId>resilience4j-bulkhead</artifactId>
4
</dependency>

1
resilience4j:
2
  bulkhead:
3
    configs:
4
      default:
5
        maxConcurrentCalls: 2 # 隔离允许并发线程执行的最大数量
6
        maxWaitDuration: 1s # 当达到并发调用数量时，新的线程的阻塞时间，我只愿意等待1秒，过时不候进舱壁兜底
7
    instances:
8
      cloud-payment-service:
9
        baseConfig: default
10
  timelimiter:
11
    configs:
12
      default:
13
        timeout-duration: 20s

1
/**
2
 *(船的)舱壁,隔离
3
 * @param id
4
 * @return
5
 */
6
@GetMapping(value = "/feign/pay/bulkhead/{id}")
7
@Bulkhead(name = "cloud-payment-service",fallbackMethod = "myBulkheadFallback",type = Bulkhead.Type.SEMAPHORE)
8
public String myBulkhead(@PathVariable("id") Integer id)
9
{
10
    return payFeignApi.myBulkhead(id);
11
}
12
public String myBulkheadFallback(Throwable t)
13
{
14
    return "myBulkheadFallback，隔板超出最大数量限制，系统繁忙，请稍后再试-----/(ㄒoㄒ)/~~";
15
}

1
<dependency>
2
    <groupId>io.github.resilience4j</groupId>
3
    <artifactId>resilience4j-bulkhead</artifactId>
4
</dependency>

1
####resilience4j bulkhead -THREADPOOL的例子
2
resilience4j:
3
  timelimiter:
4
    configs:
5
      default:
6
        timeout-duration: 10s #timelimiter默认限制远程1s，超过报错不好演示效果所以加上10秒
7
  thread-pool-bulkhead:
8
    configs:
9
      default:
10
        core-thread-pool-size: 1
11
        max-thread-pool-size: 1
12
        queue-capacity: 1
13
    instances:
14
      cloud-payment-service:
15
        baseConfig: default
16
# spring.cloud.openfeign.circuitbreaker.group.enabled 请设置为false 新启线程和原来主线程脱离

1
/**
2
 * (船的)舱壁,隔离,THREADPOOL
3
 * @param id
4
 * @return
5
 */
6
@GetMapping(value = "/feign/pay/bulkhead/{id}")
7
@Bulkhead(name = "cloud-payment-service",fallbackMethod = "myBulkheadPoolFallback",type = Bulkhead.Type.THREADPOOL)
8
public CompletableFuture<String> myBulkheadTHREADPOOL(@PathVariable("id") Integer id)
9
{
10
    System.out.println(Thread.currentThread().getName()+"\t"+"enter the method!!!");
11
    try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }
12
    System.out.println(Thread.currentThread().getName()+"\t"+"exist the method!!!");
13

14
    return CompletableFuture.supplyAsync(() -> payFeignApi.myBulkhead(id) + "\t" + " Bulkhead.Type.THREADPOOL");
15
}
16
public CompletableFuture<String> myBulkheadPoolFallback(Integer id,Throwable t)
17
{
18
    return CompletableFuture.supplyAsync(() -> "Bulkhead.Type.THREADPOOL，系统繁忙，请稍后再试-----/(ㄒoㄒ)/~~");
19
}

1
<!--resilience4j-ratelimiter-->
2
<dependency>
3
    <groupId>io.github.resilience4j</groupId>
4
    <artifactId>resilience4j-ratelimiter</artifactId>
5
</dependency>

1
####resilience4j ratelimiter 限流的例子
2
resilience4j:
3
  ratelimiter:
4
    configs:
5
      default:
6
        limitForPeriod: 2 #在一次刷新周期内，允许执行的最大请求数
7
        limitRefreshPeriod: 1s # 限流器每隔limitRefreshPeriod刷新一次，将允许处理的最大请求数量重置为limitForPeriod
8
        timeout-duration: 1 # 线程等待权限的默认等待时间
9
    instances:
10
        cloud-payment-service:
11
          baseConfig: default

1
//=========Resilience4j ratelimit 的例子
2
@GetMapping(value = "/pay/ratelimit/{id}")
3
public String myRatelimit(@PathVariable("id") Integer id)
4
{
5
    return "Hello, myRatelimit欢迎到来 inputId:  "+id+" \t " + IdUtil.simpleUUID();
6
}

1
/**
2
 * Resilience4j Ratelimit 的例子 OpenFeign
3
 * @param id
4
 * @return
5
 */
6
@GetMapping(value = "/pay/ratelimit/{id}")
7
public String myRatelimit(@PathVariable("id") Integer id);

1
 @GetMapping(value = "/feign/pay/ratelimit/{id}")
2
@RateLimiter(name = "cloud-payment-service",fallbackMethod = "myRatelimitFallback")
3
public String myBulkhead(@PathVariable("id") Integer id)
4
{
5
    return payFeignApi.myRatelimit(id);
6
}
7
public String myRatelimitFallback(Integer id,Throwable t)
8
{
9
    return "你被限流了，禁止访问/(ㄒoㄒ)/~~";
10
}

1
    gateway:
2
      routes:
3
        - id: pay_routh1 #pay_routh1                #路由的ID(类似mysql主键ID)，没有固定规则但要求唯一，建议配合服务名
4
          #uri: http://localhost:8001                #匹配后提供服务的路由地址
5
          uri: lb://cloud-payment-service          #匹配后提供服务的路由地址
6
          predicates:
7
            - Path=/pay/gateway/get/**              # 断言，路径相匹配的进行路由
8

9
        - id: pay_routh2 #pay_routh2                #路由的ID(类似mysql主键ID)，没有固定规则但要求唯一，建议配合服务名
10
          #uri: http://localhost:8001                #匹配后提供服务的路由地址
11
          uri: lb://cloud-payment-service                #匹配后提供服务的路由地址
12
          predicates:
13
            - Path=/pay/gateway/info/**              # 断言，路径相匹配的进行路由

1
          predicates:
2
            - Path=/pay/gateway/get/** # 断言，路径相匹配的进行路由
3
            - After=2023-11-20T17:38:13.586918800+08:00[Asia/Shanghai] #只有在xx之后的发起的请求可以通过
4
            - Before=2023-11-27T15:25:06.424566300+08:00[Asia/Shanghai] #超过规定时间不可访问
5
            - Between=2023-11-21T17:38:13.586918800+08:00[Asia/Shanghai],2023-11-22T17:38:13.586918800+08:00[Asia/Shanghai]
6
            - Cookie=username,zzyy
7
            - Header=X-Request-Id, \d+ # 请求头要有X-Request-Id属性并且值为整数的正则表达式
8
            - Host=**.atguigu.com
9
            - Path=/pay/gateway/get/** # 断言，路径相匹配的进行路由
10
            - Query=username, \d+  # 要有参数名username并且值还要是整数才能路由
11
            - RemoteAddr=192.168.124.1/24 # 外部访问我的IP限制，最大跨度不超过32，目前是1~24它们是 CIDR 表示法。
12
            - Metohd=GET,POST

1
@Component
2
public class MyRoutePredicateFactory extends AbstractRoutePredicateFactory<MyRoutePredicateFactory.Config>
3
{
4
}

1
@Override
2
public Predicate<ServerWebExchange> apply(MyRoutePredicateFactory.Config config)
3
{
4
       return new Predicate<ServerWebExchange>()
5
    {
6
        @Override
7
        public boolean test(ServerWebExchange serverWebExchange)
8
        {
9
            //检查request的参数里面，userType是否为指定的值，符合配置就通过
10
            String userType = serverWebExchange.getRequest().getQueryParams().getFirst("userType");
11

12
            if (userType == null) return false;
13

14
            //如果说参数存在，就和config的数据进行比较
15
            if(userType.equals(config.getUserType())) {
16
                return true;
17
            }
18

19
            return false;
20
        }
21
    }
22
}

1
@Validated
2
public static class Config{
3
    @Setter
4
    @Getter
5
    @NotEmpty
6
    private String userType; //钻、金、银等用户等级
7
}

1
public MyRoutePredicateFactory()
2
{
3
    super(MyRoutePredicateFactory.Config.class);
4
}

1
@Override
2
public List<String> shortcutFieldOrder() {
3
  return Collections.singletonList("userType");
4
}

1
package com.atguigu.cloud.mygateway;
2

3
import lombok.extern.slf4j.Slf4j;
4
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
5
import org.springframework.cloud.gateway.filter.GlobalFilter;
6
import org.springframework.core.Ordered;
7
import org.springframework.stereotype.Component;
8
import org.springframework.web.server.ServerWebExchange;
9
import reactor.core.publisher.Mono;
10

11
@Component
12
@Slf4j
13
public class MyGlobalFilter implements GlobalFilter, Ordered
14
{
15

16
    /**
17
     * 数字越小优先级越高
18
     * @return
19
     */
20
    @Override
21
    public int getOrder()
22
    {
23
        return 0;
24
    }
25

26
    private static final String BEGIN_VISIT_TIME = "begin_visit_time";//开始访问时间
27
    @Override
28
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
29
        //先记录下访问接口的开始时间
30
        exchange.getAttributes().put(BEGIN_VISIT_TIME, System.currentTimeMillis());
31

32
        return chain.filter(exchange).then(Mono.fromRunnable(()->{
33
            Long beginVisitTime = exchange.getAttribute(BEGIN_VISIT_TIME);
34
            if (beginVisitTime != null){
35
                log.info("访问接口主机: " + exchange.getRequest().getURI().getHost());
36
                log.info("访问接口端口: " + exchange.getRequest().getURI().getPort());
37
                log.info("访问接口URL: " + exchange.getRequest().getURI().getPath());
38
                log.info("访问接口URL参数: " + exchange.getRequest().getURI().getRawQuery());
39
                log.info("访问接口时长: " + (System.currentTimeMillis() - beginVisitTime) + "ms");
40
                log.info("我是美丽分割线: ###################################################");
41
                System.out.println();
42
            }
43
        }));
44
    }
45

46
}

1
server:
2
  port: 9527
3

4
spring:
5
  application:
6
    name: cloud-gateway #以微服务注册进consul或nacos服务列表内
7
  cloud:
8
    consul: #配置consul地址
9
      host: localhost
10
      port: 8500
11
      discovery:
12
        prefer-ip-address: true
13
        service-name: ${spring.application.name}
14
    gateway:
15
      routes:
16
        - id: pay_routh1 #pay_routh1                #路由的ID(类似mysql主键ID)，没有固定规则但要求唯一，建议配合服务名
17
          uri: lb://cloud-payment-service                #匹配后提供服务的路由地址
18
          predicates:
19
            - Path=/pay/gateway/get/**              # 断言，路径相匹配的进行路由
20
            - After=2023-12-30T23:02:39.079979400+08:00[Asia/Shanghai]
21

22
        - id: pay_routh2 #pay_routh2                #路由的ID(类似mysql主键ID)，没有固定规则但要求唯一，建议配合服务名
23
          uri: lb://cloud-payment-service
24
          predicates:
25
            - Path=/pay/gateway/info/**              # 断言，路径相匹配的进行路由
26

27
        - id: pay_routh3 #pay_routh3
28
          uri: lb://cloud-payment-service                #匹配后提供服务的路由地址
29
          predicates:
30
            - Path=/pay/gateway/filter/**              # 断言，路径相匹配的进行路由，默认正确地址
31
          filters:
32
            - AddRequestHeader=X-Request-atguigu1,atguiguValue1  # 请求头kv，若一头含有多参则重写一行设置

1
@Component
2

3
public class MyGatewayFilterFactory extends AbstractGatewayFilterFactory<MyGatewayFilterFactory.Config>
4
{
5
}

1
@Component
2
public class MyGatewayFilterFactory extends AbstractGatewayFilterFactory<MyGatewayFilterFactory.Config>
3
{
4
    public static class Config {
5
        @Setter @Getter
6
        private String status;
7
    }
8
}

1
  @Override
2
    public GatewayFilter apply(MyGatewayFilterFactory.Config config)
3
    {
4
        return new GatewayFilter() {
5
            @Override
6
            public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
7
                ServerHttpRequest request =  exchange.getRequest();
8
                System.out.println("进入自定义网关过滤器MyGatewayFilterFactory，status===="+config.getStatus());
9
                if(request.getQueryParams().containsKey("atguigu")) {
10
                    return chain.filter(exchange);
11
                }else {
12
                    exchange.getResponse().setStatusCode(HttpStatus.BAD_REQUEST);
13
                    return exchange.getResponse().setComplete();
14
                }
15
            }
16
        };
17
    }
18

19
@Override
20
public List<String> shortcutFieldOrder() {
21
    List<String> list = new ArrayList<String>();
22
    list.add("status");
23
    return list;
24
}

1
public MyGatewayFilterFactory() {
2
    super(MyGatewayFilterFactory.Config.class);
3
}

1
        <!--SpringCloud ailibaba sentinel-datasource-nacos -->
2
        <dependency>
3
            <groupId>com.alibaba.csp</groupId>
4
            <artifactId>sentinel-datasource-nacos</artifactId>
5
        </dependency>

1
spring:
2
  application:
3
    name: cloudalibaba-sentinel-service #8401微服务提供者后续将会被纳入阿里巴巴sentinel监管
4
  cloud:
5
    nacos:
6
      discovery:
7
        server-addr: localhost:8848         #Nacos服务注册中心地址
8
    sentinel:
9
      transport:
10
        dashboard: localhost:8080 #配置Sentinel dashboard控制台服务地址
11
                port: 8719 #默认8719端口，假如被占用会自动从8719开始依次+1扫描,直至找到未被占用的端口
12
            web-context-unify: false # controller层的方法对service层调用不认为是同一个根链路
13
            datasource:
14
         ds1:
15
           nacos:
16
             server-addr: localhost:8848
17
             dataId: ${spring.application.name}
18
             groupId: DEFAULT_GROUP
19
             data-type: json
20
             rule-type: flow # com.alibaba.cloud.sentinel.datasource.RuleType