Spring Cloud Hystrix：服务容错与熔断

1. 理解服务容错与熔断

1.1 服务容错的概念和重要性

在分布式系统中，由于各种原因（例如网络延迟、服务故障等），服务之间的通信可能会出现故障或者延迟。为了提高系统的可用性和稳定性，需要实现服务容错机制，即在发生故障或延迟时，系统能够以一种可控的方式继续提供服务，而不会导致整个系统的崩溃。

服务容错机制的重要性体现在以下几个方面：

• 提高系统的可用性：及时处理服务故障，确保系统能够持续提供服务。
• 提高系统的稳定性：避免因单个服务的故障而导致整个系统的崩溃。
• 提升用户体验：在发生故障时，通过合理的容错策略，降低用户受到的影响，提升用户体验。

1.2 熔断机制的作用和优势

熔断机制是服务容错机制的重要组成部分，其作用是在服务发生故障或延迟时，暂时中断对该服务的访问，避免系统因大量请求导致的资源耗尽和性能下降。熔断器会监控服务的状态，当服务发生故障或延迟时，会自动打开熔断器，阻止对服务的访问，并采取相应的措施，例如返回一个默认的响应结果或执行备用方案。

熔断机制的优势主要体现在以下几个方面：

• 避免雪崩效应：通过熔断机制，可以防止由于单个服务的故障导致的大量请求涌入，从而避免雪崩效应。
• 快速失败：当服务发生故障时，熔断机制能够快速失败，而不是等待超时，提高了系统的响应速度。
• 自我修复：熔断器会定期检测服务的状态，当服务恢复正常时，会自动关闭熔断器，恢复对服务的访问。

1.3 Spring Cloud Hystrix 的介绍和定位

Spring Cloud Hystrix 是 Netflix 开源的一款服务容错框架，用于实现熔断、降级、限流等功能，为微服务架构提供了强大的容错能力。作为 Spring Cloud 生态的一部分，Hystrix 提供了与 Spring Cloud 无缝集成的能力，能够与其他 Spring Cloud 组件（如 Eureka、Ribbon 等）配合使用，为微服务架构提供了全方位的容错解决方案。

Hystrix 的定位是在服务调用层面实现容错和熔断，通过为每个服务调用包装一个 Hystrix 命令，监控其执行情况，并在需要时执行降级或熔断操作，保障系统的稳定性和可用性。

2. Hystrix 的基础知识

2.1 Hystrix 的工作原理概述

Hystrix 的工作原理可以简单概括为：为每个服务调用创建一个 Hystrix 命令，监控其执行情况，并在需要时执行降级或熔断操作。具体而言，Hystrix 会在服务调用过程中记录请求的成功与失败情况，当失败率超过一定阈值或达到一定数量时，自动打开熔断器，阻止对服务的访问，并执行备用方案或返回默认结果。同时，Hystrix 会定期检测服务的状态，当服务恢复正常时，会自动关闭熔断器，恢复对服务的访问。

2.2 Hystrix 的核心组件和架构

Hystrix 的核心组件包括：

• Hystrix 命令（HystrixCommand）：用于包装一个服务调用，并监控其执行情况。
• Hystrix 熔断器（HystrixCircuitBreaker）：用于监控服务调用的成功与失败情况，并在需要时打开或关闭熔断器。
• Hystrix 线程池（HystrixThreadPool）：用于控制服务调用的并发度和资源分配。
• Hystrix 监控（Hystrix Dashboard、Hystrix Turbine）：用于监控服务调用的熔断器状态和性能指标。

Hystrix 的架构采用了命令模式，通过为每个服务调用创建一个 Hystrix 命令来实现容错和熔断。每个 Hystrix 命令都会被包装在一个线程池中，用于控制服务调用的并发度和资源分配。同时，Hystrix 还提供了监控和度量功能，可以实时监控服务调用的熔断器状态和性能指标，以便及时发现和处理问题。

2.3 Hystrix 命令模式的运行流程

Hystrix 的命令模式是其核心设计之一，它负责封装一个服务调用，并在执行过程中监控其状态，根据需要执行熔断、降级等操作。下面是 Hystrix 命令模式的运行流程：

1. 定义命令类： 首先，我们需要定义一个继承自 HystrixCommand 的命令类，通常包含了对服务调用的封装以及异常处理逻辑。这个命令类将被用于执行具体的服务调用。

