OpenFeign 入门与实战：快速搭建 Spring Cloud 微服务客户端

可儿·四系桜2024-10-15 16:09

1. 前言

随着微服务架构的流行，服务之间的通信变得越来越重要。Spring Cloud 提供了一系列工具来帮助开发者构建分布式系统，其中 OpenFeign 是一个轻量级的 HTTP 客户端，它简化了 Web 服务客户端的开发。本文将介绍如何在 Spring Cloud 应用中使用 OpenFeign 来进行服务间的调用，并解决一些常见的配置问题。

2. 什么是 OpenFeign？

OpenFeign 是 Spring Cloud 的一部分，它是一个声明式的 Web 服务客户端。通过使用 OpenFeign，开发者可以以声明的方式编写 Web 服务客户端接口，而不需要创建模板化的 HTTP 请求。Feign 内置了 Ribbon，用于实现客户端负载均衡，使得调用服务注册中心中的服务变得更加容易。

官方地址：https://github.com/OpenFeign/feign

本篇文章示例代码：https://github.com/kerrsixy/cloud-demo

3. 快速入门

以调用user-service模块的 /user/{id} 接口为例。

3.1 调用端引入依赖

在order-service服务的pom文件中引入feign的依赖：

XML 复制代码 
<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

3.2 调用端添加注解

在order-service的启动类添加注解开启Feign的功能：

java 复制代码 
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;

@EnableFeignClients
@SpringBootApplication
public class OrderServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderServiceApplication.class, args);
    }
}

3.3 编写Feign的客户端

java 复制代码 
import com.zjp.orderservice.entity.User;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

@FeignClient(name = "user-service")
public interface UserClient {
    @GetMapping("/user/{id}")
    User getUser(@PathVariable("id") Long id);
}

如果该类里都是以/user开头的可以改为：

java 复制代码 
import com.zjp.orderservice.entity.User;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

@FeignClient(name = "user-service", path = "/user")
public interface UserClient {
    @GetMapping("/{id}")
    User getUser(@PathVariable("id") Long id);
}

如果没有配置中心或配置中心有多个同名服务需要指定url，则需要额外配置url：

java 复制代码 
import com.zjp.orderservice.entity.User;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

@FeignClient(name = "user-service", url = "http://localhost:8080", path = "/user")
public interface UserClient {
    @GetMapping("/{id}")
    User getUser(@PathVariable("id") Long id);
}

这个客户端主要是基于SpringMVC的注解来声明远程调用的信息，比如：

  • 服务名称：user-service
  • 请求方式：GET
  • 请求路径：/user/{id}
  • 请求参数：Long id
  • 返回值类型：User

这样，Feign就可以帮助我们发送http请求。

注意：

  • 如果没有指定url，则name要写为服务名。
  • 如果指定了url，则name无论起什么名字都行，但是不能为null。

3.4. 测试

java 复制代码 
import com.zjp.orderservice.entity.User;
import com.zjp.feginservice.client.UserClient;
import com.zjp.orderservice.entity.Order;
import com.zjp.orderservice.mapper.OrderMapper;
import com.zjp.orderservice.service.OrderService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

@Service
public class OrderServiceImpl implements OrderService {
    @Autowired
    private UserClient userClient;

    @Override
    public User getOrderById(Long id) {
        User user = userClient.getUser(id);
        return user;
    }
}

3.5. 总结

使用Feign的步骤：

  1. 引入依赖
  2. 添加@EnableFeignClients注解
  3. 编写FeignClient接口
  4. 使用FeignClient中定义的方法代替RestTemplate

4. 自定义配置

Feign可以支持很多的自定义配置，如下表所示：

|------------------------|----------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 类型 | 作用 | 说明 |
| feign.Logger.Level | 修改日志级别 | 包含四种不同的级别：NONE、BASIC、HEADERS、FULL |
| feign.codec.Decoder | 响应结果的解析器 | http远程调用的结果做解析，例如解析json字符串为java对象 |
| feign.codec.Encoder | 请求参数编码 | 将请求参数编码，便于通过http请求发送 |
| feign. Contract | 支持的注解格式 | 默认是SpringMVC的注解，原生注解：GitHub - OpenFeign/feign: Feign makes writing java http clients easier |
| feign. Retryer | 失败重试机制 | 请求失败的重试机制，默认是没有，不过会使用Ribbon的重试 |

一般情况下，默认值就能满足我们使用，如果要自定义时，只需要创建自定义的@Bean覆盖默认Bean即可。

下面以日志为例来演示如何自定义配置。

4.1 配置文件方式

  1. 针对单个服务：
ruby 复制代码 
feign:  
  client:
    config: 
      user-service: # 针对某个微服务的配置
        logger-level: FULL #  日志级别
  1. 针对所有服务：
