微服务之间的相互调用的几种常见实现方式对比

目次
微服务之间的相互调用的几种实现方式
一、HTTP
HTTP/RESTful API调用工作原理
二、RPC
操持理念与实现方式
协议与传输层
RPC长途调用工作原理
应用场景与性能考量
特点
三、Feign
操持理念与实现方式
协议与传输层 
Feign调用的根本流程
 Feign调用的工作原理
特点
应用场景与性能考量
四、几种调用方式的区别与接洽
Feign与HTTP的关系和区别
RPC与HTTP的关系和区别
RPC和openfeign的关系和区别

---

在微服务架构中，长途调用、HTTP/RESTful API和Feign是实现微服务之间通讯的差别方式。在构建分布式体系和微服务架构时，选择符合的服务间通讯技能至关紧张。

微服务之间的相互调用的几种实现方式

在Java多模块项目中实现微服务架构时，微服务之间的相互调用通常可以通过以下几种方式实现：

根据具体的业务需求、性能要求、开辟团队技能栈等因素，可以选择符合的调用方式来举行微服务间的通讯。通常环境下，会根据项目的具体环境，联合多种调用方式来实现差别的功能和需求。
 
一、HTTP

   详情请移步我的另一篇博客HTTP协议简朴先容-CSDN博客
  HTTP/RESTful API调用工作原理

HTTP/RESTful API调用是通过HTTP协议举行通讯的一种方式，它的工作原理是客户端发送HTTP哀求到服务器，服务器吸取到哀求后处置惩罚并返回HTTP相应。下面是HTTP/RESTful API调用的工作原理和代码示例。
工作原理：

• 客户端发送哀求：客户端（比方欣赏器、移动应用、或其他服务器）创建一个HTTP哀求，并指定哀求方法（比方GET、POST、PUT、DELETE等）、URL地点、哀求头、哀求体等信息。
  
• 服务器吸取哀求：服务器吸取到客户端发送的HTTP哀求，并根据哀求中的信息确定要实行的利用。
  
• 服务器处置惩罚哀求：服务器根据哀求中的信息实行相应的利用，大概包罗查询数据库、处置惩罚业务逻辑、天生动态内容等。
  
• 服务器返回相应：服务器处置惩罚完哀求后，会天生一个HTTP相应，包罗状态码、相应头、相应体等信息。然后将该相应发送回客户端。
  
• 客户端吸取相应：客户端吸取到服务器发送的HTTP相应后，根据相应中的信息举行相应的处置惩罚，大概是渲染页面、剖析相应体中的数据等。
  

代码示例：下面是一个简朴的使用Java举行HTTP GET哀求的示例代码，使用的是java.net.HttpURLConnection。这段代码发送一个HTTP GET哀求到https://jsonplaceholder.typicode.com/posts/1，并输出相应码和相应体。

1. import java.io.BufferedReader;
2. import java.io.InputStreamReader;
3. import java.net.HttpURLConnection;
4. import java.net.URL;
6. public class HttpGetExample {
7.     public static void main(String[] args) {
8.         try {
9.             // 创建URL对象，指定要请求的URL地址
10.             URL url = new URL("https://jsonplaceholder.typicode.com/posts/1");
11.             // 打开连接
12.             HttpURLConnection connection = (HttpURLConnection) url.openConnection();
13.             // 设置请求方法为GET
14.             connection.setRequestMethod("GET");
16.             // 获取响应码
17.             int responseCode = connection.getResponseCode();
18.             System.out.println("Response Code: " + responseCode);
20.             // 读取响应内容
21.             BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
22.             StringBuilder response = new StringBuilder();
23.             String line;
24.             while ((line = reader.readLine()) != null) {
25.                 response.append(line);
26.             }
27.             reader.close();
29.             // 打印响应内容
30.             System.out.println("Response Body:");
31.             System.out.println(response.toString());
33.             // 关闭连接
34.             connection.disconnect();
35.         } catch (Exception e) {
36.             e.printStackTrace();
37.         }
38.     }
39. }

复制代码

二、RPC

