SpringCloud 服务调用 spring-cloud-starter-openfeign

mqiqe2024-06-06 18:03

spring-cloud-starter-openfeign 是 Spring Cloud 中的一个组件，用于在微服务架构中声明式地调用其他服务。它基于 Netflix 的 Feign 客户端进行了封装和增强，使其与 Spring Cloud 生态更好地集成。

1. Feign

Feign 是一个声明式的 Web Service 客户端，它使得编写 Web Service 客户端变得更加简单。只需要创建一个接口并用注解来配置它（例如，使用 @GetMapping、@PostMapping 等），Feign 就会处理 HTTP 请求的发送和接收，并映射到相应的 Java 方法上。

2. 特点

  1. 声明式调用：只需定义一个接口，并使用注解来指定请求方法、路径、参数等，Spring Cloud 就会为生成 HTTP 请求的客户端。
  2. 负载均衡：当使用 Spring Cloud 的服务发现（如 Eureka）时，Feign 客户端会自动从服务注册中心获取服务列表，并使用负载均衡算法（如 Ribbon）来选择一个服务实例进行调用。
  3. 容错处理：Feign 支持多种容错策略，例如 Hystrix（已过时，但在某些版本中仍然可用）或 Resilience4j（新的容错库）。
  4. 编码与解码：Feign 支持多种编码和解码方式，包括 JSON、XML 等。
  5. 日志记录：可以配置 Feign 的日志级别来记录请求的详细信息，这有助于调试和排查问题。
  6. 请求拦截：Feign 支持请求拦截器，可以在发送请求前对请求进行额外的处理（例如，添加请求头、请求参数等）。
  7. 与 Spring Cloud 深度集成：作为 Spring Cloud 的一个组件，spring-cloud-starter-openfeign 与 Spring Cloud 的其他组件（如服务发现、配置中心等）深度集成，使得使用更加便捷。

3. 使用

要在 Spring Cloud 项目中使用 spring-cloud-starter-openfeign，需要将其添加到 Maven 或 Gradle 依赖中，并在主应用类或配置类上添加 @EnableFeignClients 注解来启用 Feign 客户端。然后，可以定义一个接口作为 Feign 客户端，并使用 @FeignClient 注解来指定要调用的服务名称和其他配置。
示例：

java 复制代码 
// 添加 Maven 依赖（以 Maven 为例）  
<dependency>  
    <groupId>org.springframework.cloud</groupId>  
    <artifactId>spring-cloud-starter-openfeign</artifactId>  
</dependency>  
  
// 在主应用类或配置类上添加 @EnableFeignClients 注解  
@SpringBootApplication  
@EnableFeignClients  
public class MyApplication {  
    public static void main(String[] args) {  
        SpringApplication.run(MyApplication.class, args);  
    }  
}  
// 定义一个 Feign 客户端接口  
@FeignClient(name = "other-service")  
public interface OtherServiceClient {  
    @GetMapping("/some-endpoint")  
    String getSomething();  
}  
// 在服务中注入并使用 Feign 客户端  
@Service  
public class MyService {  
    private final OtherServiceClient otherServiceClient;  
    @Autowired  
    public MyService(OtherServiceClient otherServiceClient) {  
        this.otherServiceClient = otherServiceClient;  
    }  
    public void doSomething() {  
        String result = otherServiceClient.getSomething();  
        // 处理结果...  
    }  
}

4. 注解

  1. @EnableFeignClients: 用于在 Spring Boot 应用中启用 Feign 客户端。可以将此注解添加到主应用类或配置类上。
java 复制代码 
@SpringBootApplication  
@EnableFeignClients  
public class MyApplication {  
    public static void main(String[] args) {  
        SpringApplication.run(MyApplication.class, args);  
    }  
}
  1. @FeignClient: 用于标记一个接口为 Feign 客户端，该注解可以定义一些属性，如服务的名称（name 或 value），配置类（configuration），URL（如果服务地址是固定的，可以直接指定 url），降级处理类（fallback）等。
java 复制代码 
@FeignClient(name = "user-service")  
public interface UserClient {  
    //...  
}
  1. HTTP 方法注解：Feign 支持 Spring MVC 的 HTTP 方法注解，例如 @GetMapping, @PostMapping, @PutMapping, @DeleteMapping, @PatchMapping 等。这些注解用于指定请求的类型和路径。