ruby 复制代码 
feign:  
  client:
    config: 
      default: # 这里用default就是全局配置，如果是写服务名称，则是针对某个微服务的配置
        logger-level: FULL #  日志级别

日志的级别分为四种：

  • NONE：不记录任何日志信息，这是默认值。
  • BASIC：仅记录请求的方法，URL以及响应状态码和执行时间
  • HEADERS：在BASIC的基础上，额外记录了请求和响应的头信息
  • FULL：记录所有请求和响应的明细，包括头信息、请求体、元数据。

4.2. Java代码方式

也可以基于Java代码来修改日志级别，先声明一个类，然后声明一个Logger.Level的对象：

java 复制代码 
import feign.Logger;
import org.springframework.context.annotation.Bean;

public class DefaultFeignConfiguration {
    @Bean
    public Logger.Level feignLogLevel() {
        return Logger.Level.BASIC; // 日志级别为BASIC
    }
}

如果要全局生效，将其放到启动类的@EnableFeignClients这个注解中，例如：

java 复制代码 
import com.zjp.orderservice.config.DefaultFeignConfiguration;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;

@EnableFeignClients(defaultConfiguration = DefaultFeignConfiguration.class)
@SpringBootApplication
public class OrderServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderServiceApplication.class, args);
    }
}

如果是局部生效，则把它放到对应的@FeignClient这个注解中，例如：

java 复制代码 
import com.zjp.orderservice.entity.User;
import com.zjp.orderservice.config.DefaultFeignConfiguration;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

@FeignClient(name = "user-service",configuration = DefaultFeignConfiguration.class)
public interface UserClient {
    @GetMapping("/user/{id}")
    User getUser(@PathVariable("id") Long id);
}

注意：

需要将feign包下的日志级别设置为DEBUG，feign的日志才能在控制台输出，例如：

Haskell 复制代码 
logging:
  level:
    com.zjp.orderservice.client: DEBUG

5. Feign的原理

6. Feign使用优化

6.1 http连接池

Feign底层发起http请求，依赖于其它的框架。其底层客户端实现包括：

  • URLConnection：默认实现，不支持连接池
  • Apache HttpClient ：支持连接池
  • OKHttp：支持连接池

因此提高Feign的性能主要手段就是使用连接池代替默认的URLConnection。

这里我们用Apache的HttpClient来演示。

  1. 引入依赖

在order-service的pom文件中引入Apache的HttpClient依赖：

XML 复制代码 
<dependency>
  <groupId>io.github.openfeign</groupId>
  <artifactId>feign-httpclient</artifactId>
</dependency>
  1. 配置连接池

在order-service的application.yml中添加配置：

Haskell 复制代码 
feign:
  httpclient:
    enabled: true # 开启feign对HttpClient的支持
    max-connections: 200 # 最大的连接数
    max-connections-per-route: 50 # 每个路径的最大连接数
  1. 校验是否配置成功

在FeignClientFactoryBean中的loadBalance方法中打断点：

Debug方式启动order-service服务，可以看到这里的client，底层就是Apache HttpClient：

6.2 feign超时

Feign的底层用的是Ribbon或者LoadBalancer，我们可以手动设置超时时间。

可以针对单个服务：

Haskell 复制代码 
feign:
  client:
    config:
      user-service:
        connect-timeout: 5000 # 请求连接的超时时间
        read-timeout: 5000 # 请求响应的超时时间

可以针对所有服务：

Haskell 复制代码 
feign:
  client:
    config:
      default:
        connect-timeout: 5000 # 请求连接的超时时间
        read-timeout: 5000 # 请求响应的超时时间

6.3 总结

Feign的优化：

  1. 日志级别尽量用basic

  2. 使用HttpClient或OKHttp代替URLConnection

1）引入feign-httpClient依赖

2）配置文件开启httpClient功能，设置连接池参数

  1. 修改 OpenFeign 的超时时间，让 OpenFeign 能够正确的处理业务。

7. 最佳实践

在项目开发过程中可以发现，Feign的客户端与服务提供者的controller代码非常相似：

feign客户端：

java 复制代码 
@FeignClient(name = "user-service")
public interface UserClient {
    @GetMapping("/user/{id}")
    User getUser(@PathVariable("id") Long id);
}

服务提供者：

java 复制代码 
@GetMapping("/user/{id}")
public User getUser(@PathVariable("id") Long id) {
    return userService.getUserById(id);
}

有没有一种办法简化这种重复的代码编写呢？

7.1 继承方式（不推荐）

  1. 定义一个API接口，利用定义方法，并基于SpringMVC注解做声明。

  2. Feign客户端和Controller都集成改接口

优点：

  • 代码简单
  • 实现了代码的共享