2. 创建命令对象： 在需要进行服务调用的地方，我们创建命令对象并设置相应的参数。这个命令对象将负责执行服务调用，并在执行过程中监控其状态。

3. 执行服务调用： 通过调用命令对象的 execute() 方法来执行服务调用。在执行过程中，Hystrix 会监控命令的执行情况，包括成功、失败、超时等状态。

4. 监控状态变化： Hystrix 会持续监控命令的执行情况，并根据需要执行熔断、降级等操作。如果命令执行过程中出现故障或延迟，Hystrix 将采取相应的措施，保障系统的稳定性和可用性。

5. 处理降级逻辑： 在命令执行失败或超时时，Hystrix 将执行预先定义的降级逻辑，返回一个默认的响应结果或执行备用方案，以提高系统的容错能力。

总的来说，Hystrix 命令模式的运行流程是一个监控与处理的过程，通过对服务调用的封装和状态监控，实现了对服务调用的容错和熔断。

3. 实现服务容错与熔断

3.1 配置 Hystrix 断路器

在使用 Hystrix 进行服务容错和熔断时，需要对相关组件进行配置，以满足特定的业务需求。其中，最重要的组件之一是断路器（Circuit Breaker），它负责监控服务调用的状态，并在需要时打开或关闭熔断器。

在 Spring Cloud 中，可以通过在配置文件中添加相应的配置来配置 Hystrix 断路器。例如，可以配置断路器的阈值、超时时间、熔断器的打开时间窗口等参数，以满足特定的业务需求。

hystrix:
  command:
    default:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 5000 # 设置命令执行的超时时间
      circuitBreaker:
        requestVolumeThreshold: 20 # 触发断路器的最小请求数量
        errorThresholdPercentage: 50 # 断路器打开的错误百分比阈值
        sleepWindowInMilliseconds: 5000 # 断路器打开后的休眠时间窗口

在这个示例中，我们配置了 Hystrix 断路器的一些基本参数，包括命令执行的超时时间、触发断路器的最小请求数量、断路器打开的错误百分比阈值和断路器打开后的休眠时间窗口等。

3.2 定义 Hystrix 命令

在使用 Hystrix 进行服务容错和熔断时，需要定义一个继承自 HystrixCommand 的命令类，并重写其 run 方法，实现具体的服务调用逻辑。可以在 run 方法中调用远程服务、执行数据库查询等操作，并在需要时处理异常情况。

public class MyHystrixCommand extends HystrixCommand<String> {

    private final String name;

    public MyHystrixCommand(String name) {
        super(HystrixCommandGroupKey.Factory.asKey("ExampleGroup"));
        this.name = name;
    }

    @Override
    protected String run() throws Exception {
        // 执行远程服务调用或其他业务逻辑
        return "Hello, " + name + "!";
    }
}

在这个示例中，我们定义了一个名为 MyHystrixCommand 的 Hystrix 命令类，其中重写了 run 方法，实现了一个简单的服务调用逻辑，返回一个包含问候信息的字符串。

3.3 实现基本的熔断逻辑

在 Hystrix 中，熔断器（Circuit Breaker）是实现服务熔断的关键组件，它负责监控服务调用的状态，并在需要时打开或关闭熔断器。可以通过配置断路器的参数来控制断路器的行为，以满足特定的业务需求。

public class MyHystrixCommand extends HystrixCommand<String> {

    // 省略其他代码...

    @Override
    protected String run() throws Exception {
        // 执行远程服务调用或其他业务逻辑
        return "Hello, " + name + "!";
    }

    @Override
    protected String getFallback() {
        // 执行降级逻辑
        return "Fallback: Hello, Guest!";
    }
}

在这个示例中，我们重写了 getFallback 方法，在服务调用失败或超时时执行降级逻辑，返回一个默认的问候信息字符串。这样，当服务调用失败时，客户端就不会收到错误的响应，而是收到一个友好的提示信息，提高了用户体验。

综上所述，我们通过配置 Hystrix 断路器、定义 Hystrix 命令和实现基本的熔断逻辑，实现了服务容错和熔断的基本功能，提高了系统的稳定性和可用性。接下来，我们将介绍如何监控断路器状态和性能指标，以便及时发现和处理问题。

4. 断路器状态与监控

