发布于 由admin

JAVA Feign 调用超时重试机制失效？Hystrix 与 Retryer 配置冲突解析

JAVA Feign 调用超时重试机制失效？Hystrix 与 Retryer 配置冲突解析

大家好，今天我们来聊聊一个在微服务架构中经常遇到的问题：Feign 调用超时重试机制失效。这个问题通常表现为，明明配置了 Feign 的重试机制，但实际调用过程中，一旦出现超时或其他异常，服务并没有按照预期进行重试，导致调用失败。其中，Hystrix 和 Retryer 之间的配置冲突是导致这个问题的一个常见原因。

Feign 基础与超时重试机制

首先，我们简单回顾一下 Feign 的基本概念和超时重试机制。Feign 是一个声明式的 Web 服务客户端，它使得编写 HTTP 客户端变得更简单。你只需要创建一个接口并使用注解来配置它。Feign 会自动生成 HTTP 请求，处理响应，并将其转换成 Java 对象。

Feign 的超时重试机制主要依赖以下几个组件：

  • Request.Options: 用于配置请求的连接超时时间和读取超时时间。
  • Retryer: 用于控制重试策略，包括重试次数、重试间隔等。
  • ErrorDecoder: 用于将 HTTP 响应转换为异常，以便 Retryer 判断是否需要重试。

配置示例:

@Configuration
public class FeignConfig {

    @Bean
    public Request.Options options() {
        return new Request.Options(5000, 10000); // 连接超时 5 秒，读取超时 10 秒
    }

    @Bean
    public Retryer retryer() {
        return new Retryer.Default(100, 1000, 3); // 初始间隔 100ms, 最大间隔 1s, 最大重试 3 次
    }

    @Bean
    public ErrorDecoder errorDecoder() {
        return new CustomErrorDecoder();
    }
}

// 自定义 ErrorDecoder
public class CustomErrorDecoder implements ErrorDecoder {
    @Override
    public Exception decode(String methodKey, Response response) {
        if (response.status() == 500) {
            return new RetryableException(
                    response.status(),
                    "Internal Server Error",
                    response.request().httpMethod(),
                    null,
                    null
            );
        }
        return new Default().decode(methodKey, response);
    }
}

// Feign 接口
@FeignClient(name = "example-service", configuration = FeignConfig.class)
public interface ExampleServiceClient {

    @GetMapping("/api/example")
    String getExample();
}

上面的代码展示了一个典型的 Feign 配置，包括连接超时、读取超时、重试策略和自定义的 ErrorDecoder。RetryableException 告知 Feign 这是一个可以重试的异常。

Hystrix 的介入与潜在冲突

Hystrix 是一个延迟和容错库，旨在隔离访问远程系统、服务和第三方库的风险，从而阻止级联故障并在复杂的分布式系统中实现弹性。在 Feign 中集成 Hystrix 通常是为了提供熔断、降级等功能。

当 Hystrix 启用后，Feign 的调用会被 HystrixCommand 包裹起来。这意味着，任何异常都会首先被 Hystrix 捕获，而不是直接传递给 Feign 的 Retryer。

启用 Hystrix 的配置示例:

feign:
  hystrix:
    enabled: true

或者通过配置类：

@Configuration
public class HystrixFeignConfig {

    @Bean
    public HystrixTargeter hystrixTargeter() {
        return new HystrixTargeter();
    }
}

问题所在：

当 Hystrix 启用时，默认情况下，Hystrix 会将所有异常都视为不可重试的，并直接执行 fallback 方法（如果配置了的话）或者抛出 HystrixRuntimeException。 这就导致了 Feign 原本配置的 Retryer 根本没有机会执行，从而使得重试机制失效。

具体原因可以归结为以下几点:

  1. Hystrix 优先处理异常: Hystrix 在 Feign 调用链中处于更上层的位置，优先捕获所有异常。
  2. 默认异常处理策略: Hystrix 默认将所有异常视为不可重试，除非明确配置。
  3. Retryer 未被触发: 由于 Hystrix 已经处理了异常，Feign 的 Retryer 根本没有机会被调用。

解决方案：配置 Hystrix 以允许重试

要解决这个问题，我们需要配置 Hystrix，使其能够识别哪些异常是可以重试的，并将这些异常传递给 Feign 的 Retryer 进行处理。

方法一：自定义 HystrixCommand 配置

我们可以通过自定义 HystrixCommand 的配置来实现。 具体步骤如下：

  1. 创建自定义的 HystrixCommand 实现:

    import com.netflix.hystrix.HystrixCommand;
import com.netflix.hystrix.HystrixCommandGroupKey;
import com.netflix.hystrix.HystrixCommandProperties;
import feign.FeignException;
import feign.RetryableException;

public class CustomHystrixCommand<T> extends HystrixCommand<T> {

    private final FeignCallable<T> feignCallable;