java 复制代码 
@FeignClient(name = "user-service")  
public interface UserClient {  
    @GetMapping("/users/{id}")  
    User getUser(@PathVariable("id") Long id);  
}
  1. @PathVariable, @RequestParam, @RequestHeader, @RequestBody 等：这些注解用于映射请求参数、请求头和请求体到方法参数上。
java 复制代码 
@FeignClient(name = "user-service")  
public interface UserClient {  
    @GetMapping("/users")  
    List<User> getUsers(@RequestParam("page") int page, @RequestParam("size") int size);  
}
  1. @RequestMapping: 当需要在同一个接口中定义多个相似的请求路径时，可以使用 @RequestMapping 注解来指定一个公共的路径前缀。
java 复制代码 
@FeignClient(name = "user-service")  
@RequestMapping("/api/users")  
public interface UserClient {  
    @GetMapping("/{id}")  
    User getUser(@PathVariable("id") Long id);  
      
    @PostMapping("/")  
    User createUser(@RequestBody User user);  
}
  1. 自定义配置：如果需要自定义 Feign 客户端的配置，例如设置请求和响应的编码器、解码器、日志级别等，可以创建一个配置类，并使用 @Configuration 注解标记它，然后在 @FeignClient 注解的 configuration 属性中引用这个配置类。
java 复制代码 
@Configuration  
public class FeignConfig {  
    // 自定义配置...  
}  
  
@FeignClient(name = "user-service", configuration = FeignConfig.class)  
public interface UserClient {  
    //...  
}

5. 负载均衡

spring-cloud-starter-openfeign 结合了 Spring Cloud LoadBalancer（在早期版本中，可能是 Ribbon），为 Feign 客户端提供了负载均衡的功能。当使用 @FeignClient 注解定义一个 Feign 客户端时，Spring Cloud 会自动为这个客户端配置负载均衡。

负载均衡工作流程：

  1. 服务发现：首先，Spring Cloud 应用需要集成服务发现组件（如 Eureka、Consul 或其他支持的服务发现工具）。这样，应用就能够从服务注册中心获取可用服务实例的列表。
  2. 负载均衡器：Spring Cloud LoadBalancer 或 Ribbon 会从服务注册中心获取到的服务实例列表中，根据负载均衡策略（如轮询、随机等）选择一个实例。
  3. Feign 客户端：当通过 Feign 客户端发起请求时，负载均衡器会拦截这个请求，并根据其负载均衡策略选择一个目标服务实例。然后，Feign 客户端会将请求发送到选定的服务实例。
  4. 请求发送：一旦选定了服务实例，Feign 客户端就会构造完整的 HTTP 请求（包括正确的 URL、HTTP 方法和请求体等），并将其发送到该服务实例。
  5. 响应处理：服务实例处理请求后返回响应，Feign 客户端会解析这个响应并将其转换为期望的 Java 对象。

6. 容错处理

1. Sentinel

Sentinel是一个面向分布式系统的流量控制、熔断降级和系统自适应保护组件，可以很好地与OpenFeign集成，提供强大的容错能力。

OpenFeign结合Sentinel进行容错:

  1. 引入依赖：
  • 在Spring Boot项目中，需要同时引入spring-cloud-starter-openfeign和spring-cloud-starter-alibaba-sentinel这两个依赖。
  1. 配置Sentinel支持：
  • 在服务消费者的配置文件中，需要开启Feign对Sentinel的支持。通常是通过在配置文件中设置feign.sentinel.enabled=true来完成的。
  1. 定义容错类：
  • Sentinel提供了两种实现容错处理的方案。一种是直接继承被容错的接口并为每个方法实现容错逻辑，但这种方式不够灵活，且不易于维护。另一种是推荐使用的方式，即实现FallbackFactory接口。这种方式允许在容错工厂类中获取到具体的异常信息，从而可以根据不同的异常类型进行不同的容错处理。
  • 实现FallbackFactory接口的示例代码可能如下：
