fegin

优雅的处理服务降级：Feign Fallback的实现原理与实现方式

更新：2023-05-22 06:40

作为分布式系统中的一个重要概念，服务降级是指当一个服务出现故障或者延迟异常、产生瓶颈的时候，如何能够优雅的处理。在微服务架构中，Feign作为一种HTTP客户端框架，内部集成了Ribbon实现了负载均衡，为服务之间的调用提供了便利。为了保证服务的高可用性，我们需要在Feign中实现Fallback机制，从而达到——当服务出现问题的时候，能够自动切换到备用资源出来进行相应。

一、为什么需要服务降级？

服务降级是分布式系统中的一种核心模式，其目的是保证分布式系统中某个功能的可用性，使整个系统更加弹性化，防止因为某一节点出现故障而导致整个系统的瘫痪。

比如说，在微服务架构中，一些服务依赖和调用关系十分复杂，这些服务之间可能会形成链式调用，也可能会存在依赖关系的瓶颈。当某个服务被调用方出现故障或者网络延迟时，若没有服务降级的优化，后续调用请求会在这个故障节点处长时间的阻塞，这样会导致整个系统出现雪崩效应，甚至导致整个系统的崩溃。

因此，使用服务降级的方式，能够在出现故障时，自动切换到备用资源上，达到保证服务的可用性和系统的平稳运行。

二、怎么实现服务降级？

我们可以通过熔断、限流、异步处理、缓存和Fallback机制等方式来实现服务降级。

本篇文章将主要介绍如何使用Feign Fallback机制来实现服务降级。

三、Feign Fallback的实现原理

Feign作为一个HTTP客户端框架，提供了一种服务之间的调用方式。在Feign的调用过程中，对于服务降级的处理，Feign会提供一个Fallback机制，使服务出现问题时，能够自动切换到备用资源上进行相应。

使用Feign Fallback机制，步骤如下：

1. 自定义Fallback类并实现对应的Feign客户端接口
2. 在请求的Feign客户端接口上添加@FeignClient注解，指定对应的fallback类

在实际开发中，我们通过定义一个继承了Feign的客户端接口的Fallback类，在Fallback中对服务进行降级处理。

@FeignClient(name = "service-provider" , fallback = FallbackClientImpl.class)
public interface ProviderClient {

     @GetMapping("/hello")
     String hello();
} 

@Service
public class FallbackClientImpl implements ProviderClient {

   @Override
   public String hello() {
      return "Service is unavailable temporarily!";
   }
}

在上述代码中，我们通过创建一个FallbackClientImpl类来实现ProviderClient接口，并在@FeignClient注解中指定对应的fallback为FallbackClientImpl类。

当我们在调用ProviderClient的hello()方法时，如果服务提供方出现故障或延迟，就会自动切换到FallbackClientImpl类的相应方法上进行响应。

四、Feign Fallback的实现方式

除了以上的方法，使用Feign的Fallback机制还有一种更加灵活的实现方式，通过实现FallbackFactory接口来达到服务降级的目的。

实现步骤如下：

1. 定义一个FallbackFactory类，并实现对应的Fallback
2. 在请求的Feign客户端接口上添加@FeignClient注解，同时指定FallbackFactory类

在实际开发中，我们统一通过定义一个FallbackFactory类来实现服务降级的处理。

@FeignClient(name = "service-provider", fallbackFactory = FallbackFactoryClientImpl.class)
public interface ProviderClient {

      @GetMapping("/hello")
      String hello();
} 

@Service
public class FallbackFactoryClientImpl implements FallbackFactory { 

   @Override
   public ProviderClient create(Throwable throwable) {
         return new ProviderClient() { 

         @Override
         public String hello() {
              return "Service is unavailable temporarily! Exception: " + throwable.toString();
          }
        };
    }
}

在上述代码中，我们在@FeignClient注解中指定fallbackFactory为FallbackFactoryClientImpl类，同时FallbackFactoryClientImpl类实现了FallbackFactory接口，并在create()方法中对ProviderClient进行服务降级的处理。

当我们在调用ProviderClient的hello()方法时，如果服务提供方出现故障或延迟，就会自动切换到FallbackFactoryClientImpl类的相应方法上进行响应。

五、Feign Fallback的总结

通过本篇文章，我们详细介绍了如何使用Feign的Fallback机制来实现服务降级，从而保证服务的可用性和系统的平稳运行。我们可以通过自定义Fallback类或者FallbackFactory类，来灵活处理服务降级的问题，提高分布式系统的鲁棒性和稳定性。

