RabbitMQ：RPC调用的模拟分析

最新推荐文章于 2024-08-18 20:55:06 发布

编程写手

最新推荐文章于 2024-08-18 20:55:06 发布

阅读量195

点赞数

分类专栏：消息队列

本文链接：https://blog.csdn.net/weixin_45492007/article/details/106215349

版权

消息队列专栏收录该内容

77 篇文章 3 订阅

订阅专栏

1.声明

当前内容主要用于本人学习和复习之用，当前内容为使用RabbitMQ的生产者、消费者、队列实现RPC调用

当前内容来源：RabbitMQ官方文档

分析RPC调用

客户端发送参数请求服务端
服务端处理发送的请求并得到结果
服务端将结果返回到客户端

通过上面的RPC分析可以发现

数据信息可以看作消息
客户端即是消费者又是生产者(获得了消息，发送了消息)
服务端即是消费者又是生产者(处理了消息，返回了消息)

2.创建客户端和服务端

客户端(为它服务发送和接收消息的能力)

public class RPCMClientain {
	public static void main(String[] args) throws IOException, TimeoutException {
		ConnectionFactory factory=new ConnectionFactory();
		Connection conn = factory.newConnection();
		Channel channel = conn.createChannel();
		 UUID randomUUID = UUID.randomUUID(); 
		BasicProperties props = new BasicProperties
                .Builder()
                .correlationId(randomUUID.toString())
                .replyTo("rpc_queue")
                .build();
		channel.basicPublish("", "rpc_queue", props, ("10").getBytes());
		
		System.out.println("发送消息成功===>");
		/*
		 * try { Thread.sleep(5000l); } catch (InterruptedException e) { // TODO
		 * Auto-generated catch block e.printStackTrace(); }
		 */
		System.out.println("开始获取结果===>");
		channel.basicConsume("rpc_queue",true,new DefaultConsumer(channel) {

			@Override
			public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties, byte[] body)
					throws IOException {
				System.out.println("获取结果===>"+StringUtils.toString(body));
				System.out.println(consumerTag);
				System.out.println(properties);
				System.out.println(new String(body,"utf-8"));
				//conn.close();
			}
			
		});

	}
}

服务端(使用官方的例子)

public class RPCServer {

	private static final String RPC_QUEUE_NAME = "rpc_queue";

	private static int doubleNum(int n) {
		return n*2;
	}

	public static void main(String[] argv) throws Exception {
		ConnectionFactory factory = new ConnectionFactory();
		factory.setHost("localhost");

		try (Connection connection = factory.newConnection(); Channel channel = connection.createChannel()) {

			channel.queueDeclare(RPC_QUEUE_NAME, false, false, false, null);
			//channel.queuePurge(RPC_QUEUE_NAME);

			channel.basicQos(1);

			System.out.println(" [x] Awaiting RPC requests");

			Object monitor = new Object();
			DeliverCallback deliverCallback = (consumerTag, delivery) -> {
				AMQP.BasicProperties replyProps = new AMQP.BasicProperties.Builder()
						.correlationId(delivery.getProperties().getCorrelationId()).build();

				String response = "";

				try {
					String message = new String(delivery.getBody(), "UTF-8");
					int n = Integer.parseInt(message);

					System.out.println(" [.] fib(" + message + ")");
					response += doubleNum(n);
					System.out.println("执行完毕后的结果为===>" + response);
				} catch (RuntimeException e) {
					e.printStackTrace();
					System.out.println(" [.] " + e.toString());
				} finally {
					channel.basicPublish("", delivery.getProperties().getReplyTo(), replyProps,
							response.getBytes("UTF-8"));
					channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
					// RabbitMq consumer worker thread notifies the RPC server owner thread
					System.out.println("唤醒工作线程====>");
					synchronized (monitor) {
						monitor.notify();
					}
				}
			};

			channel.basicConsume(RPC_QUEUE_NAME, false, deliverCallback, (consumerTag -> {
			}));
			// Wait and be prepared to consume the message from RPC client.
			while (true) {
				synchronized (monitor) {
					try {
						System.out.println("rpcserver开始阻塞工作线程====>");
						monitor.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		}
	}
}