在使用 Hystrix 进行服务容错和熔断时，了解断路器的状态和监控是非常重要的，它能够帮助我们及时发现和处理问题，提高系统的稳定性和可用性。本部分将介绍断路器的状态以及如何进行监控。

4.1 断路器的打开、关闭和半开状态

Hystrix 断路器有三种状态：打开（Open）、关闭（Closed）和半开（Half-Open）。

• 打开状态（Open）： 当服务调用失败率超过一定阈值或达到一定数量时，断路器将进入打开状态，停止对服务的访问，所有请求都会被立即拒绝，并执行降级逻辑，直至断路器的休眠时间窗口过期。

• 关闭状态（Closed）： 在正常情况下，断路器处于关闭状态，允许请求通过，并监控服务调用的状态。如果服务调用成功，断路器保持关闭状态；如果服务调用失败，断路器将逐渐增加失败计数器，并在一定条件下打开断路器。

• 半开状态（Half-Open）： 当断路器的休眠时间窗口过期后，断路器将进入半开状态，允许部分请求通过，并尝试执行服务调用。如果服务调用成功，则断路器将重新关闭；如果服务调用失败，则断路器将重新打开，回到打开状态。

4.2 使用 Hystrix Dashboard 监控断路器状态

Hystrix Dashboard 是 Hystrix 的监控工具之一，提供了实时监控断路器状态和性能指标的功能。通过 Hystrix Dashboard，我们可以直观地查看每个断路器的状态、失败率、请求量等指标，并及时发现和处理问题。

在 Spring Cloud 中，可以通过添加依赖并配置路由来集成 Hystrix Dashboard。具体操作如下：

1. 添加依赖：

<dependency>
    <groupId>org.springframework.cloudgroupId>
    <artifactId>spring-cloud-starter-netflix-hystrix-dashboardartifactId>
dependency>

2. 配置路由：

import org.springframework.cloud.netflix.hystrix.dashboard.EnableHystrixDashboard;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableHystrixDashboard
public class HystrixDashboardConfig {
}

通过访问 Hystrix Dashboard 的地址，可以查看实时的断路器状态和性能指标，并根据需要进行调整和优化。

4.3 Hystrix Turbine 的集群监控

除了单个服务的监控外，有时我们还需要对整个集群的断路器状态进行监控，以便全面了解系统的健康状况。Hystrix Turbine 是针对 Hystrix Dashboard 的扩展，提供了集群监控的功能，能够将多个服务的断路器状态汇总显示在一个页面上。

使用 Hystrix Turbine 监控集群的步骤如下：

1. 添加依赖：

<dependency>
    <groupId>org.springframework.cloudgroupId>
    <artifactId>spring-cloud-starter-netflix-turbineartifactId>
dependency>

2. 配置路由：

import org.springframework.cloud.netflix.turbine.EnableTurbine;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableTurbine
public class TurbineConfig {
}

3. 配置集群信息：

turbine:
  aggregator:
    cluster-config: default
  app-config: user-service, order-service # 需要监控的服务名称列表

通过以上步骤，可以使用 Hystrix Turbine 对集群中多个服务的断路器状态进行监控，并及时发现和处理问题，提高系统的稳定性和可用性。

5. 降级策略与回退机制

在微服务架构中，服务调用可能会面临各种异常情况，如网络故障、服务超时等。为了提高系统的可用性和稳定性，需要实现降级策略和回退机制，以应对这些异常情况。本部分将介绍如何实现降级策略和回退机制，以确保系统在异常情况下能够正常运行。

5.1 实现服务降级逻辑

服务降级是指在服务调用出现异常或超时时，返回一个默认的响应结果，而不是抛出异常或返回错误信息。通过实现服务降级逻辑，可以保障系统在异常情况下仍能够正常运行，提高系统的可用性。

public class MyHystrixCommand extends HystrixCommand<String> {

    // 省略其他代码...

    @Override
    protected String getFallback() {
        // 执行降级逻辑，返回默认的响应结果
        return "Fallback: Service is unavailable!";
    }
}

在这个示例中，我们重写了 getFallback 方法，在服务调用失败或超时时执行降级逻辑，返回一个默认的响应结果，以提高系统的容错能力。

5.2 配置 Hystrix 的降级策略

Hystrix 允许我们通过配置文件来定义降级策略，以满足特定的业务需求。可以通过配置文件中的参数来设置降级逻辑的执行条件和返回结果，以及控制降级策略的行为。