六、在实际业务中，服务降级的方式可以有多种，具体取决于你的业务需求和技术栈。以下是一些常见的服务降级方式：

1. 返回默认值：当服务不可用时，可以返回一个默认值作为响应结果。例如，当某个接口无法访问时，可以返回一个空列表或默认的配置信息。
2. 缓存数据：当服务不可用时，可以从缓存中获取数据，避免直接请求服务端。这样可以保证用户能够继续访问，尽管数据可能不是最新的。
3. 降级页面：当服务不可用时，可以返回一个自定义的降级页面给用户，提示服务暂时不可用，并提供其他功能或信息。
4. 异步处理：当服务不可用时，可以将请求放入消息队列或异步任务中，稍后再处理。这样可以避免阻塞用户请求，提高系统的可用性。
5. 熔断器：熔断器是一种实现服务降级的机制，通过监控服务的调用情况，当服务出现故障或延迟时，自动切换到备用逻辑，避免连锁故障。
6. 限流：限流是一种控制请求流量的机制，当服务达到一定的负载或并发量时，可以拒绝部分请求，保证系统的稳定性。

以上只是一些常见的服务降级方式，具体的选择取决于你的业务需求和技术栈。在使用Feign的Fallback机制时，可以根据具体情况自定义Fallback类来实现服务降级逻辑。

需要注意的是，服务降级只是应对服务不可用的一种手段，更重要的是要保证系统的稳定性和可用性。在设计和开发过程中，需要考虑到服务的容错能力、负载均衡、监控和告警等方面，以提高系统的鲁棒性和可靠性。

解决Feign中的read timed out异常

更新：2023-06-29 11:58

本篇文章将为大家介绍如何解决Feign中的read timed out异常。这个异常通常是因为请求超时导致的，我们可以通过以下几个方面来解决这个问题。

一、增加超时时间

Feign默认的请求超时时间是1秒钟，如果请求的服务处理时间超过了1秒钟，就会出现read timed out异常。我们可以通过增加超时时间来解决这个问题。例如，我们需要将请求超时时间设置成5秒钟，可以在FeignClient的配置中增加如下配置：

    /**
     * FeignClient配置类
     */
    @Configuration
    public class FeignConfig {
        /**
         * 将超时时间设置为5秒
         */
        @Bean
        public Request.Options options() {
            return new Request.Options(5000, 5000);
        }
    }

以上代码中，“5000”表示超时时间，单位是毫秒。通过这样的方式，我们就可以增加Feign的请求超时时间。

二、增加连接池大小

如果请求的并发量很大，那么可能会导致连接池不够用，从而出现read timed out异常。此时，我们可以通过增加连接池的大小来解决问题。例如，我们需要将连接池的大小设置成20，可以在FeignClient的配置中增加如下配置：

    /**
     * FeignClient配置类
     */
    @Configuration
    public class FeignConfig {
        /**
         * 将连接池大小设置为20
         */
        @Bean
        public OkHttpClient okHttpClient() {
            return new OkHttpClient.Builder()
                    .connectTimeout(5, TimeUnit.SECONDS)
                    .readTimeout(5, TimeUnit.SECONDS)
                    .connectionPool(new ConnectionPool(20, 5L, TimeUnit.MINUTES))
                    .build();
        }
    }

以上代码中，我们通过connectionPool()方法来设置连接池的大小。第一个参数表示连接池最大的空闲连接数，第二个参数表示连接的过期时间，第三个参数表示过期时间的单位。通过这样的方式，我们就可以增加Feign的连接池大小。

三、使用线程池

如果请求的并发量很大，那么可能会导致一些请求被阻塞，从而出现read timed out异常。此时，我们可以使用线程池来解决问题。例如，我们需要将线程池的最大线程数设置成10，可以在FeignClient的配置中增加如下配置：

    /**
     * FeignClient配置类
     */
    @Configuration
    public class FeignConfig {
        /**
         * 将线程池的最大线程数设置为10
         */
        @Bean
        public Executor executor() {
            ThreadPoolExecutor executor = new ThreadPoolExecutor(10, 10, 10L, TimeUnit.SECONDS, new LinkedBlockingQueue<>());
            return executor;
        }
    }

以上代码中，我们通过ThreadPoolExecutor类来创建线程池。其中，第一个参数表示核心线程数，第二个参数表示最大的线程数，第三个参数表示空闲线程的过期时间，第四个参数表示过期时间的单位，最后一个参数表示任务队列。通过这样的方式，我们就可以使用线程池来处理Feign的请求。

四、增加日志输出

