RabbitMQ 客户端 com.rabbitmq:amqp-client:5.10.0

最新推荐文章于 2024-06-05 10:52:59 发布
最新推荐文章于 2024-06-05 10:52:59 发布
阅读量1.6k 收藏 2
点赞数
分类专栏： 中间件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mrathena/article/details/110502250
版权

博文目录

文章目录

Connection 和 Channel 的获取与关闭

package com.mrathena;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

public final class CommonKit {

	private CommonKit() {}

	public static Channel getChannel() {
		try {
			ConnectionFactory factory = new ConnectionFactory();
			factory.setHost("116.62.162.48");
			factory.setPort(5672);
			// 所有测试都是用这一个账户
			factory.setUsername("mrathena");
			factory.setPassword("password");
			// 所有测试都是用这一个VirtualHost
			factory.setVirtualHost("test");
			// 获取TCP长连接
			Connection connection = factory.newConnection();
			// 创建通信“通道”，相当于TCP中的虚拟连接
			Channel channel = connection.createChannel();
			// channel.close();
			// connection.close();
			return channel;
		} catch (Throwable cause) {
			throw new RuntimeException(cause);
		}
	}

	public static void closeChannelAndConnection(Channel channel) {
		try {
			if (!channel.isOpen()) {
				return;
			}
			Connection connection = channel.getConnection();
			channel.close();
			if (connection.isOpen()) {
				connection.close();
			}
		} catch (Throwable cause) {
			cause.printStackTrace();
		}
	}

}

HelloWorld 简单模式 队列-单个消费者

package com.mrathena;

import com.mrathena.constant.Constant;
import com.mrathena.toolkit.ThreadKit;
import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;

import java.io.IOException;

@Slf4j
public class HelloWorldModeTest {

	private static final String QUEUE = "queue-hello-world";

	@Test
	public void consumerTest() {
		Channel channel = CommonKit.getChannel();
		try {
			// 声明一个队列(不存在则自动创建), 如果队列已存在, 则使用这个队列
			// 第一个参数: 队列名
			// 第二个参数: 是否持久化, false对应不持久化数据, MQ停掉数据就会丢失
			// 第三个参数: 是否队列私有化, false则代表所有消费者都可以访问, true代表只有第一次拥有它的消费者才能一直使用, 其他消费者不让访问
			// 第四个参数: 是否自动删除, false代表连接停掉后不自动删除掉这个队列
			// 第四个参数: 其他额外的参数, null
			// 注意: 如果队列已存在, 但是这里声明的队列和已存在队列的属性不一致, 则启动会报错, 如已存在队列是durable的, 而这里第二个参数是false, 启动的时候就会报错
			channel.queueDeclare(QUEUE, false, false, false, null);

			// channel.basicQos(1)指该消费者在接收到队列里的消息但没有返回确认结果之前,它不会将新的消息分发给它。
			// 假如有两个消费者，在处理消息的时候，分别休眠10，1000毫秒，默认的任务分发机制，会使两个消费者获取相同的消息数量。
			// 更合理的方式是，休眠少的消费者多劳，消费更多的消息，channel.basicQos(1)能使休眠多的消费者接受更少的消息数量，而不再是公平分发数量。
			// 无 channel.basicQos(1), MQ会将所有请求平均发送给所有消费者, 不管你消费的快还是慢
			// 有 channel.basicQos(1), MQ不再对消费者一次发送多个请求，而是消费者处理完一个消息后（确认后），再从队列中获取一个新的, 再消费
			// 每次推送多个的话, 是否可以配合basicAck(true)来使用
			channel.basicQos(1);

			// 创建一个消息消费者
			// 第一个参数: 队列名
			// 第二个参数: 代表是否自动确认收到消息, false代表手动编程来确认消息(消费者端), 这是MQ的推荐做法, 自动提交?
			// 第三个参数: 要传入DefaultConsumer的实现类, 居然可以不使用子类, 直接new本类并覆盖某一个方法
			channel.basicConsume(QUEUE, false, new DefaultConsumer(channel) {
				public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
					long deliveryTag = envelope.getDeliveryTag();
					log.info("收到消息: {}", new String(body));
					// false只确认签收当前的消息, 设置为true的时候则代表签收该消费者所有未签收的消息
					channel.basicAck(deliveryTag, false);
				}
			});
		} catch (Throwable cause) {
			cause.printStackTrace();
		}
		ThreadKit.sleepSecond(30);
		CommonKit.closeChannelAndConnection(channel);
	}

	@Test
	public void producerTest() {
		try {
			Channel channel = CommonKit.getChannel();
			channel.queueDeclare(QUEUE, false, false, false, null);
			for (int i = 0; i < 10; i++) {
				// 发布消息
				// exchange: 交换机，暂时用不到，在后面进行发布订阅时才会用到
				// routingKey: 这里可认为是队列名称?
				// props: 额外的设置属性
				// body: 消息的字节数组
				channel.basicPublish(Constant.EMPTY, QUEUE, null, String.valueOf(i + 1).getBytes());
			}
			CommonKit.closeChannelAndConnection(channel);
		} catch (Throwable cause) {
			cause.printStackTrace();
		}
	}

}