RPC，即 Remote Procedure Call（长途过程调用）是一个盘算机通讯协议，是指一个服务通过网络向另一个服务发送哀求，以得到数据或实行利用。
RPC是一种跨网络历程间通讯技能，其目的是使长途服务调用如同本地调用一样透明。 该协议允许运行于一台盘算机的步伐调用另一台盘算机的子步伐，而步伐员无需额外地为这个交互作用编程。说得普通一点就是：A盘算机提供一个服务，B盘算机可以像调用本地服务那样调用A盘算机的服务。
长途调用的实现方式有多种，包罗但不限于HTTP REST API、gRPC、SOAP等。

• 传统的RPC实现基于自界说协媾和传输层（如TCP）
  
• 而今世RPC框架如gRPC则采取HTTP/2作为传输层，支持更高效的数据交换。
  

RPC框架通常内置服务发现、负载平衡、序列化/反序列化等高级功能，实用于高性能、低延伸的内部服务通讯。
操持理念与实现方式

操持哲学：寻求透明的长途调用体验，尽大概潜伏网络通讯细节。
实现机制：更机动的协议选择，支持自界说或尺度协议（如gRPC使用HTTP/2）。通常包罗序列化/反序列化层，以高效传输数据。
协议与传输层

多样化，既有基于TCP/UDP的自界说协议，也有采取HTTP/2等今世网络协议的实现，如gRPC，以实现更高效的二进制数据传输。
RPC长途调用工作原理

长途过程调用（RPC）是一种通过网络在差别盘算机之间举行通讯的方式，使得一个盘算机步伐可以调用另一个盘算机上的函数或方法，就像调用本地函数一样。下面是RPC的工作原理和一个简朴的Java代码示例。
工作原理：

• 界说接口：起首，在服务端和客户端都须要界说雷同的接口，接口中包罗了须要长途调用的方法。
  
• 序列化参数：当客户端调用长途方法时，客户端将方法名和参数序列化成字节省，然后通过网络发送到服务端。
  
• 网络传输：服务端吸取到客户端发送的哀求后，将哀求反序列化成方法名和参数，然后在服务端实行对应的方法。
  
• 实行方法：在服务端实行方法后，将方法的返回值序列化成字节省，然后通过网络发送给客户端。
  
• 反序列化返回值：客户端吸取到服务端发送的返回值后，将返回值反序列化成方法的返回值，然后将其返回给调用方。
  

代码示例：以下是一个简朴的RPC示例，包罗服务端和客户端的代码：
（1）服务端代码，

1. import java.io.IOException;
2. import java.io.ObjectInputStream;
3. import java.io.ObjectOutputStream;
4. import java.net.ServerSocket;
5. import java.net.Socket;
7. public class RpcServer {
8.     public static void main(String[] args) {
9.         try {
10.             // 创建ServerSocket，并指定端口号
11.             ServerSocket serverSocket = new ServerSocket(8888);
12.             System.out.println("Server started...");
14.             while (true) {
15.                 // 监听客户端连接
16.                 Socket socket = serverSocket.accept();
17.                 System.out.println("Client connected: " + socket.getInetAddress());
19.                 // 创建ObjectInputStream和ObjectOutputStream
20.                 ObjectInputStream inputStream = new ObjectInputStream(socket.getInputStream());
21.                 ObjectOutputStream outputStream = new ObjectOutputStream(socket.getOutputStream());
22.                 // 读取客户端发送的方法名和参数
23.                 String methodName = inputStream.readUTF();
24.                 int a = inputStream.readInt();
25.                 int b = inputStream.readInt();
27.                 // 调用方法
28.                 int result = 0;
29.                 if ("add".equals(methodName)) result = add(a, b);
31.                 // 将方法的返回值写回客户端
32.                 outputStream.writeInt(result);
33.                 outputStream.flush();
35.                 // 关闭流和Socket
36.                 inputStream.close();
37.                 outputStream.close();
38.                 socket.close();
39.             }
40.         } catch (IOException e) {e.printStackTrace();}
41.     }
43.     public static int add(int a, int b) {return a + b;}
44. }

复制代码

（2）客户端代码，