如果请求出现了异常，我们希望能够知道出错的具体原因。此时，我们可以增加Feign的日志输出来解决问题。例如，我们需要将日志级别设置成DEBUG，可以在FeignClient的配置中增加如下配置：

    /**
     * FeignClient配置类
     */
    @Configuration
    public class FeignConfig {
        /**
         * 将日志级别设置为DEBUG
         */
        @Bean
        Logger.Level feignLoggerLevel() {
            return Logger.Level.DEBUG;
        }
    }

以上代码中，我们通过feignLoggerLevel()方法来将日志级别设置为DEBUG。通过这样的方式，我们就可以增加Feign的日志输出，从而更好的排查问题。

以上是解决Feign中的read timed out异常的几种方式，我们可以根据实际的情况选择合适的方式来解决问题。

Feign 如何设置接受参数大小

更新：2023-06-29 10:03

Feign是一种Java HTTP客户端，它使编写Web服务客户端变得更加容易。Feign是基于Netflix Ribbon构建的，它具有可插拔的注解支持，包括Feign注解和JAX-RS注解。在使用Feign进行开发时，开发人员需要考虑到如何设置接受参数大小以确保系统运行的高效性和稳定性。

一、设置Feign Client的超时时间

在使用Feign进行开发时，由于网络问题或者请求响应问题，服务器的响应时间可能会非常慢。如果Feign Client的超时时间设置的比较短，那么请求会在超时之前得到响应。如果设置的比较长，那么在服务器响应之前等待的时间会比较长。因此，Feign Client的超时时间应该根据服务器的响应时间来进行设置。

在Feign中，设置超时时间的方法有两种。第一种方法是在全局范围内配置超时时间，这将影响所有Feign Client的超时时间。代码示例如下：

@Configuration
public class FeignConfig {

    @Bean
    public Request.Options options() {
        return new Request.Options(5000, 10000);
    }
}

在上面的示例中，使用 @Configuration注解标注的类，用于全局配置Feign Client的超时时间。在这个类中，返回一个 Request.Options 对象。在 Request.Options的构造方法中，第一个参数表示连接时间，第二个参数表示读取时间，这里分别设置为5秒和10秒。

另一种方法是对某个Feign Client进行单独配置。代码示例如下：

@FeignClient(name = "XXX", url = "http://localhost:8080/", configuration = FeignConfig.class)
public interface MyFeignClient {

    @GetMapping("/test")
    String test();
}

在上面的示例中，使用 @FeignClient 注解标注的 MyFeignClient 接口，用于单独配置Feign Client的超时时间。在 @FeignClient 注解中，使用 configuration 属性指定所使用的配置类。这里指定的是 FeignConfig 类。在 FeignConfig 类中，同样返回一个 Request.Options 对象，用于配置单独Feign Client的超时时间。

二、设置Feign Client的缓存大小

在使用Feign进行开发时，很容易产生请求和响应的缓存，这可能会导致Feign Client的缓存大小超过预期而影响系统的性能。为避免这种情况的发生，可以对Feign Client的缓存大小进行设置。

在Feign中，设置缓存大小的方法有两种。第一种方法是在全局范围内配置缓存大小，代码示例如下：

@Configuration
public class FeignConfig {

    @Bean
    public CacheManager cacheManager() {
        return new InMemoryCacheManager();
    }
}

在上面的示例中，使用 @Configuration注解标注的类，用于全局配置Feign Client的缓存大小。在这个类中，返回一个 CacheManager 对象。CacheManager 构造函数中不进行任何的设置。默认使用 InMemoryCacheManager 内存存储方式。

另一种方法是对某个Feign Client进行单独配置。代码示例如下：

@FeignClient(name = "XXX", url = "http://localhost:8080/", configuration = FeignConfig.class)
public interface MyFeignClient {

    @GetMapping("/test")
    String test();
}

在上面的示例中，使用 @FeignClient 注解标注的 MyFeignClient 接口，用于单独配置Feign Client的缓存大小。在 @FeignClient 注解中，使用 configuration 属性指定所使用的配置类。这里指定的是 FeignConfig 类。在 FeignConfig 类中，同样返回一个 CacheManager 对象，用于配置单独Feign Client的缓存大小。

三、设置Feign Client的请求大小

在使用Feign进行开发时，请求的大小也会影响系统的性能。如果请求的大小超过服务器的处理范围，那么可能会导致服务器的性能急剧下降。因此，在使用Feign进行开发时，需要设置Feign Client的请求大小。

在Feign中，设置请求大小的方法有两种。第一种方法是在全局范围内配置请求大小，代码示例如下：

