微服务之间的通信方式

暖风吹向你的脸

目录

• 微服务之间的通信方式
  
• 根据场景选择对应的通信方式
  
• 异步通信区别与选择
  
  
  
  • .Net示例
    
  • java示例
    
  
  

微服务之间的通信方式

微服务之间的通信方式常见的有以下几种：

• 同步通信：微服务之间通过请求-响应的方式进行通信，例如RESTful API和RPC。通信过程中，请求方需要等待响应方的返回结果，因此可靠性较高，但可能会出现请求排队、线程阻塞等问题，从而影响系统的响应速度和并发性能。
  
• 异步通信：微服务之间通过消息队列进行异步通信，例如Kafka和RabbitMQ。通信过程中，发送方向消息队列发送消息，接收方从消息队列中消费消息，消息传输以异步的方式进行，不需要等待接收方的响应。由于解耦性高，消息队列还可以支持发布-订阅模式，消息得以广播到多个服务中，助于构建高可伸缩的系统。不过异步通信也可能导致延迟较高，以及可靠性和容错性较差等问题。
  
• 事件驱动架构（EDA）：微服务之间通过发布-订阅模式进行通信，例如Apache Kafka和AWS SNS/SQS。通信过程中，发布者发布事件，订阅者订阅事件，事件传递以异步的方式进行。通过EDA，不同服务之间可以实现松耦合通信，提高系统的可伸缩性和弹性，但需要谨慎处理网络分区等极端情况，以避免出现一致性等问题。
  

这三种通信方式各有优缺点，可以根据具体业务需求和可用技术进行选择和结合。例如，同步通信适用于低延迟、高可靠的交互，异步通信适用于大数据处理和高性能扩展，EDA适用于事件驱动、松耦合的场景。同时，在实际应用中，也需要注意通信的负载和响应速度等问题，以满足业务的性能和稳定性要求。
根据场景选择对应的通信方式

具体选择哪种通信方式，需要根据业务场景、系统需求和软件架构等多方面考虑，以下简单列举一些案例并建议对应的通信方式：

• 低延迟场景：若要求实时高效的数据交换，需要尽可能缩小请求-响应的时间窗口，此时选择同步通信更为合适。
  
• 高吞吐量场景：若要求高效的消息传输，需要支持高并发和大数据量传输，且强调服务之间的松耦合性，此时选择消息队列（异步通信）更为合适。
  
• 高可靠、数据一致性场景：若需要确保每个操作和消息都被发送且正确接收到，即保障系统的基本可靠性和数据一致性，则选择同步通信更为合适。
  
• 多个服务之间的通信：若有多个服务需要共享同一份数据或事件，或者多个服务需要响应同一份消息，则选择消息队列（异步通信）或者事件驱动（EDA）更为合适。
  
• 对接外部系统：若需要对接外部数据源、第三方系统或者不同语言共存的服务，则需基于标准协议和规范来进行同步通信，例如RESTful API和gRPC等。
  

需要注意的是，在实际应用中，选择通信方式时需综合考虑多种因素，如系统复杂性、可伸缩性、扩展性和易用性等，不同情境下通信方式的选择也会有所不同。
异步通信区别与选择

Kafka和RabbitMQ都是消息队列系统，它们的主要区别包括：

• 通信模型：Kafka基于发布-订阅模型，而RabbitMQ则采用了AMQP协议、MQTT协议等不同模型，支持点对点和发布-订阅等模型。
  
• 性能与可靠性：Kafka在高并发、大数据流时表现更出色，可实现每秒百万级别的数据处理；而RabbitMQ采用了AMQP协议，能够保证消息传输的可靠性和事务处理能力。
  
• 数据存储：Kafka将消息以文件的形式存储在磁盘上，存储的消息不会立刻被消费；而RabbitMQ则采用内存缓存，消息一旦发送就会立刻被消费掉，存储的消息数受到限制。
  
• 集群架构：Kafka支持集群架构的高可用和分区；而RabbitMQ则基于主从架构，支持镜像队列、负载均衡等机制。
  

建议在以下场景中选择Kafka：

• 数据处理非常高频且有较高的时效性要求；
  
• 数据需要全量存储，不需要所读视图；
  
• 需要水平扩展的需求，适用于分布式的架构；
  
• 对于数据处理不同步，时间戳重要，允许有少量的丢失情况。
  

建议在以下场景中选择RabbitMQ：

• 所有的任务都需要被迅速处理；
  
• 数据不需要永久存储，只需要消费了就可以丢弃；
  
• 业务场景需要精细控制传输过程，支持异步的传输方式；
  
• 消息处理过程考虑到事务性相关的问题，需要提供可靠的传输保障。
  

需要根据具体的业务需求、可用的技术方案和系统架构等选择合适的消息队列系统。
.Net示例