java 复制代码 
@Component  
public class YourServiceFallbackFactory implements FallbackFactory<YourServiceClient> {  
    @Override  
    public YourServiceClient create(Throwable cause) {  
        return new YourServiceClient() {  
            // 在这里实现容错逻辑  
            // 可以根据cause参数获取到具体的异常信息  
            @Override  
            public SomeResponse yourMethod() {  
                // 返回一个默认响应或错误信息  
                return new SomeResponse("Service is down, please try again later.");  
            }  
            // ...其他方法...  
        };  
    }  
}
  1. 指定容错类：
  • 在Feign客户端接口上，使用@FeignClient注解的fallbackFactory属性来指定容错类。这样，当远程服务调用失败时，OpenFeign会自动调用指定的容错类中的方法。
  • 示例配置如下：
java 复制代码 
@FeignClient(name = "your-service", fallbackFactory = YourServiceFallbackFactory.class)  
public interface YourServiceClient {  
    // 定义远程服务调用方法  
}
  1. Sentinel规则配置：
  • Sentinel提供了丰富的规则配置，包括流量控制、熔断降级、系统保护等。可以通过Sentinel的控制台动态配置这些规则，也可以将规则持久化到数据库或配置文件中。
  1. 监控和告警：
  • Sentinel还提供了强大的监控和告警功能，可以帮助实时了解系统的运行状态和性能瓶颈，及时发现潜在问题并进行处理。

2. FallbackFactory

FallbackFactory接口来处理Feign客户端的容错逻辑。当远程服务调用失败或发生异常时，Feign客户端会调用FallbackFactory来返回一个实现了相同接口的降级实例，从而可以执行一些降级逻辑。

FallbackFactory进行容错处理:

  1. 引入依赖：
    确保项目中已经包含了spring-cloud-starter-openfeign依赖。
  2. 定义服务接口：
    首先，定义一个Feign客户端接口，这个接口会声明需要调用的远程服务的方法。
java 复制代码 
@FeignClient(name = "your-service", fallbackFactory = YourServiceFallbackFactory.class)  
public interface YourServiceClient {  
  
    // 定义远程服务调用的方法  
    String doSomething(String param);  
}
  1. 实现FallbackFactory：
    创建一个实现了FallbackFactory接口的类，并为Feign客户端接口创建一个实现该接口的匿名内部类。在这个类中，可以根据传入的异常类型来执行不同的降级逻辑。
java 复制代码 
@Component  
public class YourServiceFallbackFactory implements FallbackFactory<YourServiceClient> {  
  
    @Override  
    public YourServiceClient create(Throwable cause) {  
        return new YourServiceClient() {  
            @Override  
            public String doSomething(String param) {  
                // 在这里处理降级逻辑  
                // 可以根据cause参数获取异常信息  
                // 例如，可以返回一个默认值、错误消息或执行一些备用逻辑  
                return "Error occurred, fallback response";  
            }  
  
            // 如果YourServiceClient接口还有其他方法，也需要在这里实现相应的降级逻辑  
        };  
    }  
}

注意，在这个例子中，为doSomething方法提供了一个简单的降级逻辑，它总是返回一个固定的错误消息字符串。可以根据需要扩展这个逻辑，例如记录日志、发送告警通知等。

  1. 使用Feign客户端：
    可以在服务中注入YourServiceClient，并像使用普通的Spring Bean一样使用它。当远程服务调用失败时，Feign会自动调用提供的FallbackFactory来执行降级逻辑。
java 复制代码 
@Service  
public class SomeService {  
  
    private final YourServiceClient yourServiceClient;  
  
    @Autowired  
    public SomeService(YourServiceClient yourServiceClient) {  
        this.yourServiceClient = yourServiceClient;  
    }  
  
    public void doSomethingWithService(String param) {  
        String result = yourServiceClient.doSomething(param);  
        // 处理result...  
    }  
}

7. 编码与解码

