【SpringCloud】OpenFeign-远程调用

最新推荐文章于 2024-07-18 23:06:55 发布
最新推荐文章于 2024-07-18 23:06:55 发布
阅读量795 收藏 17
点赞数 24
分类专栏： 微服务 文章标签： spring cloud 后端 OpenFeign feign
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/p_fly/article/details/139882066
版权

本文基于上一篇http://t.csdnimg.cn/0qm2R 的基础上添加OpenFeign的使用。

微服务通信

在微服务架构中，微服务之间的通信通常有两种方式：RPC 和 HTTP。在 Spring Cloud 中，默认使用 HTTP 进行微服务的通信，最常用的实现形式有两种：RestTemplate  OpenFeign

HTTP 通信

RestTemplate
RestTemplate是 Spring 提供的用于同步 HTTP 请求的客户端工具，可以方便地与其他微服务进行 HTTP 调用。

OpenFeign
OpenFeign是一个声明式的 HTTP 客户端，使得编写 HTTP 客户端变得非常简单。通过注解来定义接口，Spring Cloud Feign 会自动生成实现该接口的 HTTP 客户端对象。

Netflix于2013年6月发布了Feign的第一个版本1.0.0，并于2016年7月发布了最后一个版本8.18.0。在2016年，Netflix将Feign捐献给社区，并于同年7月发布了OpenFeign的首个版本9.0.0，随后持续发布至今。因此，可以简单理解为Netflix Feign是OpenFeign的祖先，或者说OpenFeign是Netflix Feign的升级版。OpenFeign是Feign的一个更强大、更灵活的实现。（后续提到的Feign都是 OpenFeign）

Spring Cloud Feign 是 Spring 对 Feign 的封装，将 Feign 项目集成到 Spring Cloud 生态系统中。受 Feign 更名影响，Spring Cloud Feign 也有两个 starter：

spring-cloud-starter-feign
spring-cloud-starter-openfeign
由于 Feign 停更维护，因此我们使用的依赖是 spring-cloud-starter-openfeign。

RPC（Remote Procedure Call）

RPC（远程过程调用）是一种通过网络从远程计算机上请求服务，而不需要了解底层网络通信细节的机制。RPC 可以使用多种网络协议进行通信，如 HTTP、TCP、UDP 等，并且在 TCP/IP 网络四层模型中跨越了传输层和应用层。简而言之，RPC 就是像调用本地方法一样调用远程方法。

常见的 RPC 框架有：

1. Dubbo:是一个高性能的 Java RPC 框架，提供透明化的远程方法调用，主要用于构建分布式服务架构。
2. Thrift:是一个由 Facebook 开发的跨语言的 RPC 框架，支持多种编程语言，适用于服务之间高效的通信。
3. gRPC: gRPC 是 Google 开发的高性能、开源的 RPC 框架，使用 Protocol Buffers 作为接口描述语言，支持多种编程语言，适用于不同平台的服务通信。

通过上述工具和框架，可以实现微服务之间的高效通信，无论是通过 HTTP 还是 RPC，选择何种方式取决于具体的业务需求和技术选型。

OpenFeign的使用

引入依赖

在order-service的pom中引入依赖

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>

添加注解

在启动类中添加注解，开启feign功能。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;

@EnableFeignClients # 开启openFeign功能
@SpringBootApplication
public class OrderServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderServiceApplication.class, args);
    }
}

编写客户端

import com.demo.order.model.ProductInfo;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

// name：根据注册中心的服务名来调用
// path：调用product-service中的controller中的所有url都有path前缀
@FeignClient(name = "product-service", path = "/product")

// 根据product-service中的controller中的接口写方法
public interface ProductApi {

    // 与product-service中的controller中的接口相对应
    @RequestMapping("/{productId}")
    ProductInfo getProductById(@PathVariable("productId") Integer productId);
}

远程调用

import com.demo.order.api.ProductApi;
import com.demo.order.mapper.OrderMapper;
import com.demo.order.model.OrderInfo;
import com.demo.order.model.ProductInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

@Service
public class OrderService {
    @Autowired
    private OrderMapper orderMapper;

    @Autowired
    private ProductApi productApi;

    public OrderInfo selectOrderById(Integer orderId){
        OrderInfo orderInfo = orderMapper.selectOrderById(orderId);

        ProductInfo productInfo = productApi.getProductById(orderInfo.getProductId());
        orderInfo.setProductInfo(productInfo);
        return orderInfo;
    }
}