缺点：

  • 服务提供方、服务消费方紧耦合
  • 参数列表中的注解映射并不会继承，因此Controller中必须再次声明方法、参数列表、注解

7.2 抽取方式

将Feign的Client抽取为独立模块，并且把接口有关的实体类、默认的Feign配置都放到这个模块中，提供给所有消费者使用。

例如，将UserClient、User、Feign的默认配置都抽取到一个feign-api包中，所有微服务引用该依赖包，即可直接使用。

7.2.1. 抽取

  1. 创建新moudle
  1. 在fegin-service中然后引入feign的starter依赖
XML 复制代码 
<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
  1. 在order-service中编写的UserClient、User、DefaultFeignConfiguration都复制到fegin-service项目中。
  1. 删除order-service中编写的UserClient、User、DefaultFeignConfiguration。

7.2.2 在order-service中使用feign-service

  1. 在order-service的pom文件中中引入feign-service的依赖：
XML 复制代码 
<dependency>
    <groupId>com.zjp</groupId>
    <artifactId>fegin-service</artifactId>
    <version>0.0.1-SNAPSHOT</version>
</dependency>
  1. 确保order-service服务能扫描到fegin-service服务下的包

方式一：指定Feign应该扫描的包

在order-service的启动类加@EnableFeignClients(basePackages = "com.zjp.feginservice.client")

java 复制代码 
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;

@EnableFeignClients(basePackages = "com.zjp.feginservice.client")
@SpringBootApplication
public class OrderServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderServiceApplication.class, args);
    }
}

方式二：指定需要加载的Client接口

在order-service的启动类加@EnableFeignClients(clients = {UserClient.class})

java 复制代码 
import com.zjp.feginservice.client.UserClient;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;

@EnableFeignClients(clients = {UserClient.class})
@SpringBootApplication
public class OrderServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderServiceApplication.class, args);
    }
}

注意：

order-service项目启动时，启动类会扫描其所在的包及其子包，如果不@EnableFeignClients注解，在order-service项目启动过程中无法扫描fegin-service项目下的包，会出现以下错误：

java 复制代码 
***************************
APPLICATION FAILED TO START
***************************

Description:

Parameter 1 of constructor in com.zjp.orderservice.service.impl.OrderServiceImpl required a bean of type 'com.zjp.feginservice.client.UserClient' that could not be found.


Action:

Consider defining a bean of type 'com.zjp.feginservice.client.UserClient' in your configuration.

8. Feign的拦截器

在order-service服务中，创建自定义的RequestInterceptor。

java 复制代码 
import feign.RequestInterceptor;
import feign.RequestTemplate;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;

@Slf4j
@Component
public class FeignInterceptor implements RequestInterceptor {
    @Override
    public void apply(RequestTemplate requestTemplate) {
        ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = servletRequestAttributes.getRequest();
        log.info("===request: {}", requestTemplate.url());
        log.info("Request URL: {}", request.getRequestURL());
        log.info("Request Method: {}", request.getMethod());
        log.info("Request Headers: {}", request.getHeaderNames());
        // 设置请求头
        requestTemplate.header("Authorization", "Bearer token");
        // 将上游请求头全部设置到下游请求中
        Enumeration<String> headerNames = request.getHeaderNames();
        while (headerNames.hasMoreElements()) {
            String name = headerNames.nextElement();
            String value = request.getHeader(name);
            requestTemplate.header(name, value);
        }
    }
}

重启测试：

注意：

Feign 默认情况下不会自动传递所有请求头到被调用的服务端。这是因为 Feign 有一个默认的配置，它只会传递一部分特定的请求头。如果你需要传递特定的请求头，需要手动配置。

  1. 默认传递的请求头：

1）Feign 默认会传递一些基本的请求头，如 Accept-Encoding、Connection 和 User-Agent 等。

2）其他请求头需要手动配置才能传递。

  1. 手动配置请求头：

1）在feign接口的注解上添加headers参数，例如：

java 复制代码 
import com.zjp.common.entity.User;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

@FeignClient(name = "user-service")
public interface UserClient {
    @GetMapping(value = "/user/{id}", headers = {"Authorization: Hello World!"})
    User getUser(@PathVariable("id") Long id);
}

2）通过参数传递，例如：

java 复制代码 
import com.zjp.common.entity.User;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestHeader;

@FeignClient(name = "user-service")
public interface UserClient {
    @GetMapping(value = "/user/{id}")
    User getUser(@RequestHeader("Authorization") String token, @PathVariable("id") Long id);
}

调用时，需要手动传请求头

java 复制代码 
import com.zjp.common.entity.User;
import com.zjp.feginservice.client.UserClient;
import com.zjp.orderservice.entity.Order;
import com.zjp.orderservice.mapper.OrderMapper;
import com.zjp.orderservice.service.OrderService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

