【Spring Cloud】基于 Feign 实现远程调用，深入探索 Feign 的自定义配置、性能优化以及最佳实践方案

前言

在微服务架构中，服务之间的通信是至关重要的，而远程调用则成为实现这种通信的一种常见方式。在 Java 中，使用 RestTemplate 是一种传统的远程调用方式，但它存在一些问题，如代码可读性差、编程体验不一致以及参数复杂URL难以维护等。

在本文中，我们将探讨如何通过使用 Spring Cloud 中的 Feign 来解决这些问题，使得远程调用变得更加优雅和方便。

问题背景：使用 RestTemplate 远程调用存在的问题

考虑以下使用 RestTemplate 进行远程调用的代码：

String url = "http://userservice/user/" + order.getUserId();
User user = restTemplate.getForObject(url, User.class);
1
2

这段代码存在一些问题：

• 可读性差： URL 拼接直接放在代码中，降低了代码的可读性。
• 编程体验不统一： 使用 RestTemplate 和其他 HTTP 客户端的方式差异较大，不够统一。
• 参数复杂URL难以维护： 当 URL 中的参数较多时，拼接字符串的方式难以维护和管理。

解决方案：使用 HTTP 客户端 Feign

Feign 是一个声明式的、模板化的 HTTP 客户端，是 Spring Cloud 生态中的一部分。它的设计目标是简化微服务架构中服务之间的通信，使得远程调用变得更加简单和优雅。

Feign 的基本概念：

1. 声明式 API：

Feign 提供了一种声明式的 API 定义方式，通过接口的方式定义远程服务的调用。这种声明式的风格使得远程调用看起来就像是调用本地方法一样，大大提高了代码的可读性。

@FeignClient(name = "userservice")
public interface UserClient {

    @GetMapping("/user/{userId}")
    User getUser(@PathVariable("userId") String userId);
}
1
2
3
4
5
6

在上述代码中，@FeignClient 注解用于定义一个 Feign 客户端，@GetMapping 和 @PathVariable 注解用于定义远程调用的地址。

2. 集成 Ribbon

Feign 默认集成了 Ribbon，这是一个负载均衡的客户端。通过与 Ribbon 的集成，Feign 能够实现对服务的负载均衡，提高了系统的可用性和稳定性。

3. 支持 Hystrix

Hystrix 是一个熔断器框架，Feign 通过集成 Hystrix 提供了熔断器的支持。这意味着在远程服务不可用或响应时间过长时，Feign 能够执行预定义的降级逻辑，防止故障在整个系统中蔓延。

使用 Feign 的好处：

1. 简化调用代码

通过使用 Feign，远程调用的代码变得简洁清晰。不再需要手动拼接 URL，而是通过接口的方式直接定义调用的方法和参数。

2. 统一的编程体验

Feign 与其他 Spring Cloud 组件（如 Eureka、Ribbon、Hystrix 等）整合得很好，使得整体的编程体验更加统一。这样开发者在使用不同组件时，能够保持相似的编程风格。

3. 内置负载均衡和熔断器

Feign 默认集成了 Ribbon 和 Hystrix，无需额外配置，就能够实现负载均衡和熔断器的功能。这使得系统更加健壮和可靠。

总而言之，Feign 是一个优秀的声明式 HTTP 客户端，它的设计使得远程调用变得更加简单和优雅。通过整合 Ribbon 和 Hystrix，Feign 提供了负载均衡和熔断器的支持，使得微服务架构中服务之间的通信更加健壮可靠。在构建微服务应用时，考虑使用 Feign，提高代码的可读性和系统的稳定性。

一、基于 Feign 的远程调用

1.1 引入依赖

在项目的 Maven 配置中，引入 Spring Cloud 和 Feign 的依赖：

<dependency>
    <groupId>org.springframework.cloudgroupId>
    <artifactId>spring-cloud-starter-openfeignartifactId>
dependency>
1
2
3
4

1.2 启用 Feign

在 Spring Boot 应用的主类上添加 @EnableFeignClients 注解，以启用 Feign：

@SpringBootApplication
@EnableFeignClients
public class YourApplication {

    public static void main(String[] args) {
        SpringApplication.run(YourApplication.class, args);
    }
}
1
2
3
4
5
6
7
8

1.3 编写 Feign 客户端

创建一个接口，并使用 @FeignClient 注解指定服务的名称：

@FeignClient(name = "userservice")
public interface UserClient {

    @GetMapping("/user/{userId}")
    User getUser(@PathVariable("userId") String userId);
}
1
2
3
4
5
6

1.4 使用 Feign 客户端