1. csharpCopy code
2. using RabbitMQ.Client;
3. using System;
5. namespace RabbitMQSender
6. {
7.     Program
8.     {
9.         static void Main(string[] args)
10.         {
11.             var factory = new ConnectionFactory { HostName = "localhost", UserName="guest", Password="guest" };
12.             usingvar connection = factory.CreateConnection())
13.             using (var channel = connection.CreateModel())
14.             {
15. channel.QueueDeclare(queue: "hello",
16.                                      durable: false,
17.                                      exclusive: false,
18. autoDelete: false,
19.                                      arguments: null);
20.                 string message = "Hello World!";
21.                 body = System.Text.Encoding.UTF8.GetBytes(message);
22.                 channel.BasicPublish(exchange: "",
23.                                      routingKey: "hello",
24.                                      basicProperties: null,
25.                                      body: body);
26.                 Console(" [x] Sent {0}", message);
27.             }
28.             Console.WriteLine(" Press Enter to exit.");
29.             Console.ReadLine();
30.         }
31.     }
32. }

复制代码

接收消息：

1. csharpusingCopy code
2. using RabbitMQ.Client.Events;
3. using System;
4. using System.Text;
6. namespace RabbitMQReceiver
7. {
8.     class Program
9.     {
10.         static void Main(string[] args)
11.         {
12.             var factory = new ConnectionFactory() { HostName = "localhost", UserName="guest Password="guest" };
13.             using (var connection = factory.CreateConnection())
14.             using (var = connection.CreateModel())
15.             {
16.                 channel.QueueDeclare(queue: "hello",
17.                                      durable:,
18.                                      exclusive: false,
19.                                      autoDelete: false,
20.                                      arguments: null);
22.                 var consumer = new EventingBasicConsumer(channel);
23.                 consumer.Received += (model ea) =>
24.                 {
25.                     var body = ea.Body.ToArray();
26.                     var message = Encoding.UTF.GetString(body);
27.                     Console.WriteLine(" [x] Received {0}", message);
28.                 };
29.                .BasicConsume(queue: "hello",
30.                                      autoAck: true,
31.                                      consumer: consumer                Console.WriteLine(" Press [enter] to exit.");
32.                 Console.ReadLine();
33.             }
34.         }
35.     }
36. }

复制代码

这个示例中，我们先创建了一个Connection和Channel实例。然后我们声明了一个队列，之后发送一条消息，同时也显示了发送的消息。
接着，我们使用EventingBasicConsumer类建立了一个费者，并订阅了“Received”事件。在事件触发时，我们将收到的消息转换为字符串并加以打印。然后使用BasicConsume方法开始了消息的订阅。
java示例

1.安装RabbitMQ管理界面和客户端
在Web浏览器上打开http://localhost:15672/，通过用户guest和密码guest登录。接，使用Maven或Gradle安装amqp-client客户端。

• 发送消息，首先，需要创建队列和连接，如下示例代码所示：
  

1. javaCopy code
2. import com.rabbitmq.client.ConnectionFactory;
3. import com.rabbitmq.client.Connection;
4. import com.rabbitmq.client.Channel;
5. public class RMQSender {
6.     private final static String QUEUE_NAME = "hello";
7.     public static void main(String[] args) throws Exception {
8.         ConnectionFactory factory = ConnectionFactory();
9.         factory.setHost("localhost");
10.         try (Connection connection = factory.newConnection();
11.              Channel channel = connection.createChannel()) {
12.             channel.queueDeclare(QUEUE_NAME, false, false, false, null);
13.             String message = "Hello World!";
14.             channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
15.             System.out.println("Sent '" + message + "'");
16.         }
17.     }
18. }

复制代码

3.接收消息，接收消息的程序需要通过建立一个Consumer实例来监听Queue队列。如下所示：

1. javaCopy code
2. import com.rabbitmq.client.ConnectionFactory;
3. import com.rabbitmq.client.Connection;
4. import com.rabbitmq.client.Channel;
5. import com.rabbitmq.client.Consumer;
6. import com.rabbitmq.client.DefaultConsumer;
7. import com.rabbitmq.client.Envelope;
8. public class RMQReceiver {
9.     private final static String QUEUE_NAME = "hello";
10.     public static void main(String[] args) throws Exception {
11.         ConnectionFactory factory = ConnectionFactory();
12.         factory.setHost("localhost");
13.         Connection connection = factory.newConnection();
14.         Channel channel = connection.createChannel();
15.         channel.queueDeclare(QUEUE_NAME, false, false, false, null);
16.         System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
17.         Consumer consumer = new DefaultConsumer(channel) {
18.             @Override
19.             public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
20.                 String message = new String(body, "UTF-8");
21.                 System.out.println(" [x] Received '" + message + "'");
22.             }
23.         };
24.         channel.basicConsume(QUEUE_NAME, true, consumer);
25.     }
26. }

复制代码

以上就是一个简单的使用RabbitMQ的Java示例。需要注意的是，在使用RabbitMQ的时候，应该注意消息生态系统的架构设计，确保消息可靠性。

来源:https://www.cnblogs.com/AJun816/archive/2023/05/17/17410401.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！