WorkQueue 工作队列模式 队列-多个消费者(竞争关系)

package com.mrathena;

import com.mrathena.constant.Constant;
import com.mrathena.toolkit.ThreadKit;
import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;

import java.io.IOException;

@Slf4j
public class WorkQueuesModeTest {

	private static final String QUEUE = "queue-work-queues";

	@Test
	public void consumerTest() {
		// 假装是两个客户端, 竞争关系
		Channel channel = CommonKit.getChannel();
		try {
			channel.queueDeclare(QUEUE, false, false, false, null);
			// 无 channel.basicQos(1), MQ会将所有请求平均发送给所有消费者, 不管你消费的快还是慢
			// 有 channel.basicQos(1), MQ不再对消费者一次发送多个请求，而是消费者处理完一个消息后（确认后），再从队列中获取一个新的, 再消费
			// 即每次从队列里拿多少个, 可以配合basicAck(true)的那种方式来使用
			channel.basicQos(1);
			channel.basicConsume(QUEUE, false, new DefaultConsumer(channel) {
				public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
					log.info("Consumer1, 收到消息: {}", new String(body));
					//false只确认签收当前的消息，设置为true的时候则代表签收该消费者所有未签收的消息
					channel.basicAck(envelope.getDeliveryTag(), false);
					ThreadKit.sleepMilli(1000);
				}
			});
		} catch (Throwable cause) {
			cause.printStackTrace();
		}
		ThreadKit.sleepSecond(30);
		CommonKit.closeChannelAndConnection(channel);
	}

	@Test
	public void consumer2Test() {
		// 假装是两个客户端, 竞争关系
		Channel channel = CommonKit.getChannel();
		try {
			channel.queueDeclare(QUEUE, false, false, false, null);
			channel.basicQos(1);
			channel.basicConsume(QUEUE, false, new DefaultConsumer(channel) {
				public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
					log.info("Consumer2, 收到消息: {}", new String(body));
					channel.basicAck(envelope.getDeliveryTag(), false);
//					ThreadKit.sleepMilli(100);
				}
			});
		} catch (Throwable cause) {
			cause.printStackTrace();
		}
		ThreadKit.sleepSecond(30);
		CommonKit.closeChannelAndConnection(channel);
	}

	@Test
	public void producerTest() {
		try {
			Channel channel = CommonKit.getChannel();
			channel.queueDeclare(QUEUE, false, false, false, null);
			for (int i = 0; i < 10; i++) {
				channel.basicPublish(Constant.EMPTY, QUEUE, null, String.valueOf(i + 1).getBytes());
			}
			CommonKit.closeChannelAndConnection(channel);
		} catch (Throwable cause) {
			cause.printStackTrace();
		}
	}

}

PublishSubscribe 发布订阅模式(广播模式) 绑定到交换机的队列都能收到消息

package com.mrathena;

import com.mrathena.constant.Constant;
import com.mrathena.toolkit.ThreadKit;
import com.rabbitmq.client.*;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;

import java.io.IOException;

@Slf4j
public class PublishSubscribeModeTest {

	/**
	 * 广播类型的交换机
	 */
	private static final String EXCHANGE_FANOUT = "exchange-fanout";
	private static final String QUEUE1 = "queue-publish-subscribe-1";
	private static final String QUEUE2 = "queue-publish-subscribe-2";