在需要调用远程服务的地方，注入 UserClient 并调用相应的方法：

@Service
public class UserService {

    @Autowired
    private UserClient userClient;

    public User getUserById(String userId) {
        return userClient.getUser(userId);
    }
}
1
2
3
4
5
6
7
8
9
10

通过上述步骤，就成功地使用了 Feign 进行远程服务调用。

二、Feign 的自定义配置

2.1 Feign 的自定义配置项

Feign 提供了一些自定义配置项，可以根据项目的需求进行调整。以下是一些常用的配置项：

详细说明：

1. feign.Logger.Level

   • 作用： 修改 Feign 的日志级别。
   • 说明： 控制 Feign 日志输出的详细程度，包括请求、响应的头信息和正文。级别分为：
     • NONE：不输出日志。
     • BASIC：仅输出请求方法、URL、响应状态码和执行时间。
     • HEADERS：在 BASIC 的基础上，输出请求和响应的头信息。
     • FULL：输出完整的请求和响应信息。

   @Configuration
   public class FeignConfig {
   
       @Bean
       public Logger.Level feignLoggerLevel() {
           return Logger.Level.FULL; // 可根据需求调整日志级别
       }
   }
   1
   2
   3
   4
   5
   6
   7
   8

2. feign.codec.Decoder

   • 作用： 响应结果的解析器。
   • 说明： 用于将 HTTP 远程调用的结果解析为 Java 对象。通常情况下，Feign 会自动选择合适的解析器，比如将 JSON 字符串解析为 Java 对象。如果需要定制解析过程，可以实现 Decoder 接口。

   @Configuration
   public class FeignConfig {
   
       @Bean
       public Decoder feignDecoder() {
           return new YourCustomDecoder(); // 自定义的解析器
       }
   }
   1
   2
   3
   4
   5
   6
   7
   8

3. feign.codec.Encoder

   • 作用： 请求参数编码。
   • 说明： 用于将请求参数编码，便于通过 HTTP 请求发送。通常情况下，Feign 会根据请求的数据类型自动选择合适的编码器，比如将 Java 对象编码为 JSON 字符串。如果需要定制编码过程，可以实现 Encoder 接口。

   @Configuration
   public class FeignConfig {
   
       @Bean
       public Encoder feignEncoder() {
           return new YourCustomEncoder(); // 自定义的编码器
       }
   }
   1
   2
   3
   4
   5
   6
   7
   8

4. feign.Contract

   • 作用： 支持的注解格式。
   • 说明： 定义 Feign 接口中支持的注解格式，默认是 SpringMVC 的注解。可以根据项目需要选择其他的注解格式，例如 feign.Contract.Default 或自定义的 feign.Contract 实现。

   @Configuration
   public class FeignConfig {
   
       @Bean
       public Contract feignContract() {
           return new feign.Contract.Default(); // 默认的注解格式
       }
   }
   1
   2
   3
   4
   5
   6
   7
   8

5. feign.Retryer

   • 作用： 失败重试机制。
   • 说明： 控制请求失败的重试机制，默认是没有重试，但会使用 Ribbon 的重试。可以通过自定义实现 Retryer 接口来定制重试策略。

   @Configuration
   public class FeignConfig {
   
       @Bean
       public Retryer feignRetryer() {
           return new YourCustomRetryer(); // 自定义的重试策略
       }
   }
   1
   2
   3
   4
   5
   6
   7
   8

以上是一些常见的 Feign 自定义配置项，根据具体项目的需求进行选择和调整。通过合理配置这些项，可以更好地满足系统的特定需求，提高 Feign 在微服务架构中的灵活性和适用性。

2.2 示例：配置 Feign 的日志级别

在使用 Feign 进行远程调用时，配置日志级别是一种常见的需求，以便更好地监控和调试远程调用过程。配置 Feign 的日志级别有两种方式：配置文件方式和 Java 代码方式。

1. 配置文件方式

首先，在项目的配置文件（例如 application.properties 或 application.yml）中配置 Feign 的日志级别。以下是一个示例，假设你的 Feign 客户端接口为 UserClient：

# 配置 Feign 的日志等级
feign:
  client:
    config:
      default:
        loggerLevel: FULL
1
2
3
4
5
6

这里的 UserClient 是你的 Feign 客户端接口的名称，按照规范是接口的类名首字母小写。通过这种方式，你可以为每个不同的 Feign 客户端设置不同的日志级别。

这是没有配置日志时访问输出的结果：

这是配置了 FULL 等级日志后访问输出的结果：

此时，输出完整的 HTTP 请求和响应信息。

2. Java 代码方式