1. import java.io.IOException;
2. import java.io.ObjectInputStream;
3. import java.io.ObjectOutputStream;
4. import java.net.Socket;
6. public class RpcClient {
7.     public static void main(String[] args) {
8.         try {
9.             // 连接服务端的Socket，并指定IP地址和端口号
10.             Socket socket = new Socket("localhost", 8888);
12.             // 创建ObjectInputStream和ObjectOutputStream
13.             ObjectOutputStream outputStream = new ObjectOutputStream(socket.getOutputStream());
14.             ObjectInputStream inputStream = new ObjectInputStream(socket.getInputStream());
16.             // 发送方法名和参数到服务端
17.             outputStream.writeUTF("add");
18.             outputStream.writeInt(10);
19.             outputStream.writeInt(20);
20.             outputStream.flush();
22.             // 读取服务端发送的返回值
23.             int result = inputStream.readInt();
24.             System.out.println("Result: " + result);
26.             // 关闭流和Socket
27.             outputStream.close();
28.             inputStream.close();
29.             socket.close();
30.         } catch (IOException e) {e.printStackTrace();}
31.     }
32. }

复制代码

应用场景与性能考量

在须要高性能、低延伸通讯的场景中更为常见，如内部服务间的麋集通讯，特殊是在游戏、金融等范畴。今世RPC框架如gRPC，依附其高性能和跨语言特性，也渐渐应用于更广泛的分布式体系中。
特点

• 直接调用：服务通过网络协议（如HTTP、gRPC等）直接调用其他服务的API。
  
• 机动性：可以使用差别的协媾和库来实现，比如使用RestTemplate、HttpClient等。
  
• 手动管理：开辟者须要手动处置惩罚哀求的构建、相应的剖析以及非常处置惩罚等。
  

三、Feign

Feign是一个轻量级的Java库，专为简化HTTP API客户端调用而生。通过动态署理和接口注解，Feign使得调用长途服务如同调用本地方法一样直观便捷。它常用于Spring Cloud等微服务框架中，与服务发现、负载平衡等服务管理组件精麋集成，提供了一种声明式的HTTP客户端办理方案，用于简化微服务之间的HTTP调用。
OpenFeign是Spring Cloud提供的一个声明式的伪Htp客户端，它使得调用长途服务就像调用本地服务一样简朴，只须要创建一个接口并添加一个注解即可。通过使用注解，开辟者可以轻松地界说调用其他服务的接口，而不须要编写大量的底层代码。
操持理念与实现方式

操持哲学：面向接口编程，通过接口界说和服务注解，抽象出轻便的调用逻辑。
实现机制：使用JVM的动态署理机制天生客户端署理类，主动处置惩罚哀求构造、发送和相应剖析。
协议与传输层 

基于HTTP协议，使用HTTP的尺度化和易穿透网络特性，支持RESTful风格的API交互。
Feign调用的根本流程

   假如不相识 SpringCloud 中 Feign 焦点原理，不会真正的相识 SpringCloud 的性能优化和设置优化，也就不大概做到真正把握 SpringCloud。
  Feign长途调用，焦点就是通过一系列的封装和处置惩罚，将以JAVA注解的方式界说的长途调用API接口，终极转换成HTTP的哀讨情势，然后将HTTP的哀求的相应结果，解码成JAVA Bean，放回给调用者。
Feign长途调用的根本流程，大抵如下图所示。

从上图可以看到，Feign通过处置惩罚注解，将哀求模板化，当现实调用的时间，传入参数，根据参数再应用到哀求上，进而转化成真正的 Request 哀求。通过Feign以及JAVA的动态署理机制，使得Java 开辟职员，可以不消通过HTTP框架去封装HTTP哀求报文的方式，完发展途服务的HTTP调用。
 Feign调用的工作原理

Feign调用的工作原理是通过动态署理技能将接口方法的调用转换为HTTP哀求，并发送到长途服务。下面是Feign调用的一样平常工作流程：

• 界说Feign客户端接口：在客户端项目中界说一个Java接口，该接口用于形貌要调用的长途服务的API。接口的方法对应了长途服务的差别接口或资源路径。
  
• 创建Feign客户端：使用@FeignClient注解标注接口，指定要调用的长途服务的名称或URL。Feign根据该注解创建一个动态署理对象，该署理对象实现了接口界说的方法。
  
• 调用长途服务方法：在客户端代码中直接调用Feign客户端接口的方法，就像调用本地方法一样。Feign客户端会拦截这些方法调用，并将它们转换为HTTP哀求。
  
• HTTP哀求转换：当调用Feign客户端接口的方法时，Feign会根据方法的注解（如@GetMapping、@PostMapping等）以及方法的参数，构建对应的HTTP哀求。
  
  
  • 比方，根据@GetMapping注解指定的路径和方法参数，天生一个GET哀求。
    
  
  
