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

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架构

相关推荐
paopaokaka_luck10 分钟前
[371]基于springboot的高校实习管理系统
java·spring boot·后端
ExiFengs1 小时前
实际项目Java1.8流处理, Optional常见用法
java·开发语言·spring
捂月1 小时前
Spring Boot 深度解析:快速构建高效、现代化的 Web 应用程序
前端·spring boot·后端
瓜牛_gn2 小时前
依赖注入注解
java·后端·spring
Estar.Lee2 小时前
时间操作[取当前北京时间]免费API接口教程
android·网络·后端·网络协议·tcp/ip
喜欢猪猪2 小时前
Django:从入门到精通
后端·python·django
一个小坑货2 小时前
Cargo Rust 的包管理器
开发语言·后端·rust
bluebonnet272 小时前
【Rust练习】22.HashMap
开发语言·后端·rust
uhakadotcom2 小时前
如何实现一个基于CLI终端的AI 聊天机器人?
后端