@Configuration
public class FeignConfig {

    @Bean
    public Decoder decoder() {
        return new JacksonDecoder();
    }

    @Bean
    public Encoder encoder() {
        return new JacksonEncoder();
    }

    @Bean
    public Contract feignContract() {
        return new SpringMvcContract();
    }

    @Bean
    public OkHttpClient okHttpClient() {
        return new OkHttpClient.Builder()
                .addInterceptor(new RequestInterceptor())
                .retryOnConnectionFailure(false)
                .connectTimeout(15, TimeUnit.SECONDS)
                .readTimeout(60, TimeUnit.SECONDS)
                .writeTimeout(60, TimeUnit.SECONDS)
                .build();
    }
}

在上面的示例中，使用 @Configuration 注解标注的类，用于全局配置Feign Client的请求大小。在这个类中，配置了Decoder、Encoder、Contract、OkHttpClient等。其中，OkHttpClient 的参数中，设置了读取超时时间为60秒。因此，Feign Client的请求大小设置为60秒。

另一种方法是对某个Feign Client进行单独配置。代码示例如下：

@FeignClient(name = "XXX", url = "http://localhost:8080/", configuration = FeignConfig.class)
public interface MyFeignClient {

    @GetMapping(value = "/test", consumes = "application/json", produces = "application/json")
    String test(@RequestBody MyRequestBody request);
}

在上面的示例中，使用 @FeignClient 注解标注的 MyFeignClient 接口，用于单独配置Feign Client的请求大小。在 @GetMapping 注解中，使用 consumes 属性指定请求参数的类型。在 @RequestBody 注解中，使用 MyRequestBody 对象作为请求参数，其中包含了请求的大小。

OpenFeign消费者重新定义参数类全面解析

更新：2023-06-29 12:27

在本文中，我们将会从多个方面来深入探讨如何使用OpenFeign消费者重新定义参数类。

一、定义参数类的基本概念

在使用OpenFeign消费者时，参数类是至关重要的一部分。参数类可以帮助我们更好地组织请求参数并将其传递给服务端。简单来说，参数类就是一组字段的集合，每个字段代表一个请求参数。下面是一个示例参数类的代码：

public class User {
    private Integer id;
    private String name;
    private Integer age;

    // 省略 getter 和 setter 方法
}

上面的代码定义了一个名为 User 的参数类，包含了 id、name 和 age 三个字段，这三个字段分别代表了用户的ID、姓名和年龄。在构造 OpenFeign 请求时，我们可以使用这个参数类来携带请求参数。

二、重新定义参数类

在使用 OpenFeign 消费者时，我们可以重新定义参数类，这样可以更好地满足实际场景的需要。下面是一些示例：

1. 定义继承结构的参数类

如果参数类之间存在继承关系，我们可以通过继承来定义它们。下面是一个示例代码：

public class CreateUserRequest extends User {
    private String password;

    // 省略 getter 和 setter 方法
}

上面的代码定义了一个名为 CreateUserRequest 的参数类，它继承了 User 类，并添加了一个 password 字段，用于创建新用户时设置用户密码。

2. 定义多个参数类并组合使用

有些场景下，我们需要同时传递多个参数，这时可以定义多个参数类并组合使用。下面是一个示例代码：

public class CreateOrderRequest {
    private User user;
    private List items;

    // 省略 getter 和 setter 方法
}

public class OrderItem {
    private Integer productId;
    private Integer quantity;

    // 省略 getter 和 setter 方法
}

上面的代码定义了两个参数类：CreateOrderRequest 和 OrderItem。CreateOrderRequest 包含了一个 user 字段和一个 items 字段，其中 user 代表下单用户的信息，items 则代表下单的全部商品信息。而 OrderItem 则只包含了 productId 和 quantity 两个字段，用于描述一个商品的信息。

三、使用自定义的参数类

在 OpenFeign 消费者中，使用自定义的参数类非常简单。下面我们通过一个示例来展示如何在 OpenFeign 消费者中使用自定义的参数类。

1. 引入 OpenFeign

首先，我们需要在项目中引入 OpenFeign 的依赖。假设我们正在使用 Maven，可以轻松地在 pom.xml 中添加以下依赖项：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

2. 定义 API 接口

接下来，我们需要定义一个 OpenFeign 的 API 接口。在这个接口中，我们可以定义多个方法来访问服务端提供的不同接口。下面是一个示例代码：

@FeignClient(name = "user-service")
public interface UserFeignClient {
    @RequestMapping(method = RequestMethod.POST, value = "/users")
    User createUser(CreateUserRequest request);