使用spring-cloud-starter-openfeign进行服务间通信时，请求和响应的编码与解码是一个重要的环节。OpenFeign默认使用Spring的HttpMessageConverter来处理HTTP消息的编码和解码，这通常包括JSON、XML等格式的序列化和反序列化。
OpenFeign编码与解码:

  1. 默认的编码与解码
  • 请求编码： 当通过OpenFeign客户端发送请求时，请求体（如果有的话）会被序列化为HTTP消息体。默认情况下，Spring Boot会使用MappingJackson2HttpMessageConverter（如果添加了Jackson依赖）来将Java对象转换为JSON字符串。
  • 响应解码： 当OpenFeign客户端收到响应时，HTTP响应体会被反序列化为Java对象。同样地，默认情况下会使用MappingJackson2HttpMessageConverter（或其他配置的HttpMessageConverter）来将JSON字符串转换为Java对象。
  1. 自定义编码与解码
  • 注册自定义的HttpMessageConverter： 可以通过配置Spring Boot来注册自定义的HttpMessageConverter。这可以通过添加Bean定义到Spring上下文中来实现。
  • 使用Encoder和Decoder： OpenFeign还提供了Encoder和Decoder接口，允许更细粒度地控制编码和解码过程。可以实现这些接口，并在创建Feign.Builder时将它们作为参数传递。但是，在Spring Cloud OpenFeign中，通常推荐通过配置HttpMessageConverter来实现自定义编码与解码。
  1. JSON
    想要使用Jackson以外的库（如Gson）进行JSON编码与解码，可以：
  • 添加Gson依赖到项目中。
  • 配置Spring Boot以使用Gson的HttpMessageConverter。

注意，Spring Boot默认使用Jackson，并且如果同时添加了Jackson和Gson的依赖，可能会出现冲突。在这种情况下，可能需要排除Jackson的依赖或配置Spring Boot以优先使用Gson。

  1. XML
  • 添加相应的依赖（如JAXB、Simple XML等）。
  • 注册相应的HttpMessageConverter（如Jaxb2RootElementHttpMessageConverter、SimpleXmlHttpMessageConverter等）。

8. 日志记录

  1. 日志级别配置
    OpenFeign的日志级别可以通过配置文件（如application.yml或application.properties）进行设置。OpenFeign支持多个日志级别，包括：
  • NONE：不记录任何日志。
  • BASIC：仅记录请求方法、URL以及响应状态码和执行时间。
  • HEADERS：记录BASIC级别的信息以及请求和响应头。
  • FULL：记录请求和响应的详细信息，包括请求头、请求体、响应头、响应体等。
    示例（application.yml）:
yaml 复制代码 
feign:  
  client:  
    config:  
      default: # 也可以指定具体的服务名，如serviceName  
        loggerLevel: FULL # 设置日志级别为FULL
  1. 日志实现配置
    OpenFeign内部使用了SLF4J作为日志门面，但实际的日志实现（如Logback、Log4j等）需要由应用开发者提供。因此，需要确保项目中包含了合适的日志实现依赖，并正确配置了日志实现。
    示例（Logback配置，logback.xml）:
xml 复制代码 
<configuration>  
  <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">  
    <encoder>  
      <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>  
    </encoder>  
  </appender>  
    
  <logger name="org.springframework.cloud.openfeign" level="DEBUG" /> <!-- 可以根据需要调整这个级别 -->  
  <root level="INFO">  
    <appender-ref ref="STDOUT" />  
  </root>  
</configuration>
  1. 日志输出内容
    当将日志级别设置为FULL时，OpenFeign会记录请求和响应的详细信息。这包括：
  • 请求方法（如GET、POST等）。
  • 请求URL。
  • 请求头。
  • 请求体（对于POST或PUT请求）。
  • 响应状态码。
  • 响应头。
  • 响应体（如果可用）。

9. 请求拦截处理

使用spring-cloud-starter-openfeign时，如果想要拦截Feign客户端的请求，可以通过实现Feign的RequestInterceptor接口来定制请求拦截逻辑。这个接口提供了一个apply方法，该方法在发送请求之前会被调用，允许修改请求。
示例：

  1. 创建自定义的RequestInterceptor
    首先，需要创建一个类并实现RequestInterceptor接口。在这个类中，可以修改请求，比如添加请求头、请求参数等。
java 复制代码 
import feign.Request;  
import feign.RequestInterceptor;  
import feign.RequestTemplate;  
  
public class CustomRequestInterceptor implements RequestInterceptor {  
  