@Slf4j
@Service
@RequiredArgsConstructor
public class OrderServiceImpl implements OrderService {
    private final OrderMapper orderMapper;
    private final UserClient userClient;

    @Override
    public Order getOrderById(Long id) {
        Order order = orderMapper.selectOrderById(id);
        User user = userClient.getUser("token",order.getUserId());
        order.setUser(user);
        return order;
    }
}

3）通过拦截器传递请求头

9. Feign的异常捕获

9.1 自定义 ErrorDecoder

在fegin-service模块中自定义ErrorDecoder，例如：

java 复制代码 
import feign.Response;
import feign.codec.ErrorDecoder;
import lombok.extern.slf4j.Slf4j;

@Slf4j
public class CustomErrorDecoder implements ErrorDecoder {
    private final ErrorDecoder defaultErrorDecoder = new Default();

    @Override
    public Exception decode(String s, Response response) {
        if (response.status() > 200) {
            log.error("请求失败");
            return new RuntimeException("请求失败");
        } else {
            return defaultErrorDecoder.decode(s, response);
        }
    }
}

将 CustomErrorDecoder配置到feign接口：

java 复制代码 
import com.zjp.common.entity.User;
import com.zjp.feginservice.client.decoder.CustomErrorDecoder;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

@FeignClient(name = "user-service", configuration = CustomErrorDecoder.class)
public interface UserClient {
    @GetMapping(value = "/user/{id}")
    User getUser(@PathVariable("id") Long id);
}

注意：

  1. ErrorDecoder与fallback的执行顺序：先走ErrorDecoder拦截器，再走熔断的fallback。
  2. @FeignClient加上decode404 = true这一个参数，Feign对于2XX和404 ，都不会走Fallback了。

10. 常见报错

10.1 feign接口注入失败

  • 包扫描路径问题
  • 没有添加注册中心的依赖，无法从注册中心拉取ip地址和端口；
  • 如果是单元测试，注意junit的版本，如果是4.X的版本需要在测试类上添加@Runwith；
  • 没有做到依赖最小化，加入一些无关依赖；
  • 启动类的包名层级只有一层，如只在com包下。

10.2 feign接口调用失败

  • 检查feign接口的url地址，需要跟controller的完整的url保持一致；

  • 检查feign接口的参数，参数上的@RequestParam注解不能省略；

  • 检查接口的返回值，是否漏掉了泛型信息，如果没加分型，默认元素类型是LinkedHashMap；

  • @EnableFeignClients 注解没有指定需要扫描的包/类；

  • 更新代码却未重启服务；

  • 其他情况需要开启feign日志，逐步排查。

相关推荐
都叫我大帅哥9 分钟前
🌊 Redis Stream深度探险：从秒杀系统到面试通关
java·redis
都叫我大帅哥10 分钟前
Redis持久化全解析：从健忘症患者到记忆大师的逆袭
java·redis
程序猿阿越29 分钟前
Kafka源码（一）Controller选举与创建Topic
java·后端·源码
程序无bug34 分钟前
Spring6 当中 Bean 的生命周期的详细解析：有五步，有七步，有十步
java
二川bro37 分钟前
飞算智造JavaAI：智能编程革命——AI重构Java开发新范式
java·人工智能·重构
Q_970956391 小时前
java+vue+SpringBoo校园失物招领网站（程序+数据库+报告+部署教程+答辩指导）
java·数据库·vue.js
Wyc724091 小时前
Maven
java·数据库·maven
程序猿小D1 小时前
[附源码+数据库+毕业论文]基于Spring+MyBatis+MySQL+Maven+jsp实现的电影小说网站管理系统，推荐！
java·数据库·mysql·spring·毕业设计·ssm框架·电影小说网站
vim怎么退出1 小时前
万字长文带你了解微前端架构
前端·微服务·前端框架
热门推荐
012024年 最新 iPhone手机 历代机型、屏幕尺寸、纵横比、分辨率 整理02Coze实战第13讲：飞书多维表格读取+豆包生图模型，轻松批量生成短剧封面03Coze扣子平台完整体验和实践（附国内和国际版对比）04Word粘贴时出现“运行时错误53,文件未找到：MathPage.WLL“的解决方案05手机电脑之间快速传输图片视频文件，不压缩画质、不限制大小的方法！06扣子（coze）实战|我用扣子搭建了一个自动分析小红薯笔记内容的AI应用|详细步骤拆解07MIUI显示/隐藏5G开关的方法，信号弱时开启手机Wifi通话方法08华为昇腾 910B 部署 DeepSeek-R1 蒸馏系列模型详细指南09DeepSeek各版本说明与优缺点分析10django中用 InforSuite RDS 替代memcache