hystrix:
  command:
    default:
      fallback:
        enabled: true # 是否启用降级策略

在这个示例中，我们通过配置文件设置了降级策略的一些基本参数，包括是否启用降级策略等。

5.3 使用 Fallback 机制进行回退处理

除了在 Hystrix 命令中定义降级逻辑外，我们还可以使用 Spring Cloud 提供的 Fallback 机制进行回退处理。通过在 Feign 接口中定义一个 Fallback 类，可以在服务调用失败时执行回退逻辑，返回一个默认的响应结果。

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

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

@Component
public class ExampleServiceFallback implements ExampleServiceClient {

    @Override
    public String getExample() {
        return "Fallback: Service is unavailable!";
    }
}

在这个示例中，我们在 Feign 接口中指定了一个 Fallback 类 ExampleServiceFallback，当服务调用失败时，会执行该类中的方法，返回一个默认的响应结果。

通过实现降级策略和回退机制，我们可以保障系统在异常情况下仍能够正常运行，提高系统的可用性和稳定性。

6. 超时与线程池配置

在微服务架构中，服务调用可能会面临网络延迟、资源瓶颈等问题，导致服务调用时间过长。为了避免服务调用的阻塞和资源浪费，需要对超时时间和线程池进行合理的配置。本部分将介绍如何配置 Hystrix 命令的超时时间和线程池大小，以提高系统的性能和稳定性。

6.1 配置 Hystrix 命令的超时时间

Hystrix 允许我们通过配置文件来设置命令的超时时间，以控制服务调用的最大执行时间。当服务调用超过指定的超时时间时，Hystrix 将自动触发熔断机制，执行降级逻辑。

hystrix:
  command:
    default:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 5000 # 设置命令的超时时间为 5000 毫秒

在这个示例中，我们通过配置文件设置了命令的超时时间为 5000 毫秒，即 5 秒钟。这样，当服务调用超过 5 秒钟时，Hystrix 将自动触发熔断机制，执行降级逻辑。

6.2 定义 Hystrix 线程池的大小

除了配置命令的超时时间外，我们还可以配置 Hystrix 线程池的大小，以控制服务调用的并发度和资源分配。通过合理设置线程池的大小，可以避免线程池资源的耗尽和性能下降。

hystrix:
  threadpool:
    default:
      coreSize: 10 # 设置线程池的核心线程数为 10

在这个示例中，我们通过配置文件设置了线程池的核心线程数为 10，即最大并发执行的命令数为 10。这样，当服务调用达到一定并发量时，Hystrix 将自动启动新的线程来处理请求，保障系统的性能和稳定性。

通过合理配置超时时间和线程池大小，我们可以提高系统对服务调用的响应速度和处理能力，保障系统的性能和稳定性。

7. 请求合并与缓存

在微服务架构中，多个服务之间可能存在大量的交互请求，如果每个请求都单独发送到服务端，可能会导致网络开销过大，影响系统性能。为了提高系统的性能和降低网络开销，可以使用请求合并和缓存机制。本部分将介绍如何使用 Hystrix 实现请求合并和缓存，以提高系统的性能和可扩展性。

7.1 实现请求合并的需求

请求合并是指将多个相同类型的请求合并成一个批量请求发送到服务端，减少网络开销和提高系统的性能。通过合并请求，可以减少服务端的负载和资源消耗，提高系统的吞吐量和并发能力。

7.2 使用 HystrixCollapser 进行请求合并

Hystrix 提供了一个名为 HystrixCollapser 的组件，用于实现请求合并功能。通过使用 HystrixCollapser，我们可以将多个相同类型的请求合并成一个批量请求，并在一定时间内发送到服务端，从而减少网络开销和提高系统的性能。

public class MyHystrixCollapser extends HystrixCollapser<List<String>, String, Long> {

    private final Long id;

    public MyHystrixCollapser(Long id) {
        this.id = id;
    }

    @Override
    public Long getRequestArgument() {
        return id;
    }

    @Override
    protected HystrixCommand<List<String>> createCommand(Collection<CollapsedRequest<String, Long>> collapsedRequests) {
        return new BatchCommand(collapsedRequests);
    }

    @Override
    protected void mapResponseToRequests(List<String> batchResponse, Collection<CollapsedRequest<String, Long>> collapsedRequests) {
        int count = 0;
        for (CollapsedRequest<String, Long> request : collapsedRequests) {
            request.setResponse(batchResponse.get(count++));
        }
    }
}

