OpenFeign深入学习笔记

于 2024-09-03 14:33:23 发布
阅读量168 收藏 11
点赞数 7
文章标签： 学习 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CXY123654654321/article/details/141861071
版权

OpenFeign 是一个声明式的 Web 服务客户端，它使得编写 Web 服务客户端变得更加容易。OpenFeign 是在 Spring Cloud 生态系统中的一个组件，它整合了 Ribbon（客户端负载均衡器）和 Eureka（服务发现组件），从而简化了微服务之间的调用。

在 SpringCloud 应用中，我们经常会 使用 OpenFeign，比如通过定义一个接口并使用注解的方式来创建一个 Web 服务客户端，而不需要编写大量的模板代码。OpenFeign 会自动生成接口的实现类，并使用 Ribbon 来调用相应的服务。

我们先来上手用一下，在 Spring Cloud 项目中使用 OpenFeign：

需求：我们的业务场景是这样的：一个电子商务平台，其中包含一个商品服务（product-service）和一个订单服务（order-service）。我们要使用 OpenFeign 来实现订单服务调用商品服务的接口。

步骤1：创建商品服务（product-service）

  1. 添加依赖（pom.xml）：
 

xml
 

代码解读
 

复制代码
 

<dependencies> <!-- Spring Boot Web 依赖 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <!-- Spring Boot Actuator 依赖 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-actuator</artifactId> </dependency> </dependencies> 
 

  1. 主应用类（ProductApplication.java）：
 

 

java
 

代码解读
 

复制代码
 

import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication public class ProductApplication { public static void main(String[] args) { SpringApplication.run(ProductApplication.class, args); } } 
 

  1. 商品控制器（ProductController.java）：
 

 

java
 

代码解读
 

复制代码
 