运行观察

OpenFeign的参数传递

上面的代码只演示了从url中获取参数，接下来将演示使用单个/多个参数、对象、JSON的方式来接收参数。

调用过程：order-service中的一个controller 使用 feign的客户端，通过远程调用 调用 product-service中的controller方法。

对于product-service中的一个controller（服务方）

import com.demo.product.model.ProductInfo;
import com.demo.product.service.ProductService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@Slf4j
@RequestMapping("/product")
@RestController
public class ProductController {
    @Autowired
    ProductService productService;

    @RequestMapping("/{productId}")
    public ProductInfo getProductById(@PathVariable("productId") Integer productId) {
        log.info("接收到参数: productId" + productId);
        return productService.selectProductById(productId);
    }

    @RequestMapping("/p1")
    public String p1(Integer id) {
        return "product-service 接收到参数, id:" + id;
    }

    @RequestMapping("/p2")
    public String p2(Integer id, String name) {
        return "product-service 接收到参数, id:" + id + ",name:" + name;
    }

    @RequestMapping("/p3")
    public String p3(ProductInfo productInfo) {
        return "product-service 接收到参数: productInfo" + productInfo.toString();
    }

    @RequestMapping("/p4")
    public String p4(@RequestBody ProductInfo productInfo) {
        return "product-service 接收到参数: productInfo" + productInfo.toString();
    }
}

feign的客户端代码（远程调用桥梁）

import com.demo.order.model.ProductInfo;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.cloud.openfeign.SpringQueryMap;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

// name：根据注册中心的服务名来调用
// path：调用product-service中的controller中的所有url都有path前缀
@FeignClient(name = "product-service", path = "/product")

// 根据product-service中的controller中的接口写方法
public interface ProductApi {

    // 与product-service中的controller中的接口相对应
    @RequestMapping("/{productId}")
    ProductInfo getProductById(@PathVariable("productId") Integer productId);

    @RequestMapping("/p1")
    String p1(@RequestParam("id") Integer id);

    @RequestMapping("/p2")
    String p2(@RequestParam("id") Integer id, @RequestParam("name") String name);

    @RequestMapping("/p3")
    // @SpringQueryMap：feign客户端接收对象的时候需要这个注解，springmvc的controller不需要
    String p3(@SpringQueryMap ProductInfo productInfo);

    @RequestMapping("/p4")
    String p4(@RequestBody ProductInfo productInfo);
}

对于order-service中的一个controller（消费方）

import com.demo.order.api.ProductApi;
import com.demo.order.model.ProductInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 测试feign的一个order-server的controller
 * 通过feign的客户端，远程调用product-server接口
 */
@RequestMapping("/feign")
@RestController
public class TestFeignController {
    @Autowired
    private ProductApi productApi;

    @RequestMapping("/o1")
    public String o1(Integer id){
        return productApi.p1(id);
    }
    @RequestMapping("/o2")
    public String o2(Integer id, String name){
        return productApi.p2(id,name);
    }
    @RequestMapping("/o3")
    public String o3(ProductInfo productInfo){
        return productApi.p3(productInfo);
    }
    @RequestMapping("/o4")
    public String o4(@RequestBody ProductInfo productInfo){
        return productApi.p4(productInfo);
    }
}

此时来调用order-service中的controller方法。

OpenFeign最佳使用

上面使用feign的方式非常冗余，可以看到feign客户端代码和服务方提供的controller代码非常的相似。所以一般不使用上面的方式。一般有继承和抽取两种方式来使用feign。

继承

官方文档：Spring Cloud OpenFeign Features :: Spring Cloud Openfeign

下面将简单说明如何使用。

创建模块

这里是存放公共代码的模块。

引入依赖

把需要的依赖放到product-api的pom文件中

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>

提取方法和实体类

把之前写到ProductApi接口中的方法放到ProductInterface中。

把ProductInfo也放到这里。product-service中的实体类可以删除了。

打jar包

删除后，product-service中引用ProductInfo类的地方都会报错。解决方案：

暂时先把product-api这个jar包下载到本地，然后添加模块即可。

同理把order-service中的ProductInfo也删除，并进行上述操作，并重新导入ProductInfo。

服务方实现接口