在这个示例中，我们定义了一个继承自 HystrixCollapser 的请求合并器类 MyHystrixCollapser，重写了其中的 getRequestArgument、createCommand 和 mapResponseToRequests 方法，实现了请求的合并和拆分逻辑。

7.3 Hystrix 缓存的使用与配置

除了请求合并外，Hystrix 还提供了缓存功能，用于缓存命令的执行结果，减少对服务的重复调用，提高系统的性能和可扩展性。通过合理配置缓存参数，可以提高系统的性能和稳定性。

hystrix:
  command:
    default:
      requestCache:
        enabled: true # 启用缓存功能

在这个示例中，我们通过配置文件设置了缓存功能的一些基本参数，包括是否启用缓存功能等。

通过实现请求合并和缓存功能，我们可以减少网络开销，提高系统的性能和可扩展性，保障系统的稳定性和可用性。

8. 高级功能与自定义扩展

在使用 Hystrix 进行服务容错和熔断时，除了基本功能外，还可以使用一些高级功能和自定义扩展，以满足特定的业务需求。本部分将介绍如何使用 Hystrix 注解简化配置、自定义 Hystrix 命令和熔断策略，以及实现自定义的 Hystrix 插件。

8.1 使用 Hystrix 注解简化配置

Hystrix 提供了一些注解，用于简化命令和熔断器的配置，如 @HystrixCommand、@HystrixCollapser 等。通过使用这些注解，我们可以在方法上添加注解，而无需在配置文件中进行繁琐的配置，从而简化了代码的编写和维护。

@HystrixCommand(fallbackMethod = "fallbackMethod")
public String getExample() {
    // 执行远程服务调用或其他业务逻辑
}

public String fallbackMethod() {
    // 执行降级逻辑
}

在这个示例中，我们在方法上使用 @HystrixCommand 注解来指定降级方法，当服务调用失败时，会执行降级方法返回一个默认的响应结果。

8.2 自定义 Hystrix 命令和熔断策略

除了使用注解外，我们还可以自定义 Hystrix 命令和熔断策略，以满足特定的业务需求。通过继承 HystrixCommand 和 HystrixObservableCommand 类，我们可以实现自定义的命令逻辑，包括命令的执行、降级逻辑等。

public class MyHystrixCommand extends HystrixCommand<String> {

    // 省略其他代码...

    @Override
    protected String run() throws Exception {
        // 执行自定义的命令逻辑
    }

    @Override
    protected String getFallback() {
        // 执行自定义的降级逻辑
    }
}

在这个示例中，我们定义了一个继承自 HystrixCommand 的自定义命令类 MyHystrixCommand，重写了其中的 run 和 getFallback 方法，实现了自定义的命令逻辑和降级逻辑。

8.3 实现自定义的 Hystrix 插件

除了自定义命令外，我们还可以实现自定义的 Hystrix 插件，以满足特定的业务需求。通过实现 HystrixMetricsPublisher、HystrixCommandExecutionHook 等接口，我们可以扩展 Hystrix 的功能，如自定义指标发布、命令执行钩子等。

public class MyHystrixMetricsPublisher extends HystrixMetricsPublisher {

    // 实现自定义的指标发布逻辑
}

public class MyHystrixCommandExecutionHook extends HystrixCommandExecutionHook {

    // 实现自定义的命令执行钩子逻辑
}

在这个示例中，我们实现了自定义的 HystrixMetricsPublisher 和 HystrixCommandExecutionHook 类，分别用于自定义指标发布和命令执行钩子逻辑。

通过使用高级功能和自定义扩展，我们可以满足特定的业务需求，提高系统的灵活性和可扩展性，保障系统的性能和稳定性。

9. 请求重试与超时

在微服务架构中，由于网络不稳定或服务端异常等原因，服务调用可能会失败或超时。为了提高系统的可用性和稳定性，可以实现请求重试和超时机制，确保服务调用的成功和及时响应。本部分将介绍如何使用 Hystrix 实现请求重试和超时，以提高系统的健壮性和可靠性。

9.1 请求重试机制和配置

Hystrix 允许我们通过配置文件来定义请求重试机制，以应对服务调用的失败和超时。可以通过配置文件中的参数来设置重试次数、重试间隔等，以满足特定的业务需求。