	@Test
	public void consumer1Test() {
		// 两个客户端, 分别连接两个队列, 然后这两个队列都绑定到同一个交换机, 交换机将每条消息都发送到两个队列
		Channel channel = CommonKit.getChannel();
		try {
			channel.queueDeclare(QUEUE1, false, false, false, null);
			// 声明一个交换机(不存在则自动创建)
			// exchange: 交换机名
			// type: 交换器的类型，常见的有direct,fanout,topic等
			// durable: 设置是否持久化。durable设置为true时表示持久化，反之非持久化.持久化可以将交换器存入磁盘，在服务器重启的时候不会丢失相关信息。
			// autoDelete: 设置是否自动删除。autoDelete设置为true时，则表示自动删除。自动删除的前提是至少有一个队列或者交换器与这个交换器绑定，之后，所有与这个交换器绑定的队列或者交换器都与此解绑。不能错误的理解—当与此交换器连接的客户端都断开连接时，RabbitMq会自动删除本交换器
			// internal: 设置是否内置的。如果设置为true，则表示是内置的交换器，客户端程序无法直接发送消息到这个交换器中，只能通过交换器路由到交换器这种方式。
			// arguments: 其他额外的参数, null
			// exchangeDeclareNoWait 相关方法, 意思是不需要服务器返回，返回值为void，而普通的exchangeDeclare返回的是Exchange.DeclareOk,客户端声明一交换器后，需要等待服务器的返回. nowait:在声明完一个交换器后，实际上服务器还未完成交换器的创建，那么客户端接着使用这个交换吕，必然发生异常，
			channel.exchangeDeclare(EXCHANGE_FANOUT, BuiltinExchangeType.FANOUT, false, false, false, null);
			// 队列绑定到交换机
			// queue: 队列
			// exchange: 交换机
			// routingKey: 广播模式的交换机无需routingKey, 传空字符串
			// 还有 exchangeBind 方法, 是将两个exchange绑定, 生产者发送消息到source交换器中，source根据路由键找到与其匹配的另一个交换器destination，并把消息转发到destination中，进而存储在destination绑定的队列queue中
			channel.queueBind(QUEUE1, EXCHANGE_FANOUT, Constant.EMPTY);
			channel.basicQos(1);
			channel.basicConsume(QUEUE1, false, new DefaultConsumer(channel) {
				public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
					log.info("Consumer1, 收到消息: {}", new String(body));
					channel.basicAck(envelope.getDeliveryTag(), false);
				}
			});
		} catch (Throwable cause) {
			cause.printStackTrace();
		}
		ThreadKit.sleepSecond(30);
		CommonKit.closeChannelAndConnection(channel);
	}

	@Test
	public void consumer2Test() {
		// 两个客户端, 分别连接两个队列, 然后这两个队列都绑定到同一个交换机, 交换机将每条消息都发送到两个队列
		Channel channel = CommonKit.getChannel();
		try {
			channel.queueDeclare(QUEUE2, false, false, false, null);
			channel.exchangeDeclare(EXCHANGE_FANOUT, BuiltinExchangeType.FANOUT, false, false, false, null);
			channel.queueBind(QUEUE2, EXCHANGE_FANOUT, Constant.EMPTY);
			channel.basicQos(1);
			channel.basicConsume(QUEUE2, false, new DefaultConsumer(channel) {
				public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
					log.info("Consumer2, 收到消息: {}", new String(body));
					channel.basicAck(envelope.getDeliveryTag(), false);
				}
			});
		} catch (Throwable cause) {
			cause.printStackTrace();
		}
		ThreadKit.sleepSecond(30);
		CommonKit.closeChannelAndConnection(channel);
	}

	@Test
	public void producerTest() {
		try {
			Channel channel = CommonKit.getChannel();
			channel.exchangeDeclare(EXCHANGE_FANOUT, BuiltinExchangeType.FANOUT, false, false, false, null);
			for (int i = 0; i < 10; i++) {
				// 发布消息
				// exchange: 交换机, 广播模式
				// routingKey: 这里可认为是队列名称?
				// props: 额外的设置属性
				// body: 消息的字节数组
				channel.basicPublish(EXCHANGE_FANOUT, Constant.EMPTY, null, String.valueOf(i + 1).getBytes());
			}
			CommonKit.closeChannelAndConnection(channel);
		} catch (Throwable cause) {
			cause.printStackTrace();
		}
	}

}

Routing 路由模式 绑定交换机且指定的队列才能收到消息

package com.mrathena;

import com.mrathena.toolkit.ThreadKit;
import com.rabbitmq.client.*;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

@Slf4j
public class RoutingModeTest {

	/**
	 * 定向类型的交换机
	 */
	private static final String EXCHANGE_DIRECT = "exchange-direct";
	private static final String QUEUE1 = "queue-routing-1";
	private static final String QUEUE2 = "queue-routing-2";
	private static final String KEY_FOO_1 = "routing.key.foo.1";
	private static final String KEY_FOO_2 = "routing.key.foo.2";
	private static final String KEY_BAR_1 = "routing.key.bar.1";
	private static final String KEY_BAR_2 = "routing.key.bar.2";
	private static final String KEY_OTHER = "routing.key.other.what.the.fuck";