    @RequestMapping(method = RequestMethod.GET, value = "/users/{id}")
    User getUserById(@PathVariable("id") Integer id);

    @RequestMapping(method = RequestMethod.DELETE, value = "/users/{id}")
    void deleteUserById(@PathVariable("id") Integer id);
}

上面的代码定义了一个名为 UserFeignClient 的 OpenFeign 接口。这个接口包含了三个方法，分别用于创建用户、获取用户信息和删除用户信息。其中，createUser 方法将会接收一个 CreateUserRequest 类型的参数。

3. 使用参数类调用接口

现在，我们已经定义好了 OpenFeign 的接口和参数类，可以使用它们来访问服务端提供的接口。下面是一个示例代码：

@Autowired
private UserFeignClient userFeignClient;

public void test() {
    CreateUserRequest request = new CreateUserRequest();
    request.setName("张三");
    request.setAge(18);
    request.setPassword("123456");

    User user = userFeignClient.createUser(request);

    System.out.println(user);
}

上面的代码中，我们首先创建了一个 CreateUserRequest 的实例，然后将其作为参数传递给了 userFeignClient 的 createUser 方法。最后，我们打印出了服务端返回的 user 对象。

四、总结

通过本文的介绍，我们了解了 OpenFeign 消费者重新定义参数类的基本概念，并从不同方面进行了详细的阐述。同时，我们还展示了如何在 OpenFeign 消费者中定义自己的参数类，并使用它们来调用服务端提供的接口。希望本文能够对您有所帮助。

FeignException.errorexecuting异常解析

更新：2023-06-29 20:20

Feign是一个声明式的Web服务客户端，能够让我们更加方便地调用HTTP API。同时，Feign还提供了许多有用的特性，比如负载均衡、错误处理等。而其中一个常见的异常就是FeignException.errorexecuting。本文将对该异常进行详细讲解，帮你了解它的成因及如何解决该异常。

一、异常描述

FeignException.errorexecuting是Feign中的一种异常，当调用远程服务失败时，会抛出该异常。该异常常见于使用Feign调用远程服务时，由于网络原因或者目标服务的问题，调用服务失败时抛出。

二、异常原因

造成FeignException.errorexecuting异常的原因很多，常见的有以下几种：

1、服务端错误：服务提供方处理请求出错，比如服务端代码错误、数据库查询错误等。

2、网络中断：由于网络问题导致请求发送失败，比如网络波动、网络延迟等。

3、请求过程中超时：当请求耗时过久并超过了Feign客户端配置的超时时间，此时Feign会抛出该异常。

三、异常示例

1、Feign client调用服务时，返回错误状态码

public interface UserService{
    @GetMapping("/users/{id}")
    User getUserById(@PathVariable("id") Long id);
}

public class UserServiceImpl{
    User getUserById(Long id) {
        try {
            return userServiceClient.getUserById(id);
        } catch (FeignException e) {
            log.error("get user by id {} error, message: {}", id, e.getMessage());
            throw e;
        }
    }
}

在上述代码中，当user-service服务返回错误状态码时，就会抛出FeignException.errorexecuting异常。

2、feign client请求超时

public interface UserService{
    @GetMapping("/users/{id}")
    User getUserById(@PathVariable("id") Long id);
}

public class UserServiceImpl{
    User getUserById(Long id) {
        try {
            return userServiceClient.getUserById(id);
        } catch (FeignException e) {
            log.error("get user by id {} error, message: {}", id, e.getMessage());
            throw e;
        }
    }
}

在上述代码中，当调用user-service服务时，请求时间超过Feign客户端配置的超时时间，就会抛出FeignException.errorexecuting异常。

四、异常处理

对于FeignException.errorexecuting异常，我们可以通过以下方式进行处理。

1、根据异常信息判断异常类型，细化异常处理。比如，当服务端返回错误状态码时，可以根据状态码来判断异常类型，然后进行具体的异常处理。

2、增加重试机制。对于网络问题导致的请求发送失败，我们可以增加重试机制，再次尝试发送请求，减少请求失败率。如果重试次数过多仍无法成功，则抛出异常。

3、增加超时时间。当发生网络波动、网络延迟等情况时，我们可以将超时时间适当的增加一下，防止请求时间过短而引起异常。

五、小结

FeignException.errorexecuting是Feign中的一种异常，常见于使用Feign调用远程服务时，由于网络原因或者目标服务的问题，调用服务失败时抛出。我们可以通过根据异常信息判断异常类型、增加重试机制、增加超时时间等方式进行处理。