    public CustomHystrixCommand(String groupKey, FeignCallable<T> feignCallable) {
        super(Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey(groupKey))
                .andCommandPropertiesDefaults(HystrixCommandProperties.Setter()
                        .withExecutionTimeoutEnabled(true) // 启用超时
                        .withExecutionTimeoutInMilliseconds(5000) // 设置超时时间
                        .withCircuitBreakerEnabled(true) // 启用熔断器
                        .withCircuitBreakerRequestVolumeThreshold(20) // 设置请求数量阈值
                        .withCircuitBreakerErrorThresholdPercentage(50) // 设置错误百分比阈值
                        .withCircuitBreakerSleepWindowInMilliseconds(5000) // 设置熔断恢复时间
                ));
        this.feignCallable = feignCallable;
    }

    @Override
    protected T run() throws Exception {
        try {
            return feignCallable.call();
        } catch (FeignException e) {
            if (e instanceof RetryableException) {
                throw e; // 抛出 RetryableException，让 Feign 进行重试
            }
            throw e; // 抛出其他 FeignException，触发 fallback (如果配置了)
        } catch (Exception e) {
            throw e; // 抛出其他异常，触发 fallback (如果配置了)
        }
    }

    @Override
    protected T getFallback() {
        // 可选：实现 fallback 逻辑
        return null;
    }

    public interface FeignCallable<T> {
        T call() throws Exception;
    }
}

  2. 在 Feign 接口中使用自定义的 HystrixCommand:

    @FeignClient(name = "example-service", configuration = FeignConfig.class)
public interface ExampleServiceClient {

    @GetMapping("/api/example")
    String getExample();
}

@Component
public class ExampleServiceWrapper {

    @Autowired
    private ExampleServiceClient exampleServiceClient;

    public String getExampleWithRetry() {
        return new CustomHystrixCommand<String>("example-service", () -> exampleServiceClient.getExample()).execute();
    }
}

    这种方式的优点是灵活性高，可以精确控制哪些异常可以重试。缺点是需要手动包装 Feign 调用，代码侵入性较强。

方法二：自定义 HystrixConcurrencyStrategy

这种方法通过自定义并发策略，拦截 Feign 的调用，并判断异常类型，决定是否进行重试。

  1. 创建自定义的 HystrixConcurrencyStrategy:

    import com.netflix.hystrix.HystrixThreadPoolKey;
import com.netflix.hystrix.strategy.concurrency.HystrixConcurrencyStrategy;
import com.netflix.hystrix.strategy.properties.HystrixProperty;
import feign.FeignException;
import feign.RetryableException;
import org.springframework.stereotype.Component;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

@Component
public class CustomHystrixConcurrencyStrategy extends HystrixConcurrencyStrategy {

    @Override
    public <T> Callable<T> wrapCallable(Callable<T> callable) {
        return new HystrixCallableWrapper<>(callable);
    }

    private static class HystrixCallableWrapper<T> implements Callable<T> {
        private final Callable<T> delegate;

        public HystrixCallableWrapper(Callable<T> delegate) {
            this.delegate = delegate;
        }

        @Override
        public T call() throws Exception {
            try {
                return delegate.call();
            } catch (Exception e) {
                if (e instanceof FeignException && e instanceof RetryableException) {
                    throw e; // 抛出 RetryableException，让 Feign 进行重试
                }
                throw e; // 抛出其他异常，触发 fallback (如果配置了)
            }
        }
    }

    @Override
    public ThreadPoolExecutor getThreadPool(HystrixThreadPoolKey threadPoolKey, HystrixProperty<Integer> corePoolSize, HystrixProperty<Integer> maximumPoolSize, HystrixProperty<Integer> keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
        return super.getThreadPool(threadPoolKey, corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
    }

}

  2. 注册自定义的 HystrixConcurrencyStrategy:

    import com.netflix.hystrix.strategy.HystrixPlugins;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;

import javax.annotation.PostConstruct;

@Configuration
public class HystrixConfiguration {

    @Autowired
    private CustomHystrixConcurrencyStrategy customHystrixConcurrencyStrategy;

    @PostConstruct
    public void init() {
        HystrixPlugins.getInstance().registerConcurrencyStrategy(customHystrixConcurrencyStrategy);
    }
}

    这种方式的优点是对代码的侵入性较低，只需要实现一个并发策略并注册即可。缺点是相对复杂，需要理解 Hystrix 的并发策略。

方法三：自定义 FallbackFactory 并手动抛出 RetryableException

这种方法利用 Feign 的 FallbackFactory 机制，在 fallback 方法中判断异常类型，如果是可以重试的异常，则手动抛出 RetryableException，从而触发 Feign 的重试机制。

  1. 创建自定义的 FallbackFactory:

    import feign.FeignException;
import feign.hystrix.FallbackFactory;
import org.springframework.stereotype.Component;
import feign.RetryableException;

@Component
public class ExampleServiceFallbackFactory implements FallbackFactory<ExampleServiceClient> {

