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
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 2647
打开任务资源管理器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 225
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 3105
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
RocketMQ 客户端 org.apache.rocketmq:rocketmq-client:4.7.1
mrathena
12-08 2460
博文目录 文章目录准备依赖NameServer生产者编程模型消费者编程模型基本样例生产者代码演示消费者代码演示顺序消息生产者代码演示消费者代码演示广播消息生产者代码演示消费者代码演示延迟消息生产者代码演示消费者代码演示批量消息生产者代码演示消费者代码演示过滤消息生产者代码演示消费者代码演示 准备 依赖 <dependency> <groupId>org.apache.rocketmq</groupId> <artifactId>rocketm
Zookeeper 客户端 org.apache.curator:curator-recipes:5.1.0
mrathena
12-08 2455
博文目录 文章目录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 =
Zookeeper 客户端 org.apache.zookeeper:zookeeper:3.5.8
mrathena
11-19 2133
博文目录 文章目录Zookeeper 客户端代码演示Apache Curator 客户端会话创建重试策略代码演示异步接口监听Curator Cachesnode cachepath cachetree cache代码演示集群模式下的使用 Zookeeper 客户端 zookeeper 官方的客户端没有和服务端代码分离，他们为同一个jar 文件，所以我们直接引入zookeeper的maven即可， 这里版本请保持与服务端版本一致，不然会有很多兼容性的问题 <dependency> &lt
Redis 阿里云服务器遭遇攻击
mrathena
11-20 1817
博文目录 文章目录攻击提醒查看异常638063796381补救操作系统操作Redis添加密码认证残留问题 攻击提醒 通过描述来看, 我的服务器被挂马, 一直在尝试攻击别人服务器的6379端口, 阿里云一定时限内禁止我访问其他服务器的6379端口 我估计是因为我的Redis使用了默认的6379端口, 且没有设置密码, 且开放了一堆端口到公网, 且使用的是root账户, 被人扫到了, 然后通过漏洞做了不好的事情, 我是Linux小白, 只能百度看看有什么查漏补缺的措施了 查看异常 执行top发现有两个进程占
Kafka 2.4.1 环境搭建
mrathena
12-23 1787
博文目录 文章目录注意下载安装配置启动配置文件 server.properties 核心配置详解 Kafka需要JDK环境 Linux Oracle JDK 下载 安装 配置 使用 Kafka需要Zookeeper缓存存储各种元数据, 单机模式或集群模式都支持 Zookeeper 下载安装 单机 集群 Kafka从2.5.0开始不再支持Scala 2.11, 我们下载支持Scala2.11的最后一个版本 kafka_2.11-2.4.1.tgz Kafka官网下载 Kafka 2.4.1 下载页
Kafka 基础概念
mrathena
12-16 1280
博文目录 文章目录使用场景基本概念 Kafka官网 Kafka最新版本文档 Kafka是最初由Linkedin公司开发，是一个分布式、支持分区的（partition）、多副本的（replica），基于zookeeper协调的分布式消息系统，它的最大的特性就是可以实时的处理大量数据以满足各种需求场景：比如基于hadoop的批处理系统、低延迟的实时系统、Storm/Spark流式处理引擎，web/nginx日志、访问日志，消息服务等等，用scala语言编写，Linkedin于2010年贡献给了Apach
MySQL BinLog 数据还原恢复
mrathena
12-12 1203
本次还原的流程是, 重现 binlog 中拷贝表的步骤, 还原 tzh_ths_benchmark_copy1 表, 然后重命名为原表, 全部流程对应下面选中的内容, 核心在 Table_map 和 Write_rows 两个事件, 加上前面创建表的步骤, 即可还原数据, 最终确定本次恢复数据的 binlog 起始点和结束点分别为 361653031 和 361656701。binlog 日志以事件为单位写入, 以 at 作为日志的开始, 两个 at 之间的内容就是一个完整的事件。
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服务未正确安装或配置。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值