SpringBoot升级后Hystrix没了以及3个替代方案分享

<!-- 我当时看到这个配置，心想这不简单吗 -->
<spring-boot.version>2.7.18</spring-boot.version>
<spring-cloud.version>2021.x</spring-cloud.version>

***************************
APPLICATION FAILED TO RUN
***************************

Description:

The Spring Cloud project contains incompatible modules: 
spring-cloud-starter-netflix-hystrix is not compatible with 
Spring Cloud 2021.x and later.

<!-- 移除 Hystrix 依赖 -->
<!-- 
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>
-->
<!-- 添加 Resilience4j 依赖 -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-circuitbreaker-resilience4j</artifactId>
</dependency>

# application.yml
resilience4j:
  circuitbreaker:
    instances:
      backendA:  # 服务名
        registerHealthIndicator: true
        slidingWindowSize: 10
        failureRateThreshold: 50
        waitDurationInOpenState: 10000
        permittedNumberOfCallsInHalfOpenState: 5
        automaticTransitionFromOpenToHalfOpenEnabled: true
        timeout:
          timeout: 3s
          cancelRunningFuture: false

@Service
public class MyService {
    
    @CircuitBreaker(name = "backendA", fallbackMethod = "fallback")
    public String callExternalService() {
        // 调用外部服务
        return "success";
    }
    
    // fallback 方法
    public String fallback(Exception e) {
        log.error("服务调用失败，执行 fallback: {}", e.getMessage());
        return "fallback result";
    }
}

// 原来的代码
@FeignClient(name = "soa-protocol-control", 
    fallbackFactory = ControlVehicleFeignServiceFallback.class)
public interface ControlVehicleFeignService {
    // ...
}

java.lang.IllegalStateException: 
FallbackFactory must return an instance of the FeignClient interface

// ❌ 原来的导入（Hystrix 时代）
import feign.hystrix.FallbackFactory;

// ✅ 现在的导入（Resilience4j 时代）
import org.springframework.cloud.openfeign.FallbackFactory;

@Slf4j
@Component
public class ControlVehicleFeignServiceFallbackFactory 
    implements FallbackFactory<ControlVehicleFeignService> {

    @Override
    public ControlVehicleFeignService create(Throwable cause) {
        log.error("---控车接口回退异常：{}", cause);
        
        return new ControlVehicleFeignService() {
            @Override
            public BaseResponseVo<Long> executeInstruct(UserControlVehicleDTO dto) {
                return BaseResponseVo.fail(PROTOCOL_CONTROL_ERROR);
            }

            @Override
            public BaseResponseVo<Long> selectCurrentRideUserIdByVin(String vin) {
                return BaseResponseVo.fail(PROTOCOL_CONTROL_ERROR);
            }
            
            // ... 其他方法都返回 fallback 结果
        };
    }
}

@FeignClient(
    name = "soa-protocol-control", 
    contextId = "userControlVehicle", 
    fallbackFactory = ControlVehicleFeignServiceFallbackFactory.class  // 注意是 fallbackFactory
)
public interface ControlVehicleFeignService {
    
    @PostMapping("/protocol-control/user/control/vehicle")
    BaseResponseVo<Long> executeInstruct(@RequestBody UserControlVehicleDTO dto);
    
    @GetMapping("/protocol-control/current/ride-user-id")
    BaseResponseVo<Long> selectCurrentRideUserIdByVin(@RequestParam String vin);
    
    // ... 其他接口
}

<!-- Spring Cloud LoadBalancer -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-loadbalancer</artifactId>
</dependency>

# application.yml
spring:
  cloud:
    loadbalancer:
      ribbon:
        enabled: false  # 禁用 Ribbon
      cache:
        ttl: 30000  # 缓存过期时间（毫秒）
        capacity: 256  # 缓存容量

@Configuration
public class LoadBalancerConfig {
    
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
    
    @Bean
    public ReactorLoadBalancer<ServiceInstance> randomLoadBalancer(
            LoadBalancerClientFactory clientFactory) {
        return new RandomLoadBalancer(
            clientFactory.getLazyProvider("service-name", ServiceInstanceListSupplier.class),
            "service-name"
        );
    }
}

@Service
public class MyService {
    
    @Autowired
    private RestTemplate restTemplate;
    
    public String callService(String data) {
        // 使用服务名调用，LoadBalancer 会自动做负载均衡
        String url = "http://service-name/api/" + data;
        return restTemplate.getForObject(url, String.class);
    }
}

// 啥都不用配，Hystrix 自动帮你搞定
@EnableHystrix
@EnableFeignClients
@SpringBootApplication
public class Application {
    // ...
}

// 启用 Resilience4j + OpenFeign + LoadBalancer
@EnableFeignClients
@SpringBootApplication
public class Application {
    // ...
}

// Resilience4j 配置
@Configuration
public class Resilience4jConfig {
    
    @Bean
    public CircuitBreakerConfig circuitBreakerConfig() {
        return CircuitBreakerConfig.custom()
            .failureRateThreshold(50)
            .waitDurationInOpenState(Duration.ofSeconds(10))
            .slidingWindowSize(10)
            .build();
    }
}

@FeignClient(
    name = "user-service",
    fallback = UserFeignClientFallback.class  // 直接返回实例
)
public interface UserFeignClient {
    @GetMapping("/user/{id}")
    User getUser(@PathVariable Long id);
}

@Component
public class UserFeignClientFallback implements UserFeignClient {
    @Override
    public User getUser(Long id) {
        return new User(0L, "default", "default@example.com");
    }
}

@FeignClient(
    name = "user-service",
    fallbackFactory = UserFeignClientFallbackFactory.class  // 工厂模式
)
public interface UserFeignClient {
    @GetMapping("/user/{id}")
    User getUser(@PathVariable Long id);
}

@Slf4j
@Component
public class UserFeignClientFallbackFactory 
    implements FallbackFactory<UserFeignClient> {
    
    @Override
    public UserFeignClient create(Throwable cause) {
        log.error("Feign 调用失败：{}", cause.getMessage());  // 可以记录日志
        
        return new UserFeignClient() {
            @Override
            public User getUser(Long id) {
                // 根据异常类型做不同处理
                if (cause instanceof ConnectException) {
                    return new User(0L, "network-error", "连接失败");
                } else {
                    return new User(0L, "unknown-error", "未知错误");
                }
            }
        };
    }
}

# 查看项目依赖树
mvn dependency:tree | Select-String "hystrix|resilience4j|ribbon|loadbalancer"

❌ Hystrix is not compatible with Spring Cloud 2021.x
❌ Ribbon is now in maintenance mode

// 手动触发异常，测试 fallback 是否生效
@Test
public void testFallback() {
    // 模拟服务不可用
    String result = feignClient.callService();
    assertEquals("fallback result", result);
}

# 这些是我实测好用的
resilience4j:
  circuitbreaker:
    instances:
      backendA:
        registerHealthIndicator: true
        slidingWindowSize: 10
        failureRateThreshold: 50
        waitDurationInOpenState: 10000
        permittedNumberOfCallsInHalfOpenState: 5
        automaticTransitionFromOpenToHalfOpenEnabled: true
  timelimiter:
    timeoutDuration: 3s

spring:
  cloud:
    loadbalancer:
      ribbon:
        enabled: false
      cache:
        ttl: 30000
        capacity: 256

# Resilience4j 的监控指标（要加到 Prometheus 里）
resilience4j.circuitbreaker.states
resilience4j.circuitbreaker.failure.rate
resilience4j.circuitbreaker.slow.call.rate