    @Override  
    public void apply(RequestTemplate template) {  
        // 在这里添加拦截逻辑  
        // 例如，为所有请求添加一个自定义的头部  
        template.header("Custom-Header", "CustomValue");  
    }  
}
  1. 配置Feign客户端以使用自定义的RequestInterceptor
    然后，需要在Spring Boot配置中注册这个拦截器，并告诉Feign客户端使用它。这可以通过在配置类中使用@Bean注解来实现。
java 复制代码 
import org.springframework.context.annotation.Bean;  
import org.springframework.context.annotation.Configuration;  
 
@Configuration  
public class FeignConfig {  
 
   @Bean  
   public CustomRequestInterceptor customRequestInterceptor() {  
       return new CustomRequestInterceptor();  
   }  
 
   // 如果想要为特定的Feign客户端配置拦截器，可以使用Feign.Builder  
   // 并使用它的requestInterceptor()方法添加拦截器  
   // 然后使用@FeignClient的configuration属性来引用这个配置类  
}

如果想要为特定的Feign客户端配置拦截器，可以创建一个配置类，并在该类中定义拦截器。然后，在@FeignClient注解的configuration属性中引用这个配置类。

java 复制代码 
import org.springframework.cloud.openfeign.EnableFeignClients;  
import org.springframework.context.annotation.Configuration;  
  
@Configuration  
@EnableFeignClients(defaultConfiguration = FeignConfig.class) // 为所有Feign客户端设置默认配置  
public class FeignClientConfig {  
    // 其他配置...  
}  
  
// 或者，只为特定的Feign客户端设置配置  
@FeignClient(name = "some-service", configuration = CustomFeignConfig.class)  
public interface SomeServiceClient {  
    // 定义方法...  
}  
  
@Configuration  
public class CustomFeignConfig {  
    @Bean  
    public CustomRequestInterceptor customRequestInterceptor() {  
        return new CustomRequestInterceptor();  
    }  
}

10. 使用

在分布式微服务架构中，每个微服务对外的api，通常会独立拆分成一个module API单独对外提供该微服务的api，在使用该微服务的api时，只要因为openfeign封装的api jar即可。
原则：

  • 引入maven包尽量简洁。
  • 接口描述同api源接口描述。
  • 微服务之间调用注意公共参数补充：header补充的用户、组织信息。

开发环境微服务网络访问问题，若微服务之间有网络隔离，例如k8s微服务之间调用是namespace 的overlay网络，而服务发现获取到的是overlay网络，处理方案：

1、在网关处做逻辑处理。

2、临时指定服务访问URL：

通过配置文件指定URL

通过@FeignClient注解指定URL

DEMO架构

相关推荐
YaHuiLiang4 分钟前
小微互联网公司与互联网创业公司 -- 学历之殇
前端·后端·面试
冬天的风滚草8 分钟前
Higress开源版 大规模 MCP Server 部署配置方案
后端
雨落倾城夏未凉8 分钟前
4.信号与槽
后端·qt
考虑考虑1 小时前
JDK9中的dropWhile
java·后端·java ee
hqxstudying2 小时前
java依赖注入方法
java·spring·log4j·ioc·依赖
春生野草2 小时前
关于SpringMVC的整理
spring
martinzh3 小时前
Spring AI 项目介绍
后端
Bug退退退1233 小时前
RabbitMQ 高级特性之重试机制
java·分布式·spring·rabbitmq
前端付豪3 小时前
20、用 Python + API 打造终端天气预报工具（支持城市查询、天气图标、美化输出🧊
后端·python
爱学习的小学渣3 小时前
关系型数据库
后端
热门推荐
01集群聊天服务器---MySQL数据库的建立02GPU 进阶笔记（二）：华为昇腾 910B GPU03Coze扣子平台完整体验和实践（附国内和国际版对比）04使用Ruby接入实时行情API教程05Word粘贴时出现“运行时错误53,文件未找到：MathPage.WLL“的解决方案06扣子（coze）实战|我用扣子搭建了一个自动分析小红薯笔记内容的AI应用|详细步骤拆解07Java学习第十五部分——MyBatis08扣子空间的使用教程与大模型技术思考09DeepSeek各版本说明与优缺点分析10基于odoo17的设计模式详解---装饰模式