hystrix:
  command:
    default:
      execution:
        isolation:
          strategy: SEMAPHORE
      circuitBreaker:
        requestVolumeThreshold: 20
        sleepWindowInMilliseconds: 5000
      metrics:
        rollingStats:
          timeInMilliseconds: 10000

在这个示例中，我们通过配置文件设置了一些基本的重试参数，包括执行策略、断路器阈值、休眠窗口等。

9.2 Feign 客户端的超时设置

除了在 Hystrix 中配置请求重试外，我们还可以在 Feign 客户端中配置超时时间，以控制服务调用的最大执行时间。通过合理设置超时时间，可以避免服务调用的阻塞和资源浪费，提高系统的可用性和性能。

feign:
  client:
    config:
      default:
        connectTimeout: 5000 # 设置连接超时时间为 5000 毫秒
        readTimeout: 5000 # 设置读取超时时间为 5000 毫秒

在这个示例中，我们通过配置文件设置了 Feign 客户端的连接超时时间和读取超时时间，分别为 5000 毫秒，即 5 秒钟。

9.3 使用 Retryer 实现请求重试

除了在 Hystrix 和 Feign 中配置请求重试外，我们还可以使用 Retryer 接口来实现请求重试功能。通过实现 Retryer 接口，我们可以自定义重试策略，包括重试次数、重试间隔等，以满足特定的业务需求。

public class MyRetryer implements Retryer {

    @Override
    public void continueOrPropagate(RetryableException e) {
        // 实现重试逻辑
    }

    @Override
    public Retryer clone() {
        return new MyRetryer();
    }
}

在这个示例中，我们实现了自定义的 Retryer 类 MyRetryer，重写了其中的 continueOrPropagate 和 clone 方法，实现了自定义的重试逻辑。

通过实现请求重试和超时机制，我们可以提高系统的可用性和稳定性，保障服务调用的成功和及时响应。

10. 实践

在前面的部分中，我们详细介绍了 Spring Cloud Feign 的各种特性和用法，以及与 Hystrix 相关的服务容错和熔断机制。现在，让我们通过一个实际的示例来演示如何使用 Feign 和 Hystrix 来实现服务调用和容错处理。

10.1 使用 Feign 实现服务调用

首先，我们需要定义一个 Feign 接口，用于声明服务调用的方法。通过在接口上添加 @FeignClient 注解，我们可以指定服务的名称和服务调用的路径。

@FeignClient(name = "example-service")
public interface ExampleServiceClient {

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

在这个示例中，我们定义了一个名为 ExampleServiceClient 的 Feign 接口，声明了一个名为 getExample 的方法，用于调用示例服务的 /example 路径。

10.2 定义 Feign 接口并实现服务调用逻辑

接下来，我们需要实现 Feign 接口，并注入到 Spring 容器中，以便在其他组件中使用。通过调用 Feign 接口中定义的方法，我们可以实现对服务的调用。

@Service
public class ExampleService {

    private final ExampleServiceClient client;

    @Autowired
    public ExampleService(ExampleServiceClient client) {
        this.client = client;
    }

    public String callExampleService() {
        return client.getExample();
    }
}

在这个示例中，我们定义了一个名为 ExampleService 的服务类，通过构造函数注入了 ExampleServiceClient，并在方法中调用了 ExampleServiceClient 中定义的方法。

10.3 实现服务降级和熔断策略

最后，我们需要实现服务降级和熔断策略，以应对服务调用失败或超时的情况。通过在 Feign 接口的方法上添加 @HystrixCommand 注解，并指定降级方法，我们可以实现服务调用失败时执行降级逻辑。

@Service
public class ExampleService {

    // 省略其他代码...

    @HystrixCommand(fallbackMethod = "fallbackMethod")
    public String callExampleService() {
        return client.getExample();
    }

    public String fallbackMethod() {
        return "Fallback: Service is unavailable!";
    }
}

在这个示例中，我们在 callExampleService 方法上添加了 @HystrixCommand 注解，并指定了降级方法 fallbackMethod，当服务调用失败时，会执行降级逻辑返回一个默认的响应结果。

通过这个实例，我们演示了如何使用 Feign 和 Hystrix 实现服务调用和容错处理，以提高系统的可用性和稳定性。在实际应用中，可以根据具体的业务需求进行相应的调整和扩展，以满足系统的需求。