import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RestController; @RestController public class ProductController { @GetMapping("/products/{id}") public String getProduct(@PathVariable("id") Long id) { // 模拟数据库中获取商品信息 return "Product with ID: " + id; } } 
 

步骤2：创建订单服务（order-service）
 

  1. 添加依赖（pom.xml）：
 

 

xml
 

代码解读
 

复制代码
 

<dependencies> <!-- Spring Boot Web 依赖 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <!-- Spring Cloud OpenFeign 依赖 --> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-openfeign</artifactId> </dependency> </dependencies> 
 

  1. 主应用类（OrderApplication.java）：
 

 

java
 

代码解读
 

复制代码
 

import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.cloud.openfeign.EnableFeignClients; @SpringBootApplication @EnableFeignClients public class OrderApplication { public static void main(String[] args) { SpringApplication.run(OrderApplication.class, args); } } 
 

  1. Feign 客户端接口（ProductClient.java）：
 

 

java
 

代码解读
 

复制代码
 

import org.springframework.cloud.openfeign.FeignClient; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; @FeignClient(name = "product-service", url = "http://localhost:8081") public interface ProductClient { @GetMapping("/products/{id}") String getProduct(@PathVariable("id") Long id); } 
 

  1. 订单控制器（OrderController.java）：
 

 
 
整理了一份核心面试笔记包括了：Java面试、Spring、JVM、MyBatis、Redis、MySQL、并发编程、微服务、Linux、Springboot、SpringCloud、MQ、Kafka 面试专题
 
 
需要全套面试笔记的【点击此处即可】即可免费获取
 

 

java
 

代码解读
 

复制代码
 

import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RestController; @RestController public class OrderController { private final ProductClient productClient; @Autowired public OrderController(ProductClient productClient) { this.productClient = productClient; } @GetMapping("/orders/{id}/product") public String getOrderProduct(@PathVariable("id") Long id) { // 调用商品服务获取商品信息 return productClient.getProduct(id); } } 
 

步骤3：运行和测试
 

  1.  
    启动商品服务（ProductApplication）：
     
  
    • 运行 ProductApplication 的 main 方法。
  2.  
    启动订单服务（OrderApplication）：
     
  
    • 运行 OrderApplication 的 main 方法。
  3.  
    测试调用：
     
  
    • 使用浏览器或 Postman 访问 http://localhost:8082/orders/1/product，我们就能看到商品服务返回的商品信息。
 

以上是OpenFeign的基本使用，作为优秀的程序员，我们必须要去深入了解OpenFeign核心组件背后的实现，知己知彼，方能百战不殆。下面我们来一起看下 OpenFeign 的一些核心组件及其源码分析：
 

OpenFeign 的核心组件有哪些？
 

OpenFeign 是 Spring Cloud 生态系统中的一个声明式 Web 服务客户端，用于简化微服务之间的 HTTP 调用。
 

1. Encoder：
 

在 OpenFeign 中，Encoder 组件负责将请求数据序列化成可以发送的格式。默认情况下，OpenFeign 只支持将请求数据序列化为字符串或字节数组。如果需要支持更复杂的对象序列化，可以通过实现自定义的 Encoder 来实现。
 

我们来分析一下 Encoder 组件的源码实现：
 

步骤1：定义 Encoder 接口
 

首先，Feign定义了一个 Encoder 接口，该接口包含一个 encode 方法，用于将对象序列化为字节数组：
 

 

java
 

代码解读
 

复制代码
 

public interface Encoder { void encode(Object object, Type bodyType, RequestTemplate template) throws EncodeException; } 
 

  • object：要序列化的对象。
  • bodyType：对象的类型信息，通常用于确定如何序列化对象。
  • template：RequestTemplate 对象，用于设置请求的主体（body）。
 

步骤2：实现默认 Encoder
 

OpenFeign 提供了一个默认的 Encoder 实现，通常使用 Jackson 或其他 JSON 库来序列化对象为 JSON 格式：
 

 

java
 

代码解读
 

复制代码
 

public class JacksonEncoder extends SpringEncoder implements Encoder { public JacksonEncoder(ObjectFactory objectFactory) { super(objectFactory); } @Override public void encode(Object object, Type bodyType, RequestTemplate template) throws EncodeException { // 将对象序列化为 JSON 格式，并设置到 RequestTemplate 中 byte[] body = this.objectFactory.createInstance(bodyType).writeValueAsBytes(object); template.body(body); template.requestBody(Request.Body.create(body, ContentType.APPLICATION_JSON)); } } 
 

在这个实现中，JacksonEncoder 使用 Jackson 库将对象序列化为 JSON，并设置请求的内容类型为 APPLICATION_JSON。
 

步骤3：自定义 Encoder 实现
 

如果我们需要支持其他类型的序列化，可以创建自定义的 Encoder 实现。例如，如果要支持 XML 序列化，可以创建一个使用 JAXB 或其他 XML 库的 Encoder：
 

 

java
 

代码解读
 

复制代码
 

public class XmlEncoder implements Encoder { @Override public void encode(Object object, Type bodyType, RequestTemplate template) throws EncodeException { // 使用 XML 库将对象序列化为 XML 格式 String xml = serializeToXml(object); template.body(xml, ContentType.APPLICATION_XML); } private String serializeToXml(Object object) { // 实现对象到 XML 的序列化逻辑 // ... return xml; } } 
 

步骤4：配置 OpenFeign 客户端使用自定义 Encoder
 

在 Feign 客户端配置中，可以指定自定义的 Encoder 实现：
 

 

java
 

代码解读
 

复制代码
 

@Configuration public class FeignConfig { @Bean public Encoder encoder() { return new XmlEncoder(); } } 
 

然后在 @FeignClient 注解中指定配置类：
 

 

java
 

代码解读
 

复制代码
 

@FeignClient(name = "myClient", configuration = FeignConfig.class) public interface MyClient { // ... } 
 

小结一下
 

Encoder 接口，为请求数据的序列化提供了一个扩展点。OpenFeign 提供了默认的 JacksonEncoder 实现，它使用 Jackson 库来序列化对象为 JSON 格式。如果想实现自定义的 Encoder，来支持其他数据格式，如 XML、Protobuf 等也是非常方便灵活的。
 

2. Decoder：
 

OpenFeign 的Decoder 组件负责将HTTP响应体（通常是字节流）反序列化为Java对象。默认情况下，OpenFeign支持将响应体反序列化为字符串或字节数组。如果需要支持更复杂的对象反序列化，可以通过实现自定义的 Decoder 来实现。
 

下面来分析 Decoder 组件的源码实现：
 

步骤1：定义 Decoder 接口
 

OpenFeign 定义了一个 Decoder 接口，该接口包含一个 decode 方法，用于将响应体反序列化为对象：
 

 

java
 

代码解读
 

复制代码
 

public interface Decoder { <T> T decode(Response response, Type type) throws IOException, DecodeException; } 
 

  • T：要反序列化成的对象类型。
  • response：Feign的 Response 对象，包含了HTTP响应的所有信息。
  • type：要反序列化成的对象的类型信息。
 

步骤2：实现默认 Decoder
 

OpenFeign 提供了一个默认的 Decoder 实现，通常使用 Jackson 或其他 JSON 库来反序列化JSON响应体：
 

 

java
 

代码解读
 

复制代码
 

public class JacksonDecoder extends SpringDecoder implements Decoder { public JacksonDecoder(ObjectFactory objectFactory) { super(objectFactory); } @Override public <T> T decode(Response response, Type type) throws IOException, DecodeException { // 从响应中获取字节流 InputStream inputStream = response.body().asInputStream(); // 使用 Jackson 库将字节流反序列化为 Java 对象 return this.objectFactory.createInstance(type).readValue(inputStream, type); } } 
 

在这个实现中，JacksonDecoder 使用 Jackson 库将响应体的字节流反序列化为 Java 对象，并根据响应的状态码抛出相应的异常或返回对象。
 

步骤3：自定义 Decoder 实现
 

如果咱们需要支持其他类型的反序列化，可以创建自定义的 Decoder 实现。比如要支持 XML 反序列化，可以创建一个使用 JAXB 或其他 XML 库的 Decoder：
 

 

java
 

代码解读
 

复制代码
 

public class XmlDecoder implements Decoder { @Override public <T> T decode(Response response, Type type) throws IOException, DecodeException { // 从响应中获取字节流 InputStream inputStream = response.body().asInputStream(); // 使用 XML 库将字节流反序列化为 Java 对象 T object = deserializeFromXml(inputStream, type); return object; } private <T> T deserializeFromXml(InputStream inputStream, Type type) { // 实现 XML 到 Java 对象的反序列化逻辑 // ... return null; } } 
 

步骤4：配置 OpenFeign 客户端使用自定义 Decoder
 

在 Feign 客户端配置中，可以指定自定义的 Decoder 实现：
 

 

java
 

代码解读
 

复制代码
 

@Configuration public class FeignConfig { @Bean public Decoder decoder() { return new XmlDecoder(); } } 
 

然后在 @FeignClient 注解中指定配置类：
 

 

java
 

代码解读
 

复制代码
 

@FeignClient(name = "myClient", configuration = FeignConfig.class) public interface MyClient { // ... } 
 

小结一下
 

OpenFeign 提供了默认的 JacksonDecoder 实现，它使用 Jackson 库来反序列化 JSON 格式的响应体。咱们还可以通过实现自定义的 Decoder，可以支持其他数据格式，如 XML等。开发中，咱们可以根据需要选择或实现适合自己业务场景的反序列化方式。
 

3. Contract：
 

OpenFeign的Contract 组件负责将接口的方法和注解转换为HTTP请求。它定义了如何将Java接口映射到HTTP请求上，包括请求的URL、HTTP方法、请求头、查询参数和请求体等。Contract 组件是Feign中非常核心的部分，因为它决定了Feign客户端如何理解和构建HTTP请求。
 

步骤1：定义 Contract 接口
 

Feign定义了一个 Contract 接口，该接口包含两个主要的方法：
 

 

java
 

代码解读
 

复制代码
 

public interface Contract { List<MethodMetadata> parseAndValidatteMethods(FeignTarget<?> target); RequestTemplate create(Request request, Target<?> target, Method method, Object... argv); } 
 

  • parseAndValidatteMethods：解析并验证目标接口的方法，生成 MethodMetadata 列表，每个 MethodMetadata 包含一个方法的所有元数据。
  • create：根据 Request 和 Target 创建 RequestTemplate，用于构建实际的HTTP请求。
 

步骤2：实现默认 Contract
 

Feign提供了一个默认的 Contract 实现，通常使用Java的反射API来解析接口的方法和注解：
 

 

java
 

代码解读
 

复制代码
 

public class FeignContract implements Contract { @Override public List<MethodMetadata> parseAndValidateMethods(FeignTarget<?> target) { // 解析目标接口的方法，生成 MethodMetadata 列表 // ... } @Override public RequestTemplate create(Request request, Target<?> target, Method method, Object... argv) { // 根据 MethodMetadata 和参数创建 RequestTemplate // ... } } 
 

在实现中咱们可以看到，FeignContract 会检查接口方法上的注解（如 @GetMapping、@PostMapping 等），并根据这些注解构建HTTP请求。
 

步骤3：自定义 Contract 实现
 

同样的道理，如果需要支持自定义的注解或扩展Feign的功能，可以通过实现自定义的 Contract 来实现：
 

 

java
 

代码解读
 

复制代码
 

public class MyCustomContract implements Contract { @Override public List<MethodMetadata> parseAndValidateMethods(FeignTarget<?> target) { // 自定义解析逻辑 // ... } @Override public RequestTemplate create(Request request, Target<?> target, Method method, Object... argv) { // 自定义创建 RequestTemplate 的逻辑 // ... } } 
 

步骤4：配置 OpenFeign 客户端使用自定义 Contract
 

在Feign客户端配置中，可以指定自定义的 Contract 实现：
 

 

java
 

代码解读
 

复制代码
 

@Configuration public class FeignConfig { @Bean public Contract contract() { return new MyCustomContract(); } } 
 

然后在 @FeignClient 注解中指定配置类：
 

 

java
 

代码解读
 

复制代码
 

@FeignClient(name = "myClient", configuration = FeignConfig.class) public interface MyClient { // ... } 
 

小结一下
 

OpenFeign 提供了默认的 FeignContract 实现，它使用Java的反射API来解析接口的方法和注解，并生成 MethodMetadata。这种方式允许Feign自动处理标准的JAX-RS注解。咱们可以通过实现自定义的 Contract，可以支持自定义注解或改变Feign的请求构建逻辑。
 

4. Client：
 

Client 组件是负责发送HTTP请求并接收HTTP响应的核心组件。OpenFeign 默认使用Java标准库中的HttpURLConnection来发送请求，但也支持使用其他HTTP客户端库，如Apache HttpClient或OkHttp。
 

步骤1：定义 Client 接口
 

OpenFeign中定义了一个Client接口，该接口包含一个execute方法，用于执行HTTP请求：
 

 

java
 

代码解读
 

复制代码
 

public interface Client { Response execute(Request request, Request.Options options) throws IOException; } 
 

  • Request：代表要执行的HTTP请求。
  • Request.Options：包含请求的配置选项，如连接超时和读取超时。
  • Response：代表HTTP响应。
 

步骤2：实现默认 Client
 

OpenFeign 提供了一个默认的Client实现，使用Java的HttpURLConnection：
 

 

java
 

代码解读
 

复制代码
 

public class HttpURLConnectionClient implements Client { @Override public Response execute(Request request, Request.Options options) throws IOException { // 创建和配置 HttpURLConnection URL url = new URL(request.url()); HttpURLConnection connection = (HttpURLConnection) url.openConnection(); // 设置请求方法、头信息、超时等 // ... // 发送请求并获取响应 // ... return response; } } 
 

在这个实现中，HttpURLConnectionClient使用HttpURLConnection来构建和发送HTTP请求，并处理响应。
 

步骤3：自定义 Client 实现
 

如果我们需要使用其他HTTP客户端库，可以创建自定义的Client实现。例如，使用Apache HttpClient：
 

 

java
 

代码解读
 

复制代码
 

public class HttpClientClient implements Client { private final CloseableHttpClient httpClient; public HttpClientClient(CloseableHttpClient httpClient) { this.httpClient = httpClient; } @Override public Response execute(Request request, Request.Options options) throws IOException { // 使用 Apache HttpClient 构建和发送HTTP请求 // ... return response; } } 
 

步骤4：配置 Feign 客户端使用自定义 Client
 

在Feign配置中，可以指定自定义的Client实现：
 

 

java
 

代码解读
 

复制代码
 

@Configuration public class FeignConfig { @Bean public Client httpClientClient() { CloseableHttpClient httpClient = HttpClients.createDefault(); return new HttpClientClient(httpClient); } } 
 

然后在@FeignClient注解中指定配置类：
 

 

java
 

代码解读
 

复制代码
 

@FeignClient(name = "myClient", configuration = FeignConfig.class) public interface MyClient { // ... } 
 

小结一下
 

OpenFeign 提供了默认的HttpURLConnectionClient实现，它使用Java标准库中的HttpURLConnection来发送请求。这种方式的好处是简单且无需额外依赖。也可以通过实现自定义的Client，如Apache HttpClient或OkHttp。这让OpenFeign能够适应不同的性能和功能需求。
 

5. RequestInterceptor：
 

RequestInterceptor 是一个非常重要的组件，它允许咱们在请求发送之前对其进行拦截，从而可以添加一些通用的处理逻辑，比如设置认证头、日志记录、修改请求参数等。我们来分析一下 RequestInterceptor 组件的源码实现：
 

步骤1：定义 RequestInterceptor 接口
 

Feign定义了一个 RequestInterceptor 接口，该接口包含一个 apply 方法，用于在请求发送前对 RequestTemplate 进行操作：
 

 

java
 

代码解读
 

复制代码
 

public interface RequestInterceptor { void apply(RequestTemplate template); } 
 

  • RequestTemplate：代表即将发送的HTTP请求，可以修改URL、头信息、请求体等。
 

步骤2：实现默认 RequestInterceptor
 

OpenFeign 提供了一些默认的 RequestInterceptor 实现，例如用于设置默认头信息的 RequestInterceptor：
 

 

java
 

代码解读
 

复制代码
 

public class DefaultRequestInterceptor implements RequestInterceptor { private final Configuration configuration; public DefaultRequestInterceptor(Configuration configuration) { this.configuration = configuration; } @Override public void apply(RequestTemplate template) { // 设置默认的头信息，比如Content-Type template.header("Content-Type", configuration.getContentType().toString()); // 可以添加更多的默认处理逻辑 } } 
 

在这个实现中，DefaultRequestInterceptor 会在每个请求中设置一些默认的头信息。
 

步骤3：自定义 RequestInterceptor 实现
 

咱们可以根据需要实现自定义的 RequestInterceptor。例如，添加一个用于设置认证头的拦截器：
 

 

java
 

代码解读
 

复制代码
 

public class AuthRequestInterceptor implements RequestInterceptor { private final String authToken; public AuthRequestInterceptor(String authToken) { this.authToken = authToken; } @Override public void apply(RequestTemplate template) { // 在每个请求中添加认证头 template.header("Authorization", "Bearer " + authToken); } } 
 

步骤4：配置 OpenFeign 客户端使用自定义 RequestInterceptor
 

在 OpenFeign 配置中，可以指定自定义的 RequestInterceptor 实现：
 

 

java
 

代码解读
 

复制代码
 

@Configuration public class FeignConfig { @Bean public RequestInterceptor authRequestInterceptor() { // 假设从配置文件或环境变量中获取认证令牌 String authToken = "your-auth-token"; return new AuthRequestInterceptor(authToken); } } 
 

然后在 @FeignClient 注解中指定配置类：
 

 

java
 

代码解读
 

复制代码
 

@FeignClient(name = "myClient", configuration = FeignConfig.class) public interface MyClient { // ... } 
 

小结一下
 

RequestInterceptor让咱们在不修改每个单独请求的情况下，统一处理请求。这使得Feign客户端更加灵活和强大，能够适应各种复杂的业务需求。
 

6. Retryer：
 

Retryer 组件负责定义重试策略，它决定了在遇到特定类型的错误时是否重试请求，以及重试的次数和间隔。Retryer 是Feign中的一个重要组件，特别是在网络不稳定或服务不稳定的环境中，大派用场，它可以显著提高系统的健壮性哦。
 

步骤1：定义 Retryer 接口
 

Feign定义了一个 Retryer 接口，该接口包含几个关键的方法，用于控制重试的行为：
 

 

java
 

代码解读
 

复制代码
 

public interface Retryer { void continueOrPropagate(RetryableException e); Retryer clone(); long getDelay(RetryableException e, int attempt); boolean shouldRetry(RetryableException e, int attempt, int retry); } 
 

  • continueOrPropagate：决定是继续重试还是抛出异常。
  • clone：创建 Retryer 的副本，通常用于每个请求的独立重试策略。
  • getDelay：返回在下一次重试之前的延迟时间。
  • shouldRetry：决定是否应该重试请求。
 

步骤2：实现默认 Retryer
 

Feign提供了一个默认的 Retryer 实现，通常是一个简单的重试策略，例如：
 

 

java
 

代码解读
 

复制代码
 

public class DefaultRetryer implements Retryer { private final long period; private final long maxPeriod; private final int maxAttempts; public DefaultRetryer(long period, long maxPeriod, int maxAttempts) { this.period = period; this.maxPeriod = maxPeriod; this.maxAttempts = maxAttempts; } @Override public void continueOrPropagate(RetryableException e) { // 根据异常类型和重试次数决定是否重试 if (shouldRetry(e, e.getAttempt(), maxAttempts)) { // 继续重试 } else { // 抛出异常 throw e; } } @Override public Retryer clone() { return new DefaultRetryer(period, maxPeriod, maxAttempts); } @Override public long getDelay(RetryableException e, int attempt) { // 计算重试延迟 return Math.min(period * (long) Math.pow(2, attempt), maxPeriod); } @Override public boolean shouldRetry(RetryableException e, int attempt, int retry) { // 根据异常类型和重试次数决定是否重试 return attempt < retry; } } 
 

在这个实现中，DefaultRetryer 使用指数退避策略来计算重试延迟，并允许指定最大重试次数。
 

步骤3：自定义 Retryer 实现
 

当咱们需要更复杂的重试策略时，可以创建自定义的 Retryer 实现。例如，可以基于特定的异常类型或响应码来决定重试策略：
 

 

java
 

代码解读
 

复制代码
 

public class CustomRetryer implements Retryer { // ... 自定义重试逻辑 ... @Override public void continueOrPropagate(RetryableException e) { // 自定义重试逻辑 } @Override public Retryer clone() { return new CustomRetryer(); } @Override public long getDelay(RetryableException e, int attempt) { // 自定义延迟逻辑 return ...; } @Override public boolean shouldRetry(RetryableException e, int attempt, int retry) { // 自定义重试条件 return ...; } } 
 

步骤4：配置 Feign 客户端使用自定义 Retryer
 

在Feign配置中，可以指定自定义的 Retryer 实现：
 

 

java
 

代码解读
 

复制代码
 

@Configuration public class FeignConfig { @Bean public Retryer retryer() { return new CustomRetryer(); } } 
 

然后在 @FeignClient 注解中指定配置类：
 

 

java
 

代码解读
 

复制代码
 

@FeignClient(name = "myClient", configuration = FeignConfig.class) public interface MyClient { // ... } 
 

小结一下
 

OpenFeign 允许我们根据需要选择或实现适合自己业务场景的重试策略，从而提高系统的健壮性和可靠性。问题来了，啥是指数退避策略？
 

解释一下哈，指数退避策略（Exponential Backoff）是一种在网络通信和分布式系统中常用的重试策略，特别是在处理临时故障或网络延迟时。这种策略旨在通过增加连续重试之间的等待时间来减少系统的负载，并提高重试成功的机会。
 

指数退避策略的工作原理是这样的：当发生错误或故障时，系统首先会等待一个初始的短暂延迟，然后重试。如果第一次重试失败，等待时间会指数增长。这意味着每次重试的等待时间都是前一次的两倍（或另一个指数因子）。
 

通常会设置一个最大尝试次数，以防止无限重试。为了避免等待时间过长，会设定一个最大延迟时间，超过这个时间后，即使重试次数没有达到最大次数，也不会再增加等待时间。
 

为了减少多个客户端同时重试时的同步效应，有时会在指数退避中加入随机化因子，使得每次的等待时间在一定范围内变化。
 

7. Configuration：
 

Configuration 组件是一个关键的设置类，它允许用户自定义Feign客户端的行为。Configuration 类通常包含了一系列的设置，比如连接超时、读取超时、重试策略、编码器、解码器、契约（Contract）、日志级别等。这些设置可以应用于所有的Feign客户端，或者特定的Feign客户端。
 

步骤1：定义 Configuration 接口
 

Feign定义了一个 Configuration 接口，该接口允许用户配置Feign客户端的各种参数：
 

 

java
 

代码解读
 

复制代码
 

public interface Configuration { // 返回配置的编码器 Encoder encoder(); // 返回配置的解码器 Decoder decoder(); // 返回配置的契约 Contract contract(); // 返回配置的请求拦截器 RequestInterceptor requestInterceptor(); // 返回配置的重试策略 Retryer retryer(); // 返回配置的日志级别 Logger.Level loggerLevel(); // ... 可能还有其他配置方法 ... } 
 

步骤2：实现默认 Configuration
 

Feign提供了一个默认的 Configuration 实现，这个实现包含了Feign的默认行为：
 

 

java
 

代码解读
 

复制代码
 

public class DefaultConfiguration implements Configuration { // ... 定义默认的编码器、解码器、契约等 ... @Override public Encoder encoder() { return new JacksonEncoder(...); } @Override public Decoder decoder() { return new JacksonDecoder(...); } @Override public Contract contract() { return new SpringMvcContract(...); } // ... 实现其他配置方法 ... } 
 

在这个实现中，DefaultConfiguration 定义了Feign的默认编码器、解码器、契约等组件。
 

步骤3：自定义 Configuration 实现
 

用户可以创建自定义的 Configuration 实现，以覆盖默认的行为：
 

 

java
 

代码解读
 

复制代码
 

public class CustomConfiguration extends DefaultConfiguration { // ... 自定义特定的配置 ... @Override public Encoder encoder() { // 返回自定义的编码器 return new CustomEncoder(...); } @Override public Decoder decoder() { // 返回自定义的解码器 return new CustomDecoder(...); } // ... 可以覆盖其他配置方法 ... } 
 

步骤4：配置 Feign 客户端使用自定义 Configuration
 

在Feign配置中，可以指定自定义的 Configuration 实现：
 

 

java
 

代码解读
 

复制代码
 

@Configuration public class FeignConfig { @Bean public Configuration feignConfiguration() { return new CustomConfiguration(...); } } 
 

然后在 @FeignClient 注解中指定配置类：
 

 

java
 

代码解读
 

复制代码
 

@FeignClient(name = "myClient", configuration = FeignConfig.class) public interface MyClient { // ... } 
 

8. Target：
 

Target 组件代表了Feign客户端将要调用的远程服务的目标。它通常包含了服务的名称和可能的特定配置，例如请求的URL。Target 组件在Feign的动态代理机制中扮演着重要角色，因为它定义了如何将方法调用转换为实际的HTTP请求。
 

步骤1：定义 Target 接口
 

Feign定义了一个 Target 接口，该接口包含一些关键的方法和属性：
 

 

java
 

代码解读
 

复制代码
 

public interface Target<T> { String name(); String url(); Class<T> type(); } 
 

  • name()：返回服务的名称，通常用于服务发现。
  • url()：返回服务的URL，可以是完整的URL或者是一个模板。
  • type()：返回Feign客户端接口的类型。
 

步骤2：实现 Target 接口
 

Feign提供了 Target 接口的实现，通常是一个名为 HardCodedTarget 的类：
 

 

java
 

代码解读
 

复制代码
 

public class HardCodedTarget<T> implements Target<T> { private final String name; private final String url; private final Class<T> type; public HardCodedTarget(Class<T> type, String name, String url) { this.type = type; this.name = name; this.url = url; } @Override public String name() { return name; } @Override public String url() { return url; } @Override public Class<T> type() { return type; } } 
 

在这个实现中，HardCodedTarget 通过构造函数接收服务的名称、URL和接口类型，并提供相应的getter方法。
 

步骤3：使用 Target 组件
 

在Feign客户端接口中，可以通过 @FeignClient 注解的 value 属性指定服务名称，Feign在内部会使用 Target 来构建代理：
 

 

java
 

代码解读
 

复制代码
 

@FeignClient(value = "myService", url = "http://localhost:8080") public interface MyClient extends MyServiceApi { // 定义服务方法 } 
 

Feign会根据注解信息创建一个 HardCodedTarget 实例，并使用它来构建动态代理。
 

步骤4：动态代理和 Target
 

Feign使用Java的动态代理机制（是不是哪哪都是动态代理，所以说动态代理很重要）来创建客户端代理。在Feign的 ReflectiveFeign 类中，会使用 InvocationHandlerFactory 来创建 InvocationHandler：
 

 

java
 

代码解读
 

复制代码
 

public class ReflectiveFeign extends Feign { private final InvocationHandlerFactory invocationHandlerFactory; public ReflectiveFeign(InvocationHandlerFactory invocationHandlerFactory) { this.invocationHandlerFactory = invocationHandlerFactory; } @Override public <T> T newInstance(Target<T> target) { // 使用 InvocationHandlerFactory 创建 InvocationHandler InvocationHandler invocationHandler = invocationHandlerFactory.create(target); // 创建动态代理 return (T) Proxy.newProxyInstance(target.type().getClassLoader(), new Class<?>[]{target.type()}, invocationHandler); } } 
 

在这个过程中，InvocationHandler 会使用 Target 来构建实际的HTTP请求。
 

9. InvocationHandlerFactory：
 

InvocationHandlerFactory 组件是动态代理的核心，它负责创建 InvocationHandler，这是Java动态代理机制的关键部分。InvocationHandler 定义了代理对象在被调用时的行为。在Feign的上下文中，InvocationHandler 负责将方法调用转换为HTTP请求。
 

步骤1：定义 InvocationHandlerFactory 接口
 

Feign定义了一个 InvocationHandlerFactory 接口，该接口包含一个方法，用于创建 InvocationHandler：
 

 

java
 

代码解读
 

复制代码
 

public interface InvocationHandlerFactory { InvocationHandler create(Target target); } 
 

  • Target：代表Feign客户端的目标，包含了服务的名称、URL和接口类型。
 

步骤2：实现 InvocationHandlerFactory
 

Feign提供了一个默认的 InvocationHandlerFactory 实现，通常是一个名为 ReflectiveInvocationHandlerFactory 的类：
 

 

java
 

代码解读
 

复制代码
 

public class ReflectiveInvocationHandlerFactory implements InvocationHandlerFactory { @Override public InvocationHandler create(Target target) { return new ReflectiveInvocationHandler(target); } } 
 

在这个实现中，ReflectiveInvocationHandlerFactory 创建了一个 ReflectiveInvocationHandler 实例，这个 InvocationHandler 会处理反射调用。
 

步骤3：实现 InvocationHandler
 

ReflectiveInvocationHandler 是 InvocationHandler 接口的一个实现，它负责将方法调用转换为HTTP请求：
 

 

java
 

代码解读
 

复制代码
 

public class ReflectiveInvocationHandler implements InvocationHandler { private final Target<?> target; private final FeignClientFactory feignClientFactory; public ReflectiveInvocationHandler(Target<?> target, FeignClientFactory feignClientFactory) { this.target = target; this.feignClientFactory = feignClientFactory; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // 根据方法和参数构建RequestTemplate RequestTemplate template = buildTemplateFromArgs(target, method, args); // 发送请求并获取响应 Response response = feignClientFactory.create(target).execute(template, options()); // 根据响应构建返回值 return decode(response, method.getReturnType()); } private RequestTemplate buildTemplateFromArgs(Target<?> target, Method method, Object[] args) { // 构建请求模板逻辑 // ... } private Response.Options options() { // 获取请求选项，如超时设置 // ... } private Object decode(Response response, Type type) { // 将响应解码为方法返回类型的逻辑 // ... } } 
 

代码中我们发现，invoke 方法是核心，它根据目标对象、方法和参数构建一个 RequestTemplate，然后使用 FeignClient 发送请求并获取响应。
 

步骤4：配置 Feign 客户端使用自定义 InvocationHandlerFactory
 

自定义 InvocationHandlerFactory，可以在Feign配置中指定：
 

 

java
 

代码解读
 

复制代码
 

@Configuration public class FeignConfig { @Bean public InvocationHandlerFactory invocationHandlerFactory() { return new CustomInvocationHandlerFactory(); } } 
 

然后在 @FeignClient 注解中指定配置类：
 

 

java
 

代码解读
 

复制代码
 

@FeignClient(name = "myClient", configuration = FeignConfig.class) public interface MyClient { // ... } 
 

小结一下
 

为啥说程序员需要充分理解设计模式的应用，如果在面试时问你任何关于设计模式的问题，请不要只讲概念、不要只讲概念、不要只讲概念，还要结合业务场景，或者结合框架源码的理解来讲，讲一讲解决了什么问题，这是关键所在。

                

        

        

    




    

      

        

            

              
                
                  程序以一
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    7
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    11
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
2024SpringCloud学习笔记

				
			

			

				

					pineapplegi的博客
				

				

					07-08
					
					1044
					
				

			

		

		

			
				
官网开发者模式启动浏览器访问本地端口:8500。

			
		

	



                

              
                



	

		

			

				
					
Spring Cloud 学习笔记三：负载均衡

				
			

			

				

					RHeng的博客
				

				

					08-05
					
					1859
					
				

			

		

		

			
				
负载均衡是指将网络请求或网络流量分散到多个服务器或网络节点上，以提高系统的整体处理能力和可用性。在微服务架构中，负载均衡器通常部署在客户端和服务提供者之间，负责将请求智能地分发到各个服务实例上，以确保没有单个服务实例过载，同时最大化资源利用率。Spring Cloud LoadBalancer允许开发者通过实现ReactorLoadBalancer接口来自定义负载均衡策略。开发者可以根据业务需求，编写复杂的负载均衡逻辑，以满足特定的需求。

			
		

	



                


  
              

                


	

		

			

				
					
SpringCloud学习笔记（十、消息总线）

				
			

			

				

					2401_84010362的博客
				

				

					04-18
					
					413
					
				

			

		

		

			
				
在开头跟大家分享的时候我就说，面试我是没有做好准备的，全靠平时的积累，确实有点临时抱佛脚了，以至于我自己还是挺懊恼的。（准备好了或许可以拿个40k，没做准备只有30k+，你们懂那种感觉吗）如何准备面试？1、前期铺垫（技术沉积）程序员面试其实是对于技术的一次摸底考试，你的技术牛逼，那你就是大爷。大厂对于技术的要求主要体现在：基础，原理，深入研究源码，广度，实战五个方面，也只有将原理理论结合实战才能把技术点吃透。

			
		

	





	

		

			

				
					
不愧是阿里内部“SpringCloudAlibaba学习笔记”这细节讲解，神了

				
			

			

				

					2401_83329402的博客
				

				

					04-19
					
					665
					
				

			

		

		

			
				
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

			
		

	



		

			
		



	

		

			

				
					
SpringCloud学习笔记（六、视图微服务-FEIGN）

				
			

			

				

					2401_84010326的博客
				

				

					04-18
					
					397
					
				

			

		

		

			
				
关于分布式，限流+缓存+缓存，这三大技术（包含：ZooKeeper+Nginx+MongoDB+memcached+Redis+ActiveMQ+Kafka+RabbitMQ）等等。这些相关的面试也好，还有手写以及学习的笔记PDF，都是啃透分布式技术必不可少的宝藏。以上的每一个专题每一个小分类都有相关的介绍，并且小编也已经将其整理成PDF啦《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！

			
		

	





	

		

			

				
					
【SpringCloud】学习笔记-p3（Feign远程调用）

				
			

			

				

					2301_82242484的博客
				

				

					04-19
					
					575
					
				

			

		

		

			
				
现在正是金三银四的春招高潮，前阵子小编一直在搭建自己的网站，并整理了全套的**【一线互联网大厂Java核心面试题库+解析】：包括Java基础、异常、集合、并发编程、JVM、Spring全家桶、MyBatis、Redis、数据库、中间件MQ、Dubbo、Linux、Tomcat、ZooKeeper、Netty等等**《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！注Java获取）**

			
		

	





	

		

			

				
					
Spring Cloud 学习笔记

				
			

			

				

					山河已无恙
				

				

					03-19
					
					1978
					
				

			

		

		

			
				
26岁的时候，如果你过的不够好。请不要过于自责。很可能，你只是不够幸运罢了！---哈哈，知乎看到的，讲给自己


...

			
		

	





	

		

			

				
					
尚硅谷SpringCloud第二季笔记

				
			

			

				

					01-22
				

			

		

		

			
				
【尚硅谷SpringCloud第二季笔记】是一份详细记录了SpringCloud组件使用的学习笔记，涵盖了SpringCloud在云原生环境下的核心概念和实践应用。SpringCloud是基于Spring Boot实现的微服务框架，它提供了构建分布式系统...

			
		

	





	

		

			

				
					
SpringCloud学习笔记（十）声明式客户端Feign的简单调用 源码包

				
			

			

				

					11-29
				

			

		

		

			
				
在本文中，我们将深入探讨如何在Spring Cloud项目中使用Feign进行服务间的调用，以及其源码分析。  1. **Feign基本概念**  - **声明式API**: Feign通过注解接口来定义HTTP请求，接口方法名对应HTTP方法，方法参数...

			
		

	





	

		

			

				
					
尚硅谷周阳SpringCloud第一季笔记（超详细非官方手工笔记）

				
			

			

				

					02-21
				

			

		

		

			
				
尚硅谷周阳老师的SpringCloud课程因其深入浅出的讲解而备受赞誉，这份笔记正是基于他的第一季教学内容精心整理而成。  笔记中可能涵盖的知识点包括但不限于：  1. **SpringCloud Eureka**：作为服务注册与发现的核心...

			
		

	





	

		

			

				
					
springcloud实战：服务间通信OpenFeign熔断(1)

				
			

			

				

					hnsgsdsagaaq的博客
				

				

					04-18
					
					516
					
				

			

		

		

			
				
大型分布式系统犹如一个生命，系统中各个服务犹如骨骼，其中的数据犹如血液，而Kafka犹如经络，串联整个系统。这份Kafka源码笔记通过大量的设计图展示、代码分析、示例分享，把Kafka的实现脉络展示在读者面前，帮助读者更好地研读Kafka代码。麻烦帮忙转发一下这篇文章+关注我《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！数据犹如血液，而Kafka犹如经络，串联整个系统。

			
		

	





	

		

			

				
					
【学习笔记】卫星通信NTN 3GPP标准化进展分析（六）- 参考标准

					
最新发布

				
			

			

				

					u011376987的博客
				

				

					09-01
					
					923
					
				

			

		

		

			
				
本文总结了NTN标准化进程以及后续的研究计划，是学习NTN协议的入门。本文来自3GPP Joern Krause, 3GPP MCC。

			
		

	





	

		

			

				
					
Web3开发与安全：6个月高效学习路径

				
			

			

				

					weixin_47075747的博客
				

				

					08-30
					
					1486
					
				

			

		

		

			
				
这份计划应该能帮助你系统地学习智能合约开发和安全审计技能，同时克服英语的障碍。

			
		

	





	

		

			

				
					
MySQL基础学习

				
			

			

				

					eugene03的博客
				

				

					08-29
					
					2178
					
				

			

		

		

			
				
事务是一组操作的集合，它是一个不可分割的工作单位，事务会把所有操作作为一个整体一起向系统提交或者撤掉操作请求，那么这些操作要么同时成功，要么同时失败。笛卡尔积：两个集合 A集合和B集合的所有组合情况（在多表查询时，需要消除无效的笛卡尔积）对于union 查询，就是把多次查询的结果合并起来，行程一个新的查询结果集。相当于查询表1（左表）的所有数据包含表1和表2交集部分的数据。相当于查询表2（右表）的所有数据包含表1和表2交集部分的数据。自连接查询，可以是内连接查询，也可以是外连接查询。

			
		

	





	

		

			

				
					
AI实践与学习8-AI Agent Workflow助力解题和验证答案置信度

				
			

			

				

					xiaosi的博客
				

				

					08-30
					
					685
					
				

			

		

		

			
				
之前在试着提高解题正确率，目标100%，发现外部知识不足仅依靠大模型的话比较困难。而试题人工生产成本巨大。本质因为大模型生成内容会有幻觉特点，也就是说解答的试题正确性不太好评判，直接解答试题生产场景不太可控。后面考虑调用OpenAI解题的时候，像xxx那样通过输出置信度来帮助判断答案的正确性 or 其他形式只要能保证LLM生成答案是可靠（程序判断）的。

			
		

	





	

		

			

				
					
网络编程学习：TCP/IP协议

				
			

			

				

					kkbbaaii的博客
				

				

					09-01
					
					1152
					
				

			

		

		

			
				
网络编程学习：TCP/IP协议

			
		

	





	

		

			

				
					
ArkTS基础快速入门学习

				
			

			

				

					weixin_49898946的博客
				

				

					08-29
					
					1349
					
				

			

		

		

			
				
ArkTS语言在TS语言基础上扩展了声明式UI，组件化，状态管理等功能。官方推荐两种开发模式开发鸿蒙，一种是基于js扩展的类web范式，另一种是基于TS扩展的声明式UI范式（也就是使用ArkTS开发）。主要介绍harmonyos的页面布局和组件的基础使用

			
		

	





	

		

			

				
					
html+css+js网页设计 个人博客模版 我的学习经历7个页面

				
			

			

				

					qq_42431718的博客
				

				

					08-28
					
					1295
					
				

			

		

		

			
				
html+css+js网页设计 个人博客模版 我的学习经历7个页面  
 网页作品代码简单，可使用任意HTML编辑软件（如：Dreamweaver、HBuilder、Vscode 、Sublime 、Webstorm、Text 、Notepad++ 等任意html编辑软件进行运行及修改编辑等操作）。

			
		

	





	

		

			

				
					

				
			

			

				

					
				

			

		

		

			
				

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值