    @Override
    public ExampleServiceClient create(Throwable cause) {
        return () -> {
            if (cause instanceof FeignException) {
                FeignException feignException = (FeignException) cause;
                if (feignException instanceof RetryableException) {
                    throw (RetryableException) feignException;
                }
               // 或者
               //throw new RetryableException(feignException.status(), feignException.getMessage(), feignException.request().httpMethod(), null, null);
            }
            // 处理其他异常，例如返回默认值或抛出自定义异常
            return "fallback value";
        };
    }
}

  2. 在 Feign 接口中使用 FallbackFactory:

    @FeignClient(name = "example-service", fallbackFactory = ExampleServiceFallbackFactory.class, configuration = FeignConfig.class)
public interface ExampleServiceClient {

    @GetMapping("/api/example")
    String getExample();
}

    这种方式的优点是代码相对简洁，易于理解。缺点是需要在 fallback 方法中处理异常，可能会增加代码的复杂度。

总结对比:

方法 优点 缺点 适用场景
自定义 HystrixCommand 灵活性高，可以精确控制哪些异常可以重试 代码侵入性较强，需要手动包装 Feign 调用 需要对每个 Feign 调用进行精确控制的场景
自定义 HystrixConcurrencyStrategy 对代码的侵入性较低，只需要实现一个并发策略并注册即可 相对复杂，需要理解 Hystrix 的并发策略 需要全局控制 Feign 重试策略的场景
自定义 FallbackFactory 代码相对简洁，易于理解 需要在 fallback 方法中处理异常，可能会增加代码的复杂度 只需要简单处理 Feign 重试，并且可以接受在 fallback 方法中处理异常的场景

其他可能导致重试失效的原因

除了 Hystrix 的影响外，还有一些其他因素可能导致 Feign 的重试机制失效：

  1. Retryer 配置错误: 检查 Retryer 的配置是否正确，例如最大重试次数是否为 0，重试间隔是否设置过大等。
  2. ErrorDecoder 未正确处理异常: 确保 ErrorDecoder 能够正确地将需要重试的异常转换为 RetryableException。
  3. 网络问题: 检查网络连接是否正常，如果网络不稳定，可能会导致 Feign 无法进行重试。
  4. 服务提供者的问题: 如果服务提供者本身存在问题，例如服务器宕机或数据库连接失败，可能会导致 Feign 无法进行重试。
  5. 版本兼容性问题: 确保 Feign、Hystrix 和其他相关依赖的版本兼容。

最佳实践

  1. 明确重试策略: 在设计微服务时，需要明确定义重试策略，包括哪些异常可以重试，重试次数和间隔等。
  2. 选择合适的解决方案: 根据实际情况选择合适的解决方案，例如自定义 HystrixCommand、自定义 HystrixConcurrencyStrategy 或自定义 FallbackFactory。
  3. 监控和告警: 建立完善的监控和告警机制，及时发现和解决重试失效的问题。
  4. 幂等性设计: 确保服务提供者的接口是幂等的，即使多次调用也不会产生副作用。

异常处理与重试：关注点

  • 可重试异常的识别: 准确识别哪些异常是可以通过重试解决的，例如网络超时、服务暂时不可用等。避免将所有异常都视为可重试，否则可能会导致无限重试，浪费资源。
  • 重试次数和间隔的设置: 合理设置重试次数和间隔，避免过度重试导致服务雪崩。
  • Fallback 机制: 在重试失败后，提供 fallback 机制，例如返回默认值、调用备用服务等，以保证服务的可用性。
  • 日志记录: 详细记录重试过程，包括重试次数、异常信息等，以便进行问题排查。

总结

Feign 的超时重试机制是一个非常有用的功能，可以提高微服务的可用性。但是，在集成 Hystrix 时，需要注意配置冲突的问题。通过自定义 Hystrix 的配置，我们可以让 Feign 的重试机制正常工作。同时，还需要注意其他可能导致重试失效的原因，并采取相应的措施。希望今天的讲解能够帮助大家更好地理解和使用 Feign 的超时重试机制。

理解 Feign 重试机制的本质

希望通过以上内容，能帮助大家理解 Feign 集成 Hystrix 时，重试机制失效的原因以及对应的解决方案。 记住，在复杂的分布式系统中，容错和弹性是至关重要的，合理地配置和使用 Feign 和 Hystrix，可以帮助我们构建更健壮的微服务架构。

选择适合场景的重试方案

总而言之，解决 Feign 调用超时重试机制失效的问题，关键在于理解 Hystrix 和 Retryer 的交互方式，并选择合适的配置方案，确保可重试异常能够被正确地传递给 Feign 的 Retryer 进行处理。同时，结合实际业务场景，合理设置重试策略，才能真正提高微服务的可用性和容错能力。

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注