	@Test
	public void consumer1Test() {
		// 两个客户端, 分别连接两个队列, 然后这两个队列都绑定到同一个交换机, 交换机按routingKey匹配将消息推送到不同队列
		Channel channel = CommonKit.getChannel();
		try {
			channel.queueDeclare(QUEUE1, false, false, false, null);
			channel.exchangeDeclare(EXCHANGE_DIRECT, BuiltinExchangeType.DIRECT, false, false, false, null);
			// queue-routing-1 绑定 exchange-direct, 且 routingKey是routing.key.foo.1, 只能收到该routingKey的消息
			// 注意: 一旦绑定过, 就会一直保持, 除非调用 channel.queueUnbind() 解除绑定, 具体的绑定关系可以从Web管理页面的Queue里查看
			channel.queueBind(QUEUE1, EXCHANGE_DIRECT, KEY_FOO_1);
			channel.basicQos(1);
			channel.basicConsume(QUEUE1, false, new DefaultConsumer(channel) {
				public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
					log.info("Consumer1, 收到消息: {}", new String(body));
					channel.basicAck(envelope.getDeliveryTag(), false);
				}
			});
		} catch (Throwable cause) {
			cause.printStackTrace();
		}
		ThreadKit.sleepSecond(30);
		CommonKit.closeChannelAndConnection(channel);
	}

	@Test
	public void consumer2Test() {
		// 两个客户端, 分别连接两个队列, 然后这两个队列都绑定到同一个交换机, 交换机按routingKey匹配将消息推送到不同队列
		Channel channel = CommonKit.getChannel();
		try {
			channel.queueDeclare(QUEUE2, false, false, false, null);
			channel.exchangeDeclare(EXCHANGE_DIRECT, BuiltinExchangeType.DIRECT, false, false, false, null);
			// queue-routing-1 绑定 exchange-direct, 且 routingKey绑定了3个, 能收到这3个routingKey的消息
			channel.queueBind(QUEUE2, EXCHANGE_DIRECT, KEY_BAR_1);
			channel.queueBind(QUEUE2, EXCHANGE_DIRECT, KEY_BAR_2);
			channel.queueBind(QUEUE2, EXCHANGE_DIRECT, KEY_OTHER);
			channel.basicQos(1);
			channel.basicConsume(QUEUE2, false, new DefaultConsumer(channel) {
				public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
					log.info("Consumer2, 收到消息: {}", new String(body));
					channel.basicAck(envelope.getDeliveryTag(), false);
				}
			});
		} catch (Throwable cause) {
			cause.printStackTrace();
		}
		ThreadKit.sleepSecond(30);
		CommonKit.closeChannelAndConnection(channel);
	}

	@Test
	public void consumer3Test() {
		// 测试consumer3和consumer2是否竞争消费同一个队列, 测试说明: 是的, 在有交换机参与的情况下, 仍然可以给某一个队列组WorkQueues
		Channel channel = CommonKit.getChannel();
		try {
			channel.queueDeclare(QUEUE2, false, false, false, null);
			channel.exchangeDeclare(EXCHANGE_DIRECT, BuiltinExchangeType.DIRECT, false, false, false, null);
			// queue-routing-1 绑定 exchange-direct, 且 routingKey绑定了3个, 能收到这3个routingKey的消息
			channel.queueBind(QUEUE2, EXCHANGE_DIRECT, KEY_BAR_1);
			channel.queueBind(QUEUE2, EXCHANGE_DIRECT, KEY_BAR_2);
			channel.queueBind(QUEUE2, EXCHANGE_DIRECT, KEY_OTHER);
			channel.basicQos(1);
			channel.basicConsume(QUEUE2, false, new DefaultConsumer(channel) {
				public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
					log.info("Consumer3, 收到消息: {}", new String(body));
					channel.basicAck(envelope.getDeliveryTag(), false);
				}
			});
		} catch (Throwable cause) {
			cause.printStackTrace();
		}
		ThreadKit.sleepSecond(30);
		CommonKit.closeChannelAndConnection(channel);
	}

	@Test
	public void producerTest() {
		Map<String, String> data = new HashMap<>();
		data.put(KEY_FOO_1, "value.foo.1");
		data.put(KEY_FOO_2, "value.foo.2");
		data.put(KEY_BAR_1, "value.bar.1");
		data.put(KEY_BAR_2, "value.bar.2");
		data.put(KEY_OTHER, "value.other");
		try {
			Channel channel = CommonKit.getChannel();
			channel.exchangeDeclare(EXCHANGE_DIRECT, BuiltinExchangeType.DIRECT, false, false, false, null);
			for (Map.Entry<String, String> entry : data.entrySet()) {
				channel.basicPublish(EXCHANGE_DIRECT, entry.getKey(), null, entry.getValue().getBytes());
			}
			CommonKit.closeChannelAndConnection(channel);
		} catch (Throwable cause) {
			cause.printStackTrace();
		}
	}

}

Topics 主题模式 绑定交换机且符合条件的队列才能收到消息

package com.mrathena;

import com.mrathena.constant.Constant;
import com.mrathena.toolkit.ThreadKit;
import com.rabbitmq.client.*;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

@Slf4j
public class TopicsModeTest {

	/**
	 * 主题类型的交换机
	 */
	private static final String EXCHANGE_TOPIC = "exchange-topic";
	private static final String QUEUE1 = "queue-topics-1";
	private static final String QUEUE2 = "queue-topics-2";
	private static final String QUEUE3 = "queue-topics-3";
	private static final String QUEUE4 = "queue-topics-4";
	private static final String QUEUE5 = "queue-topics-5";
	private static final String QUEUE6 = "queue-topics-6";
	private static final String KEY_FOO_1 = "routing.key.foo.1";
	private static final String KEY_FOO_2 = "routing.key.foo.2";
	private static final String KEY_BAR_1 = "routing.key.bar.1";
	private static final String KEY_BAR_2 = "routing.key.bar.2";
	private static final String KEY_OTHER = "routing.key.other.what.the.fuck";