import com.demo.product.api.ProductInterface;
import com.demo.product.model.ProductInfo;
import com.demo.product.service.ProductService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@Slf4j
@RequestMapping("/product")
@RestController
public class ProductController implements ProductInterface {
    @Autowired
    ProductService productService;

    @RequestMapping("/{productId}")
    public ProductInfo getProductById(@PathVariable("productId") Integer productId) {
        log.info("接收到参数: productId" + productId);
        return productService.selectProductById(productId);
    }

    @RequestMapping("/p1")
    public String p1(Integer id) {
        return "product-service 接收到参数, id:" + id;
    }

    @RequestMapping("/p2")
    public String p2(Integer id, String name) {
        return "product-service 接收到参数, id:" + id + ",name:" + name;
    }

    @RequestMapping("/p3")
    public String p3(ProductInfo productInfo) {
        return "product-service 接收到参数: productInfo" + productInfo.toString();
    }

    @RequestMapping("/p4")
    public String p4(@RequestBody ProductInfo productInfo) {
        return "product-service 接收到参数: productInfo" + productInfo.toString();
    }
}

消费方继承接口

import com.demo.product.api.ProductInterface;
import org.springframework.cloud.openfeign.FeignClient;

// name：根据注册中心的服务名来调用
// path：调用product-service中的controller中的所有url都有path前缀
@FeignClient(name = "product-service", path = "/product")
// 根据product-service中的controller中的接口写方法
public interface ProductApi extends ProductInterface {

}

测试

可以正常使用。

抽取

官方推荐使用继承的方法来使用OpenFeign，但在企业开发中，更多的是把feign客户端接口抽取为一个独立的模块，并把涉及到的实体类等都放到这个模块，打成一个jar包。

创建模块

引入依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>

提取api接口等

把ProductApi复制粘贴到新模块中，并删除之前的。

把ProductInfo按照上面的操作同样的移动到新模块中。

服务端基本不用改，消费端需要从自身的拿取改到从公共模块拿取。

打jar包

对公共模块打jar包到本地。

打完jar包后，在order-service中修改公共代码的使用路径。

添加扫描包

order-service启动的时候，只能扫描当前路径下的，无法扫描到公共模块的api

需要在启动类中添加扫描路径。

import com.demo.product.api.ProductApi;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;

// clients 添加启动类无法扫描到的ProductApi
@EnableFeignClients(clients = {ProductApi.class})
@SpringBootApplication
public class OrderServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderServiceApplication.class, args);
    }
}

测试

部署

这里部署的时候只有打包的地方和之前有区别。因为这里有个product-api的包是本地的，不是从maven仓库下载的。

解决方案：

这里使用从本地读取的方案。

把product-api打包

复制路径

修改pom
在order-service中修改一下pom，让它读本地的product-api的jar包。

        <dependency>
            <groupId>org.example</groupId>
            <artifactId>product-api</artifactId>
            <version>1.0-SNAPSHOT</version>
<!--            <scope>compile</scope>-->
            <!-- 从本地仓库引入 -->
            <scope>system</scope>
            <systemPath>C:/Users/pxf/.m2/repository/org/example/product-api/1.0-SNAPSHOT/product-api-1.0-SNAPSHOT.jar</systemPath>
        </dependency>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <!-- 让它可以引入本地jar包 -->
                <configuration>
                    <includeSystemScope>true</includeSystemScope>
                </configuration>
            </plugin>
        </plugins>
    </build>

后面的正常打包部署即可。

