博文目录
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");
factory.setVirtualHost("test");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
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 {
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 {
long deliveryTag = envelope.getDeliveryTag();
log.info("收到消息: {}", new String(body));
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++) {
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);
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));
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);
}
});
} 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);
channel.exchangeDeclare(EXCHANGE_FANOUT, BuiltinExchangeType.FANOUT, false, false, false, null);
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++) {
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() {
Channel channel = CommonKit.getChannel();
try {
channel.queueDeclare(QUEUE1, false, false, false, null);
channel.exchangeDeclare(EXCHANGE_DIRECT, BuiltinExchangeType.DIRECT, false, false, false, null);
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() {
Channel channel = CommonKit.getChannel();
try {
channel.queueDeclare(QUEUE2, false, false, false, null);
channel.exchangeDeclare(EXCHANGE_DIRECT, BuiltinExchangeType.DIRECT, false, false, false, null);
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() {
Channel channel = CommonKit.getChannel();
try {
channel.queueDeclare(QUEUE2, false, false, false, null);
channel.exchangeDeclare(EXCHANGE_DIRECT, BuiltinExchangeType.DIRECT, false, false, false, null);
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() {
Channel channel = CommonKit.getChannel();
try {
channel.queueDeclare(QUEUE1, false, false, false, null);
channel.exchangeDeclare(EXCHANGE_TOPIC, BuiltinExchangeType.TOPIC, false, false, false, null);
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() {
Channel channel = CommonKit.getChannel();
try {
channel.queueDeclare(QUEUE2, false, false, false, null);
channel.exchangeDeclare(EXCHANGE_TOPIC, BuiltinExchangeType.TOPIC, false, false, false, null);
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() {
Channel channel = CommonKit.getChannel();
try {
channel.queueDeclare(QUEUE3, false, false, false, null);
channel.exchangeDeclare(EXCHANGE_TOPIC, BuiltinExchangeType.TOPIC, false, false, false, null);
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() {
Channel channel = CommonKit.getChannel();
try {
channel.queueDeclare(QUEUE4, false, false, false, null);
channel.exchangeDeclare(EXCHANGE_TOPIC, BuiltinExchangeType.TOPIC, false, false, false, null);
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() {
Channel channel = CommonKit.getChannel();
try {
channel.queueDeclare(QUEUE5, false, false, false, null);
channel.exchangeDeclare(EXCHANGE_TOPIC, BuiltinExchangeType.TOPIC, false, false, false, null);
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() {
Channel channel = CommonKit.getChannel();
try {
channel.queueDeclare(QUEUE6, false, false, false, null);
channel.exchangeDeclare(EXCHANGE_TOPIC, BuiltinExchangeType.TOPIC, false, false, false, null);
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;
@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();
channel.confirmSelect();
channel.addConfirmListener(new ConfirmListener() {
@Override
public void handleAck(long deliveryTag, boolean multiple) throws IOException {
log.info("ack true : {}", deliveryTag);
}
@Override
public void handleNack(long deliveryTag, boolean multiple) throws IOException {
log.info("ack false : {}", deliveryTag);
}
});
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));
}
});
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);
channel.basicPublish(EXCHANGE_TOPIC_CONFIRM, KEY_CONFIRM, true, null, "value".getBytes());
channel.basicPublish(EXCHANGE_TOPIC_CONFIRM, KEY_NOT_EXIST, true, null, "value".getBytes());
ThreadKit.sleepSecond(3);
CommonKit.closeChannelAndConnection(channel);
} catch (Throwable cause) {
cause.printStackTrace();
}
}
}