	@Test
	public void consumer1Test() {
		// 两个客户端, 分别连接两个队列, 然后这两个队列都绑定到同一个交换机, 交换机按routingKey匹配将消息推送到不同队列
		Channel channel = CommonKit.getChannel();
		try {
			channel.queueDeclare(QUEUE1, false, false, false, null);
			channel.exchangeDeclare(EXCHANGE_TOPIC, BuiltinExchangeType.TOPIC, false, false, false, null);
			// queue-topics-1 绑定 exchange-topic, 且 routingKey是routing.key.foo.*, 只收 routing.key.foo.xxx 这种key的消息, * 代表一个分段, # 代表多个分段
			channel.queueBind(QUEUE1, EXCHANGE_TOPIC, "routing.key.foo.*");
			channel.basicQos(1);
			channel.basicConsume(QUEUE1, false, new DefaultConsumer(channel) {
				public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
					log.info("Consumer1, 收到消息: {}", new String(body));
					channel.basicAck(envelope.getDeliveryTag(), false);
				}
			});
		} catch (Throwable cause) {
			cause.printStackTrace();
		}
		ThreadKit.sleepSecond(30);
		CommonKit.closeChannelAndConnection(channel);
	}

	@Test
	public void consumer2Test() {
		// 两个客户端, 分别连接两个队列, 然后这两个队列都绑定到同一个交换机, 交换机按routingKey匹配将消息推送到不同队列
		Channel channel = CommonKit.getChannel();
		try {
			channel.queueDeclare(QUEUE2, false, false, false, null);
			channel.exchangeDeclare(EXCHANGE_TOPIC, BuiltinExchangeType.TOPIC, false, false, false, null);
			// queue-routing-1 绑定 exchange-direct, routingKey是routing.#.1, 只收 routing.#.1 这种key的消息, * 代表一个分段, # 代表多个分段
			channel.queueBind(QUEUE2, EXCHANGE_TOPIC, "routing.#.1");
			channel.basicQos(1);
			channel.basicConsume(QUEUE2, false, new DefaultConsumer(channel) {
				public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
					log.info("Consumer2, 收到消息: {}", new String(body));
					channel.basicAck(envelope.getDeliveryTag(), false);
				}
			});
		} catch (Throwable cause) {
			cause.printStackTrace();
		}
		ThreadKit.sleepSecond(30);
		CommonKit.closeChannelAndConnection(channel);
	}

	@Test
	public void consumer3Test() {
		// 两个客户端, 分别连接两个队列, 然后这两个队列都绑定到同一个交换机, 交换机按routingKey匹配将消息推送到不同队列
		Channel channel = CommonKit.getChannel();
		try {
			channel.queueDeclare(QUEUE3, false, false, false, null);
			channel.exchangeDeclare(EXCHANGE_TOPIC, BuiltinExchangeType.TOPIC, false, false, false, null);
			// queue-routing-1 绑定 exchange-direct, routingKey是routing.#.1, 只收 routing.key.*.* 这种key的消息, * 代表一个分段, # 代表多个分段
			channel.queueBind(QUEUE3, EXCHANGE_TOPIC, "routing.key.*.*");
			channel.basicQos(1);
			channel.basicConsume(QUEUE3, false, new DefaultConsumer(channel) {
				public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
					log.info("Consumer3, 收到消息: {}", new String(body));
					channel.basicAck(envelope.getDeliveryTag(), false);
				}
			});
		} catch (Throwable cause) {
			cause.printStackTrace();
		}
		ThreadKit.sleepSecond(30);
		CommonKit.closeChannelAndConnection(channel);
	}

	@Test
	public void consumer4Test() {
		// 两个客户端, 分别连接两个队列, 然后这两个队列都绑定到同一个交换机, 交换机按routingKey匹配将消息推送到不同队列
		Channel channel = CommonKit.getChannel();
		try {
			channel.queueDeclare(QUEUE4, false, false, false, null);
			channel.exchangeDeclare(EXCHANGE_TOPIC, BuiltinExchangeType.TOPIC, false, false, false, null);
			// queue-routing-1 绑定 exchange-direct, routingKey是routing.#.1, 只收 routing.key.# 这种key的消息, * 代表一个分段, # 代表多个分段
			channel.queueBind(QUEUE4, EXCHANGE_TOPIC, "routing.key.#");
			channel.basicQos(1);
			channel.basicConsume(QUEUE4, false, new DefaultConsumer(channel) {
				public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
					log.info("Consumer4, 收到消息: {}", new String(body));
					channel.basicAck(envelope.getDeliveryTag(), false);
				}
			});
		} catch (Throwable cause) {
			cause.printStackTrace();
		}
		ThreadKit.sleepSecond(30);
		CommonKit.closeChannelAndConnection(channel);
	}

	@Test
	public void consumer5Test() {
		// 两个客户端, 分别连接两个队列, 然后这两个队列都绑定到同一个交换机, 交换机按routingKey匹配将消息推送到不同队列
		Channel channel = CommonKit.getChannel();
		try {
			channel.queueDeclare(QUEUE5, false, false, false, null);
			channel.exchangeDeclare(EXCHANGE_TOPIC, BuiltinExchangeType.TOPIC, false, false, false, null);
			// queue-routing-1 绑定 exchange-direct, routingKey是明确的"routing.key.other.what.the.fuck", 测试说明topic模式下是支持明确RoutingKey的
			channel.queueBind(QUEUE5, EXCHANGE_TOPIC, KEY_OTHER);
			channel.basicQos(1);
			channel.basicConsume(QUEUE5, false, new DefaultConsumer(channel) {
				public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
					log.info("Consumer5, 收到消息: {}", new String(body));
					channel.basicAck(envelope.getDeliveryTag(), false);
				}
			});
		} catch (Throwable cause) {
			cause.printStackTrace();
		}
		ThreadKit.sleepSecond(30);
		CommonKit.closeChannelAndConnection(channel);
	}

	@Test
	public void consumer6Test() {
		// 两个客户端, 分别连接两个队列, 然后这两个队列都绑定到同一个交换机, 交换机按routingKey匹配将消息推送到不同队列
		Channel channel = CommonKit.getChannel();
		try {
			channel.queueDeclare(QUEUE6, false, false, false, null);
			channel.exchangeDeclare(EXCHANGE_TOPIC, BuiltinExchangeType.TOPIC, false, false, false, null);
			// queue-routing-1 绑定 exchange-direct, routingKey是明确的空字符串, 测试说明topic模式下是支持类似广播模式的效果, 不过需要发送时RoutingKey也是空字符串
			channel.queueBind(QUEUE6, EXCHANGE_TOPIC, Constant.EMPTY);
			channel.basicQos(1);
			channel.basicConsume(QUEUE6, false, new DefaultConsumer(channel) {
				public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
					log.info("Consumer6, 收到消息: {}", new String(body));
					channel.basicAck(envelope.getDeliveryTag(), false);
				}
			});
		} catch (Throwable cause) {
			cause.printStackTrace();
		}
		ThreadKit.sleepSecond(30);
		CommonKit.closeChannelAndConnection(channel);
	}

	@Test
	public void producerTest() {
		// 每次发送消息都会给所有绑定该交换机并且路由键匹配的队列发送消息, 有任何一个队列没有被消费, 则消息就会积压
		Map<String, String> data = new HashMap<>();
		data.put(KEY_FOO_1, "value.foo.1");
		data.put(KEY_FOO_2, "value.foo.2");
		data.put(KEY_BAR_1, "value.bar.1");
		data.put(KEY_BAR_2, "value.bar.2");
		data.put(KEY_OTHER, "value.other");
		try {
			Channel channel = CommonKit.getChannel();
			channel.exchangeDeclare(EXCHANGE_TOPIC, BuiltinExchangeType.TOPIC, false, false, false, null);
			CommonKit.closeChannelAndConnection(channel);
		} catch (Throwable cause) {
			cause.printStackTrace();
		}
	}

	@Test
	public void producer6Test() {
		Map<String, String> data = new HashMap<>();
		data.put(KEY_FOO_1, "value.foo.1");
		data.put(KEY_FOO_2, "value.foo.2");
		data.put(KEY_BAR_1, "value.bar.1");
		data.put(KEY_BAR_2, "value.bar.2");
		data.put(KEY_OTHER, "value.other");
		try {
			Channel channel = CommonKit.getChannel();
			channel.exchangeDeclare(EXCHANGE_TOPIC, BuiltinExchangeType.TOPIC, false, false, false, null);
			for (Map.Entry<String, String> entry : data.entrySet()) {
				channel.basicPublish(EXCHANGE_TOPIC, Constant.EMPTY, null, entry.getValue().getBytes());
			}
			CommonKit.closeChannelAndConnection(channel);
		} catch (Throwable cause) {
			cause.printStackTrace();
		}
	}

}