如果要使用 Java 代码完成 Feign 日志的配置，则需要创建一个 Feign 的配置类，并配置 Feign 的日志 Bean 对象。

示例代码如下：

public class FeignConfig {
    @Bean
    public Logger.Level logLevel(){
        return Logger.Level.BASIC;
    }
}
1
2
3
4
5
6

但是，光有这个类，Feign 的日志并不会生效，还需要额外加上注解，这里有两种方式：

1. 如果是针对所有的 Client 类都生效，则把这个类放到启动类的@EnableFeignClients注解中：

@EnableFeignClients(defaultConfiguration = FeignConfig.class)
1

例如：

2. 如果这个配置只针对某个特定的 Feign 客户端生效，将配置类放到这个 Feign 客户端接口上的 @FeignClient 注解中：

@FeignClient(value = "userservice", configuration = FeignConfig.class)
1

例如：

通过以上的方式进行配置，我们可以灵活地控制 Feign 的日志输出，以适应不同环境和调试需求。

三、性能优化

在使用 Feign 进行远程调用时，性能优化是一个重要的方面，涉及到连接池的配置和日志级别的选择。下面将重点讨论 Feign 的性能优化，包括连接池配置和日志级别的优化。

3.1 Feign 的性能优化之连接池配置

Feign 的底层支持多种客户端实现，包括 URLConnection、Apache HttpClient 和 OKHttp。其中，URLConnection 是默认实现，不支持连接池，而 Apache HttpClient 和 OKHttp 支持连接池。

下面以添加 HttpClient 为例，进行 Feign 的连接池配置：

1. 添加 HttpClient 支持

首先，我们需要添加 HttpClient 的支持。在项目的 Maven 配置中引入 feign-httpclient 依赖：

<dependency>
    <groupId>io.github.openfeigngroupId>
    <artifactId>feign-httpclientartifactId>
dependency>
1
2
3
4
5

2. 配置连接池

接下来，我们需要配置连接池的相关参数。在配置文件（例如 application.yml）中添加如下配置：

feign:
  client:
    config:
      default:
        loggerLevel: BASIC # 日志级别，BASIC 表示基本的请求和响应信息
  httpclient:
    enabled: true # 开启 Feign 对 HttpClient 的支持
    max-connections: 200 # 最大的连接数
    max-connections-per-route: 50 # 每个路径的最大连接数
1
2
3
4
5
6
7
8
9

上述配置中，max-connections 表示最大的连接数，max-connections-per-route 表示每个路径的最大连接数。通过这样的配置，我们可以充分利用连接池来提高远程调用的性能。

3.2 Feign 的性能优化之日志级别优化

Feign 的日志级别选择也对性能有一定的影响。在远程调用中，通常建议使用 BASIC 或 NONE 级别的日志，以减少不必要的日志输出，提高性能。

例如，在配置文件中，将 Feign 的日志级别设置为 BASIC：

feign:
  client:
    config:
      default:
        loggerLevel: BASIC # 日志级别，BASIC 表示基本的请求和响应信息
1
2
3
4
5

或者，如果不需要任何日志输出，可以将日志级别设置为

feign:
  client:
    config:
      default:
        loggerLevel: NONE # 不输出任何日志
1
2
3
4
5

选择适当的日志级别，可以降低日志输出的数量，减轻系统的负担，提高远程调用的性能。特别是在生产环境中，通常建议选择较低的日志级别，以减少不必要的日志信息。

综上所述，优化 Feign 的性能主要包括连接池的配置和日志级别的选择。通过使用连接池代替默认的 URLConnection，以及选择适当的日志级别，我们可以提高远程调用的效率，减轻系统负担。在实际项目中，根据具体需求和场景进行合理的配置，以达到性能优化的目的。

四、最佳实践方案

4.1 使用 Feign 存在的问题及解决方案

在使用 Feign 进行微服务间通信时，可能会出现接口定义的重复开发问题。例如，在服务提供者的 Controller 中定义了一个接口方法，而在服务消费者的 Feign Client 中也需要定义相同的接口方法。这样的重复开发显然是不够优雅和高效的。

问题描述：

以示例代码为例：

在 user-service 中的 UserController 中有以下方法：

@GetMapping("/{id}")
public User findById(@PathVariable("id") Long id) {
    return userService.queryById(id);
}
1
2
3
4

而在 order-service 中的 UserClient 中，需要定义相似的接口方法：

@GetMapping("/user/{id}")
User findById(@PathVariable("id") Long id);
1
2

这两段代码的功能相似，但却存在重复的问题。

解决方案：