• 发送HTTP哀求：Feign客户端将天生的HTTP哀求发送到长途服务的URL。这个URL通常是通过服务注册与发现机制获取的，大概是在@FeignClient注解中指定的硬编码URL。
  
• 吸取相应：长途服务吸取到HTTP哀求后，处置惩罚哀求并返回相应。Feign客户端吸取到相应后，将其转换为Java对象（假如有须要）并返回给调用方。
  

总体来说，Feign通过动态署理技能将接口方法调用转换为HTTP哀求，并将这些哀求发送到长途服务。这种方式使得调用长途服务变得简朴、直观，而且潜伏了底层HTTP通讯的细节，进步了开辟服从。
Feign是一个声明式的HTTP客户端，它简化了使用HTTP API的调用。Feign的工作原理是通过动态署理技能，将接口方法的调用转换为HTTP哀求，并发送到长途服务。以下是使用Feign调用长途服务的具体Java代码示例：
假设有一个名为UserService的微服务，此中包罗了一些用户相干的接口，我们渴望在另一个微服务中调用这些接口。
（1）起首，我们须要在调用方的项目中添加Feign的依赖，

1. <dependency>
2.     <groupId>org.springframework.cloud</groupId>
3.     <artifactId>spring-cloud-starter-openfeign</artifactId>
4. </dependency>

复制代码

（2）创建一个Feign客户端接口，界说要调用的长途服务的API。假设UserService提供了一个获取用户信息的API，我们可以界说一个Feign接口如下：

1. import org.springframework.cloud.openfeign.FeignClient;
2. import org.springframework.web.bind.annotation.GetMapping;
3. import org.springframework.web.bind.annotation.RequestParam;
5. @FeignClient(name = "user-service") // 指定要调用的微服务名称
6. public interface UserFeignClient {
8.     @GetMapping("/user/info") // 指定远程服务的URL路径
9.     String getUserInfo(@RequestParam("userId") Long userId); // 定义要调用的远程方法
10. }

复制代码

（3）在调用方的代码中注入Feign客户端接口，并使用该接口来调用长途服务的方法：

1. import org.springframework.beans.factory.annotation.Autowired;
2. import org.springframework.stereotype.Service;
4. @Service
5. public class UserService {
7.     @Autowired
8.     private UserFeignClient userFeignClient; // 注入Feign客户端接口
10.     public String getUserInfo(Long userId) {
11.         return userFeignClient.getUserInfo(userId); // 调用远程服务的方法
12.     }
13. }

复制代码

在这个示例中，UserFeignClient接口界说了一个名为getUserInfo的方法，该方法对应了长途服务的/user/info接口。然后在UserService中注入了UserFeignClient接口的实例，并在getUserInfo方法中调用了长途服务的方法。Feign会根据接口界说动态天生一个署理对象，负责将方法调用转换为HTTP哀求并发送到长途服务。
须要留意的是，为了使Feign可以大概正常工作，我们须要确保调用方项目中已经设置了Spring Cloud的相干组件，比方服务注册与发现（Eureka、Consul等）和负载平衡（Ribbon等）等功能。
特点

• 声明式：使用注解界说RESTful API调用，镌汰了样板代码。
  
• 主动处置惩罚：OpenFeign主动处置惩罚哀求的构建、相应的剖析和错误处置惩罚等，简化了开辟过程。
  
• 与Spring Cloud集成：OpenFeign通常与Spring Cloud联合使用，支持负载平衡、熔断、服务发现等特性。
  

应用场景与性能考量

非常得当RESTful风格的微服务架构，特殊是集成在Spring Cloud生态中，提供服务管理本事的同时，保持了与Web服务的良好兼容性。

四、几种调用方式的区别与接洽

以下是Feign、HTTP/RESTful API调用、RPC调用它们三个之间的区别与接洽。
区别：

• Feign：
  
  
  
  • Feign是一个声明式的HTTP客户端，用于简化基于HTTP的RESTful服务调用。它通过接口的方式形貌长途服务的API，使得调用长途服务更加简朴直观，无需编写底层的HTTP通讯代码。
    
  • Feign通常与Spring Cloud等微服务框架集成，可以与服务注册中心共同使用，实现服务发现、负载平衡等功能。
    
  
  