监听测试(Confirm/Return)

package com.mrathena;

import com.mrathena.toolkit.ThreadKit;
import com.rabbitmq.client.*;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;

import java.io.IOException;

/**
 * 消息确认机制测试(与消费者无关)
 * 会有两种状态
 * 消息有没有送到Broker(confirm)
 * - 送到了,返回ack(正常情况)
 * - 没送到,返回nack
 * 消息有没有被MQ送到Queue(return)
 * confirm一定是ack
 * - 送到了
 * - 送不到,回退给生产者(队列没有绑定匹配的路由键)
 */
@Slf4j
public class ConfirmTest {

	private static final String EXCHANGE_TOPIC_CONFIRM = "exchange-topic-confirm";
	private static final String EXCHANGE_TOPIC_CONFIRM_NOT_EXIST = "exchange-topic-confirm-not-exist";
	private static final String QUEUE_CONFIRM = "queue-confirm";
	private static final String KEY_CONFIRM = "routing.key.confirm";
	private static final String KEY_NOT_EXIST = "routing.key.not.exist";

	@Test
	public void test() {
		try {
			Channel channel = CommonKit.getChannel();
			// 开启 confirm 的监听
			channel.confirmSelect();
			// 添加 ConfirmListener 监听
			channel.addConfirmListener(new ConfirmListener() {
				@Override
				public void handleAck(long deliveryTag, boolean multiple) throws IOException {
					// multiple代表接收的数据是否为批量接收, 一般用不到
					log.info("ack true : {}", deliveryTag);
				}

				@Override
				public void handleNack(long deliveryTag, boolean multiple) throws IOException {
					// 不太好模拟
					log.info("ack false : {}", deliveryTag);
				}
			});
			// 添加 ReturnListener 监听
			channel.addReturnListener(new ReturnListener() {
				@Override
				public void handleReturn(int replyCode, String replyText, String exchange, String routingKey, AMQP.BasicProperties properties, byte[] body) throws IOException {
					log.info("return : {}", new String(body));
//					log.info("replyCode:{}, replyText:{}, exchange:{}, routingKey:{}, context:{}", replyCode, replyText, exchange, routingKey, new String(body));
				}
			});
			channel.queueDeclare(QUEUE_CONFIRM, false, false, false, null);
			channel.exchangeDeclare(EXCHANGE_TOPIC_CONFIRM, BuiltinExchangeType.TOPIC, false, false, false, null);
			channel.queueBind(QUEUE_CONFIRM, EXCHANGE_TOPIC_CONFIRM, KEY_CONFIRM);
			// 这里使用另一个发布的api
			// mandatory: true:如果消息无法正常投递到Queue则return给生产者, false:无法正常投递的消息直接丢弃
			channel.basicPublish(EXCHANGE_TOPIC_CONFIRM, KEY_CONFIRM, true, null, "value".getBytes());
			// 奇怪, exchange不存在的时候, confirm监听就失效了, 而且导致其他ok的也一起失效了
//			channel.basicPublish(EXCHANGE_TOPIC_CONFIRM_NOT_EXIST, KEY_CONFIRM, true, null, "value".getBytes());
			// exchange已接收消息, 但是没有找到对应的queue时(routingKey不匹配), 就会return
			channel.basicPublish(EXCHANGE_TOPIC_CONFIRM, KEY_NOT_EXIST, true, null, "value".getBytes());
			ThreadKit.sleepSecond(3);
			// 注意: 渠道和连接不能立即关闭, 不然就无法监听了
			CommonKit.closeChannelAndConnection(channel);
//			ThreadKit.sleepDay(1);
		} catch (Throwable cause) {
			cause.printStackTrace();
		}
	}

}
mrathena
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用JMS通过AMQP协议对接activeMQ和rabbitMQ测试代码
xiaolilian007的博客
11-20 924
本打算用一套代码，实现可同时对接activeMQ和rabbitMQ，最后只找到一个jar可支持，但只能发到队列，不满足业务需求，在此做个记录。 import com.rabbitmq.client.Channel; import com.rabbitmq.client.MessageProperties; import com.rabbitmq.jms.admin.RMQConnectionFactory; import com.rabbitmq.jms.admin.RMQDestination; impo
RabbitMQ使用jar包-amqp-client-5.2.0.jar
04-03
使用JAVA进行运用了RabbitMQ的程序时所需的源码包，此包导入工程之后便可使用。
2. rabbitmq（消息中间件）
qq_44949002的博客
08-14 296
一、引言 什么RabbitMQ？ RabbitMQ是基于amqp协议，实现的一种MQ理念的服务。类似的服务 RocketMQ、ActiveMQ、Kafka等 为什么在分布式项目中需要一款消息中间件？ 消息中间件能够实现一些Feign（同步调用）无法实现的效果： 1、服务的异步调用 2、消息的广播（事件总线） 3、消息的延迟处理 4、分布式事务 5、请求削峰（处理高并发） 二、RabbitMQ的Docker安装 1）拉取镜像 docker pull rabbitmq:3.8.5-management
Windows下载安装RabbitMQ客户端（2024最新篇）
最新发布
A的博客
06-05 2697
打开任务资源管理器Win10，WIn11 的快捷键都是Ctrl+Shift+Esc，找到rabbitmq服务-右键-开始/重新启动。选择图中选中进行下载，最后会下载一个rabbitmq-server-x.x.x的安装包文件，注意要放到无中文路径下，避免有问题。【注意】不要安装在中文或带空格的文件路径下，双击下载的安装包rabbitmq-server-x.x.x。安装路径，我这里又新建了一层RabbitMQ-Server，然后无脑下一步。，我这里是64位的就下载64-bit对应的，会看到右上角已经在下载了。
SpringBoot项目引入amqp-client依赖失败
u013182548的博客
05-13 3304
pom文件中添加依赖 <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</artifactId> </dependency> update maven 一直下载该jar包失败，用的是公司内网（也可以上外网），后来切换网络换成自己手机流量，更新成功。 ...
基于AMQP的RabbitMQ整合SpringBoot
菜鸟玩Java
03-03 1631
1. AMQP（Advanced Message Queue Protocol） AMQP（Advanced Message Queue Protocol）高级消息队列协议。协议无非就是需要遵循一定的数据规范，是在线路层上建立的，也就是应用层协议的一个开放标准，定义了网络交互的数据格式，而不是API接口（例如JMS），这使得AMQP和JMS从本质上的区别。它天然就是跨平台的，就像SMTP、HTTP 等协议样，只要开发者按照规范的格式发送数据，任何平台都可以通过AMQP进行消息交互。像目前流行的 StormM
【消息队列】消息中间件RabbitMQ急速入门
互联网小阿祥
11-07 694
消息中间件RabbitMQ急速入门
RabbitMQ 下载相关记录
xiaoxiao48的博客
06-18 226
1、RabbitMQ 下载地址：https://www.rabbitmq.com/download.html 2、Erlang下载地址：https://www.erlang.org/downloads 3、RabbitMQ 和 Erlang的版本对应关系：https://www.rabbitmq.com/which-erlang.html#intro 4、amqp-client.jar 下载地址：https://www.rabbitmq.com/java-client.html RabbitMQ安装参考：R
Rabbitmq安装以及入门
ifspirt的博客
04-02 3106
rabbitmq安装以及入门
RabbitMQ一Spring boot-An unexpected connection driver error occured
pingsiyue6550的博客
08-07 519
目录 报错日志： 解决方案 以下为补充内容 报错日志： java.net.SocketException: Socket Closed at java.net.SocketInputStream.socketRead0(Native Method) ~[na:1.8.0_275] at java.net.SocketInputStream.socketRead(SocketInputStream.java:116) ~[na:1.8.0_275] at java.net.
RabbitMQ安装详解
henianyou的博客
11-28 385
安装（centos系统）第一步： 下载rabbitmq安装包 第二步： 安装erlang 1） 安装Erlang Solutions仓库到你的系统（目的在于让你可以使用yum安装到最新版本的erlang， 如果不设置， yum安装的erlang版本通常太低） 　　　　　　 wget https://packages.erlang-solutions.com/erlang-solutio
amqp-client-3.6.6.jar
07-23
jmeter amqp-client jar包 rabbitmq amqp-client-3.6.6.jar
rabbitmq-mock：RabbitMQ Java amqp-client的模拟
02-06
动机该项目旨在通过以下方式模拟RabbitMQ行为以进行测试： com.rabbitmq.client.ConnectionFactory与使用范例更换使用com.rabbitmq.client.ConnectionFactory通过 ConnectionFactory factory = new ...
amqp-client-5.5.0-API文档-中英对照版.zip
06-07
Maven坐标：com.rabbitmq:amqp-client:5.5.0； 标签：rabbitmq、amqp、client、中英对照文档、jar包、java； 使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件，即可纵览文档内容。 人性化翻译，文档...
rabbitmq-jar包
06-29
在这个“rabbitmq-jar包”中，我们有两个版本的AMQP客户端库，分别是`amqp-client-3.2.4.jar`和`amqp-client-5.3.0.jar`。 1. AMQP客户端库： - `amqp-client-3.2.4.jar`: 这是RabbitMQ官方提供的AMQP客户端库的...
RocketMQ 客户端 org.apache.rocketmq:rocketmq-client:4.7.1
mrathena
12-08 2461
博文目录 文章目录准备依赖NameServer生产者编程模型消费者编程模型基本样例生产者代码演示消费者代码演示顺序消息生产者代码演示消费者代码演示广播消息生产者代码演示消费者代码演示延迟消息生产者代码演示消费者代码演示批量消息生产者代码演示消费者代码演示过滤消息生产者代码演示消费者代码演示 准备 依赖 <dependency> <groupId>org.apache.rocketmq</groupId> <artifactId>rocketm
Zookeeper 客户端 org.apache.curator:curator-recipes:5.1.0
mrathena
12-08 2457
博文目录 文章目录Apache Curator 客户端会话创建重试策略代码演示异步接口监听Curator Cachesnode cachepath cachetree cache代码演示集群模式下的使用 Apache Curator 客户端 Curator 是一套由netflix 公司开源的，Java 语言编程的 ZooKeeper 客户端框架，Curator项目是现在ZooKeeper 客户端中使用最多，对ZooKeeper 版本支持最好的第三方客户端，并推荐使用，Curator 把我们平时常用的很多
Kafka 客户端 org.apache.kafka:kafka-clients:2.4.1
mrathena
01-01 2248
博文目录 文章目录消息体生产者消费者 消息体 package com.mrathena.kafka; import lombok.*; import java.io.Serializable; @Getter @Setter @ToString @NoArgsConstructor @AllArgsConstructor public class Order implements Serializable { private static final long serialVersionUID =
sudo service rabbitmq-server restart Redirecting to /bin/systemctl restart rabbitmq-server.service Failed to restart rabbitmq-server.service: Unit rabbitmq-server.service not found.
06-03
如果您在执行`sudo service rabbitmq-server restart`时遇到了“Failed to restart rabbitmq-server.service: Unit rabbitmq-server.service not found”的错误消息，可能是因为RabbitMQ服务未正确安装或配置。请尝试以下解决方案： 1. 确认RabbitMQ已正确安装并处于运行状态。您可以使用以下命令检查RabbitMQ状态： ``` sudo rabbitmqctl status ``` 如果该命令返回“Status of node rabbit@localhost ...”等有关RabbitMQ状态的信息，则表示RabbitMQ已正确安装并正在运行。 2. 如果RabbitMQ未正确安装，请按照官方文档中的说明进行安装和配置。您可以在RabbitMQ官方网站上找到有关安装和配置的详细信息。 3. 如果您已正确安装RabbitMQ但仍无法重新启动服务，请尝试使用以下命令重新启动RabbitMQ服务： ``` sudo systemctl restart rabbitmq-server ``` 请注意，这些命令需要在具有管理员权限的终端或命令提示符中执行。如果问题仍然存在，请联系您的系统管理员或技术支持以获取更多帮助。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值