为了解决这个问题，我们可以考虑提前它们公共的代码，这个提取公共代码的方式则可以考虑使用继承或者抽取来实现。

4.2 方式一（继承）：定义统一的父接口

通过继承的方式，我们可以定义一个统一的父接口，包含了微服务间通信的所有可能方法。

如下图所示：

以下是详细的实现步骤：

1. 定义统一的接口

   // UserAPI.java
   public interface UserAPI {
       @GetMapping("/user/{id}")
       User findById(@PathVariable("id") Long id);
   }
   1
   2
   3
   4
   5

2. 服务消费者的 Feign Client 继承接口

   // UserClient.java
   @FeignClient(value = "userservice")
   public interface UserClient extends UserAPI {
       // 这里无需再次定义方法，直接继承 UserAPI 即可
   }
   1
   2
   3
   4
   5

3. 服务提供者的 Controller 实现接口

   // UserController.java
   @RestController
   public class UserController implements UserAPI {
   
       @Override
       public User findById(@PathVariable("id") Long id) {
           // 实现业务逻辑
       }
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9

通过这种方式，我们实现了统一的 API 定义，服务消费者直接继承接口，无需重复定义。服务提供者实现接口，确保了对外提供的接口和消费者使用的接口一致性。

优势：

• 提高代码的一致性和可读性。
• 统一接口定义，降低维护成本。

存在的问题：

1. 紧密耦合： 继承接口的方式会引入服务提供者和服务消费者之间的紧密耦合。一旦服务提供者的接口发生变化，所有继承的 Feign Client 都需要进行相应的修改，这可能导致维护成本的增加。

2. 不适用于当前形式的 Spring MVC： 在 Spring MVC 中，方法参数映射并不是通过继承关系来实现的，而是通过注解等机制。因此，直接继承可能并不是最合适的选择。

考虑到这些问题，采用抽取的方式，将 Feign Client 抽取为独立模块，通过独立的接口定义和配置来提供给服务消费者，确实是更加灵活和可维护的选择。

4.3 方式二（抽取）：抽取 Feign Client 为独立模块

在这个方式中，我们将 Feign Client 抽取为一个独立的模块，其中包含了所有服务的客户端、相关的实体类以及 Feign 的自定义配置。这个模块将被所有服务的消费者引入，从而实现对 Feign Client 的共享使用。

示例图：

在这个示例中，创建了一个名为 feign-api 的模块，它包含了所有服务的 Feign Client 接口 UserClient、相关的实体类 User，以及 Feign 的自定义配置 FeignConfig。

实现最佳实践方式二的步骤如下：

1. 首先新创建一个模块，命名为feign-api，然后在 pom.xml 中引入feign的starter依赖

  <dependency>
      <groupId>org.springframework.cloudgroupId>
      <artifactId>spring-cloud-starter-openfeignartifactId>
  dependency>
1
2
3
4
5

2. 将 order-service 中编写的UserClient、User、FeignConfig等类都复制到feign-api项目中

3. 在order-service中引入feign-api的依赖

<dependency>
    <groupId>cn.demo.cloudgroupId>
    <artifactId>feign-apiartifactId>
    <version>1.0version>
dependency>
1
2
3
4
5
6

4. 修改order-service中的所有与上述三个组件有关的import部分，改成导入feign-api中的包

5. 重启测试

重新启动 order-service 服务，发现找不到 UserClinet 这个 Bean 对象：

其原因在于当定义的FeignClient不在 order-service 的SpringBootApplication的扫描包范围，此时这些FeignClient无法使用。

有两种方式解决：

1. 指定FeignClient所在包

@EnableFeignClients(basePackages = "cn.itcast.feign.clients")
1

2. 指定FeignClient字节码

@EnableFeignClients(clients = {UserClient.class})
1

优点：

• 代码复用性： 将 Feign Client 抽取为独立模块，可以在多个微服务中实现代码的复用，避免了重复定义 Feign Client 接口和相关实体类。
• 统一配置： 集中管理 Feign 的自定义配置，确保所有服务使用相同的配置，提高了配置的一致性。
• 模块化： 将相关的内容放置在独立的模块中，使得项目结构更加清晰，易于维护和管理。

缺点：

• 依赖冗余： 有时一个服务可能只会使用 feign-api 中的部分内容，例如仅仅需要其中的一个实体类，但却引入了整个 feign-api 模块，可能导致依赖的冗余。

注意事项：

• 在设计 feign-api 模块时，需要根据实际需求进行合理的划分，确保模块中的内容是相关的、有复用性的。
• 对于可能引入的依赖冗余问题，可以根据具体情况权衡使用方式一或方式二。