p_fly
关注
  • 24
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Cloud OpenFeign - - - ＞拦截器
11-29
初学者很容易将 Spring MVC 拦截器 和 Spring Cloud OpenFeign 拦截器搞混，误以为OpenFeign拦截器...Spring Cloud OpenFeign拦截器发生在两个不同的服务之间，在服务消费端发送请求远程调用服务提供方时进行拦截处理。
微服务--03--OpenFeign 实现远程调用 （负载均衡组件SpringCloudLoadBalancer）
时光里的博客
11-28 793
在hm-api模块下新建一个配置类，定义Feign的日志级别：2.配置接下来，要让日志级别生效，还需要配置这个类。
openfeign实现远程调用
wangcheng_BI的博客
06-25 1731
Feign 是声明性(注解)web 服务客户端它使编写 web 服务客户端更加容易请创建一个接口并对其进行注解.它具有可插入注解支持，包括Feign注解和JAXRS注解Feign 还支持可插拔编码器和解码器。Spring cloud 添加了对Spring MVC注解的支持，并支持使用 HttpMessageConverters，Spring Web 中默认使用的注解。
【微服务】第38节：微服务的OpenFeign远程调用
最新发布
m0_46013789的博客
07-18 852
分布式事务，就是指不是在单个服务或单个数据库架构下，产生的事务，例如： 跨数据源的分布式事务；跨服务的分布式事务；综合情况。我们之前解决分布式事务问题是直接使用Seata框架的AT模式，但是解决分布式事务问题的方案远不止这一种。
OpenFeign远程调用
NineT_Pure的博客
10-10 2068
一、引入open-feign <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-openfeign</artifactId> </dependency> 二、在被调用的微服务的Controller编写一个测试方法。（gulimall-coupon 优惠卷服务） @RequestMapping(
openfeign远程调用
cxy_ydj的博客
12-06 1076
openfeign远程调用
微服务之openfeign实现远程调用的步骤
qq_21500309的博客
03-26 1193
penFeign是一种声明式、模板化的HTTP客户端。在Spring Cloud中使用OpenFeign，可以做到使用HTTP请求访问远程服务，就像调用本地方法一样的，开发者完全感知不到这是在调用远程方法，更感知不到在访问HTTP请求。提示：以下是本篇文章正文内容，下面案例可供参考以上就是今天要讲的内容，本文仅仅简单介绍了openFeign的使用，做个笔记记录一下！！
Spring Cloud OpenFeign 远程调用
11-25
OpenFeign 和 Dubbo一样是一个RPC远程调用框架，目的是使的我们调用接口和调用本地方法一样简单，开发者无需关心和远程的交互细节( 即不需要通过常规的 Http Client 构建请求再解析返回数据，让开发者在调用远程接口...
SpringCloud-OpenFeign服务接口调用及代码
06-01
在SpringCloud生态系统中，OpenFeign是一个非常重要的组件，它为开发者提供了声明式的Web服务客户端。这个组件使得我们可以像编写本地方法一样调用远程服务，极大地简化了微服务之间的通信。下面将详细介绍OpenFeign...
Spring Cloud OpenFeign示例代码
10-28
Spring Cloud OpenFeign是Spring Cloud生态中的一个组件，主要用于简化微服务之间的调用，它提供了声明式的Web服务客户端实现。OpenFeign使得开发者能够通过简单的注解定义接口，即可实现远程服务的调用，如同调用...
03_SpringCloud-openFeign远程调用.md
01-03
feign是一个客户端声明式http远程调用工具，提供了接口和注解方式进行调用 ，推荐使用feign继承体系方式进行内部RPC调用。
OpenFeign远程调用实现
莫须有的博客
06-30 2939
OpenFeign远程调用实现
OpenFeign的三种远程调用方式
Tianwen55的博客
07-04 3562
OpenFeign的三种远程调用方式， 分别是通过服务名、写死url，动态传入URL、进行远程调用。
open feign 远程服务调用
孟斌斌的博客
03-25 550
1、我们在微服务之间接口的相互之间调用；降低代码的冗余，主要是集成了负载均衡，主要是以接口的方式发送Http请求。2.定义一个接口，在接口上面添加@FeignClient注解，在注解的后面主要是指定我们的服务名称，之后通过里面的接口路径找到对应的服务，进行远程调用；3.在远程调用的服务里面的启动类上面添加@EnableFeignClients注解，之后spring加载@FeignClient就能找到对应的服务；基础使用就到这里，接下来，将为大家介绍一下用到熔断监测、降级和恢复机制 Hystrix。
微服务间的远程接口调用：OpenFeign的使用并理解原理
qq_42582773的博客
10-09 4231
Feign
使用OpenFeign进行服务远程调用
m0_57669503的博客
12-10 1061
在hm-api模块下新建一个配置类，定义Feign的日志级别：代码如下：​​@Bean​。
OpenFeign远程调用的使用
lirtyuj的博客
06-25 236
【代码】OpenFeign远程调用的使用。
SpringCloud OpenFeign：简化远程服务调用与负载均衡
在Spring Cloud微服务架构中，OpenFeign是一种强大的客户端负载均衡工具，用于简化服务之间的远程调用。相较于传统的RestTemplate，OpenFeign提供了一种更加优雅和高效的解决方案，特别是在处理大量参数或复杂请求时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值