• HTTP/RESTful API调用：
  
  
  
  • HTTP/RESTful API调用是一种基于HTTP协议的通讯方式，每个微服务提供RESTful API，其他微服务通过发送HTTP哀求来调用服务。这是一种最根本的微服务间通讯方式，使用HTTP协议举行数据传输。
    
  
  
• RPC调用：
  
  
  
  • RPC（长途过程调用）是一种实现微服务之间直接方法调用的方式，无需处置惩罚HTTP协议的细节。通过RPC框架，可以使得一个盘算机步伐可以调用另一个盘算机上的函数或方法，就像调用本地函数一样。
    
  
  

Feign与HTTP的关系和区别

Feign与HTTP之间的关系在于，Feign是一个用于Java语言的声明式HTTP客户端库，它简化了HTTP哀求的编写过程，特殊实用于构建微服务架构中的服务间调用。简朴来说，Feign允许开辟者通过界说接口的方式来实现HTTP哀求的发送，而不须要手动创建哀求体、设置URL、处置惩罚相应等繁琐工作。
在技能层面，Feign背后现实上是对HTTP协议的封装和抽象。当使用Feign界说一个接口并添加相应的HTTP注解（如@GetMapping, @PostMapping等）时，Feign会根据这些注解和接口方法的界说，动态天生实现类。这个实现类会在运行时实行HTTP哀求，与长途服务举行通讯。Feign内部可以设置差别的HTTP客户端实现来举行现实的网络IO利用，比如默认使用Java的HttpURLConnection，也可以设置为使用Apache HttpClient大概OkHttp等其他库来实行这些哀求。
因此，可以说Feign与HTTP是工具与协议的关系，Feign作为一种工具或框架，基于HTTP协议实现了更高条理的抽象，提供了更为便捷的服务调用方式。 
总结就是，Feign和HTTP/RESTful API调用都是基于HTTP协议举行通讯的，它们之间的接洽是Feign实质上是在HTTP/RESTful API调用的底子上举行了封装和简化。Feign是一种更加高级、简化的HTTP/RESTful API调用方式，潜伏了底层的HTTP通讯细节，提供了声明式的接口来形貌长途服务的API，让开辟职员可以像调用本地方法一样来调用长途服务。
RPC与HTTP的关系和区别

雷同点是底层通讯都是基于socket，都可以实现长途调用，都可以实现服务调用服务。
差别点：
RPC调用固然不直接依赖于HTTP协议，但它也可以在HTTP协议的底子上实现。一些RPC框架（比方gRPC）可以使用HTTP/2作为底层传输协议，从而具备更高的性能和服从。
RPC调用是一种更加底层、直接的长途方法调用方式，无需处置惩罚HTTP协议的细节，通常具有更高的性能和服从，但须要引入RPC框架，并在体系中举行服务管理和管理。

既然两种方式都可以实现长途调用，我们该怎样选择呢？

• 速率来看，RPC要比http更快，固然底层都是TCP，但是http协议的信息通常比力痴肥。
  
• 难度来看，RPC实现较为复杂，http相对比力简朴。
  
• 机动性来看，http更胜一筹，由于它不关心实现细节，跨平台、跨语言。
  

RPC和openfeign的关系和区别

接洽：

• 目的雷同：两者都是为了实现微服务之间的通讯。
  
• 可以联合使用：OpenFeign可以看作是长途调用的一种实现方式，使用OpenFeign可以简化长途调用的实现过程，使开辟者更加专注于业务逻辑。
  

区别：
在微服务架构中，长途调用是一个广义的概念，而OpenFeign是实现长途调用的一种特定方式。OpenFeign通过声明式的方式简化了长途调用的复杂性，得当用于须要频仍举行微服务调用的场景。开辟者可以根据项目需求选择得当的方式举行服务间通讯。
Feign和RPC各有千秋，选择应基于项目的具体需求、性能指标、团队认识度以及生态体系的集本钱事。在微服务架构中，两者并非互斥，乃至可根据差别服务的特点，在同一体系中机动搭配使用。明确它们的焦点差异，有助于做出更贴合现实的技能决定。


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！qidao123.com:ToB企服之家，中国第一个企服评测及软件市场,开放入驻,技术点评得现金