Java接收rabbitmQ消息_RabbitMQ消息发送与接收
1.简介
所有MQ产品从模型抽象上来说都是一样的过程。消费者订阅某个队列。生产者创建消息，然后发布到队列，最后将消息发送到监听的消费者。
AMQP(Advanced message queuing protocol)是一个提供统一消息服务的应用层标准协议，基于此协议的客户端与消息中间件可传递消息，并不受客户端、中间件等不同产品，不同开发语言等条件的限制。
ActiveMQ是基于JMS(Java Message Service)协议的消息中间件。区别如下：
Rabbit模型如下：
1.Message。消息，是不具体的。由消息头和消息体组成。消息体是不透明的，而消息头是一系列可选属性组成，这些属性包括routing-key(路由键)、priority(优先级)、delivery-mode(是否持久存储)等
2.Publisher。消息的生产者，也是一个向交换机发布消息的客户端应用程序。
3.Exchanger。交换机，用来接收生产者发布的消息并将这些消息路由给服务器中的队列。
4.Binging。绑定，用于消息队列和交换器之间的管理。一个绑定就是基于路由键将交换器和消息队列连接起来的路由规则。所以可以将交换器理解成一个由绑定构成的路由表。
5.Queue。消息队列，用来保存消息知道发送给消费者。一个消息可投入一个或对个队列。
6.Connection。网络连接，比如一个TCP连接。
7.Channel。信道，多路复用连接中的一条独立的双向数据流通道，可读可写。一个Connection包括多个channel。因为对于操作系统来说建立和销毁TCP是非常昂贵的开销，所以引入信道的概念，以复用一条TCP连接。
8.Consumer。消费者，从消息队列取得消息的客户端应用程序。
9.VirtualHost。虚拟主机。表示一批交换机、消息队列和相关对象。vhost本质上是一个mini版的RabbitMQ服务器，拥有自己的队列、绑定、交换器和权限控制；vhost通过在各个实例间提供逻辑上分离，允许你为不同应用程序安全保密地运行数据；vhost是AMQP概念的基础，必须在连接时进行指定，RabbitMQ包含了默认vhost：“/”。
10.Borker。表示消息队列服务器实体。表示启动一个rabbitmq所包含的进程。
2.使用
1.简单队列模式
不涉及交换机的模型如下：
pom文件引入如下依赖：
com.rabbitmq
amqp-client
5.4.3
1.消息生产者
packagerabbitmq;importjava.io.IOException;importjava.util.concurrent.TimeoutException;importcom.rabbitmq.client.Channel;importcom.rabbitmq.client.Connection;importcom.rabbitmq.client.ConnectionFactory;public classProducer {public staticConnectionFactory getConnectionFactory() {//创建连接工程，下面给出的是默认的case
ConnectionFactory factory = newConnectionFactory();
factory.setHost("192.168.99.100");
factory.setPort(5672);
factory.setUsername("guest");
factory.setPassword("guest");
factory.setVirtualHost("/");returnfactory;
}public static void main(String[] args) throwsIOException, TimeoutException {
ConnectionFactory connectionFactory=getConnectionFactory();
Connection newConnection= null;
Channel createChannel= null;try{
newConnection=connectionFactory.newConnection();
createChannel=newConnection.createChannel();/*** 声明一个队列。
* 参数一：队列名称
* 参数二：是否持久化
* 参数三：是否排外 如果排外则这个队列只允许有一个消费者
* 参数四：是否自动删除队列，如果为true表示没有消息也没有消费者连接自动删除队列
* 参数五：队列的附加属性
* 注意：
* 1.声明队列时，如果已经存在则放弃声明，如果不存在则会声明一个新队列；
* 2.队列名可以任意取值，但需要与消息接收者一致。
* 3.下面的代码可有可无，一定在发送消息前确认队列名称已经存在RabbitMQ中，否则消息会发送失败。*/createChannel.queueDeclare("myQueue", true, false, false,null);
String message= "测试消息";/*** 发送消息到MQ
* 参数一：交换机名称，为""表示不用交换机
* 参数二:为队列名称或者routingKey.当指定了交换机就是routingKey
* 参数三：消息的属性信息
* 参数四：消息内容的字节数组*/createChannel.basicPublish("", "myQueue", null, message.getBytes());
System.out.println("消息发送成功");
}catch(Exception e) {
e.printStackTrace();
}finally{if (createChannel != null) {
createChannel.close();
}if (newConnection != null) {
newConnection.close();
}
}
}
}
注意：5672是rabbitmq暴露的端口，15672是management插件的端口。
发送成功之后可以从15672端口查看，也可以从15672进行消费，如下：
2.消息接收
packagerabbitmq;importjava.io.IOException;importjava.util.concurrent.TimeoutException;importcom.rabbitmq.client.Channel;importcom.rabbitmq.client.Connection;importcom.rabbitmq.client.ConnectionFactory;importcom.rabbitmq.client.DefaultConsumer;importcom.rabbitmq.client.Envelope;importcom.rabbitmq.client.AMQP.BasicProperties;public classConsumer {public staticConnectionFactory getConnectionFactory() {//创建连接工程，下面给出的是默认的case
ConnectionFactory factory = newConnectionFactory();
factory.setHost("192.168.99.100");
factory.setPort(5672);
factory.setUsername("guest");
factory.setPassword("guest");
factory.setVirtualHost("/");returnfactory;
}public static void main(String[] args) throwsIOException, TimeoutException {
ConnectionFactory connectionFactory=getConnectionFactory();
Connection newConnection= null;
Channel createChannel= null;try{
newConnection=connectionFactory.newConnection();
createChannel=newConnection.createChannel();/*** 声明一个队列。
* 参数一：队列名称
* 参数二：是否持久化
* 参数三：是否排外 如果排外则这个队列只允许有一个消费者
* 参数四：是否自动删除队列，如果为true表示没有消息也没有消费者连接自动删除队列
* 参数五：队列的附加属性
* 注意：
* 1.声明队列时，如果已经存在则放弃声明，如果不存在则会声明一个新队列；
* 2.队列名可以任意取值，但需要与消息接收者一致。
* 3.下面的代码可有可无，一定在发送消息前确认队列名称已经存在RabbitMQ中，否则消息会发送失败。*/createChannel.queueDeclare("myQueue", true, false, false,null);/*** 接收消息。会持续坚挺，不能关闭channel和Connection
* 参数一：队列名称
* 参数二：消息是否自动确认，true表示自动确认接收完消息以后会自动将消息从队列移除。否则需要手动ack消息
* 参数三：消息接收者的标签，用于多个消费者同时监听一个队列时用于确认不同消费者。
* 参数四：消息接收者*/createChannel.basicConsume("myQueue", true, "", newDefaultConsumer(createChannel) {
@Overridepublic voidhandleDelivery(String consumerTag, Envelope envelope, BasicProperties properties,byte[] body) throwsIOException {
String string= new String(body, "UTF-8");
System.out.println("接收到d消息： -》 " +string);
}
});
}catch(Exception e) {
e.printStackTrace();
}finally{
}
}
}
注意：消息的确认模式可以为自动也可以为手动，自动确认读取完会自动从队列删除；手动需要自己ack，如果设为手动也没ack可能会造成消息重复消费。
如果是多个消费者，会从队列以轮询的方式处理消息，这种称为工作队列模式。
补充：这种实际也是用了rabbitmq的一个默认交换机，routing_key为队列名称。也可以理解为是Rabbitmq类型为System的交换机。
测试：修改消费者代码
createChannel.basicConsume("myQueue", true, "", newDefaultConsumer(createChannel) {
@Overridepublic voidhandleDelivery(String consumerTag, Envelope envelope, BasicProperties properties,byte[] body) throwsIOException {
String string= new String(body, "UTF-8");
System.out.println(envelope);
System.out.println(properties);
System.out.println("接收到d消息： -》 " +string);
}
});
结果：(可以看出是有路由key的，值为队列名称)
Envelope(deliveryTag=1, redeliver=false, exchange=, routingKey=myQueue)
#contentHeader(content-type=null, content-encoding=null, headers=null, delivery-mode=null, priority=null, correlation-id=null, reply-to=null, expiration=null, message-id=null, timestamp=null, type=null, user-id=null, app-id=null, cluster-id=null)
接收到d消息：-》 测试消息
2.涉及交换机的发送和接收
Exchange类型根据分发策略分为四种。direct、fanout、topic、headers。headers匹配AMQP消息的header而不是路由键，此外headers交换机和direct交换机完全一致，目前几乎不用。Exchange只负责转发消息，不具备存储消息的能力，因此如果没有任何队列与Exchange绑定，或者没有符合路由规则的队列，消息会丢失。所以只能收到监听之后生产者发送的消息。
抽取工具类：
packagerabbitmq;importcom.rabbitmq.client.Connection;importcom.rabbitmq.client.ConnectionFactory;public classConnectionUtils {public static Connection getConnection() throwsException {//创建连接工程，下面给出的是默认的case
ConnectionFactory factory = newConnectionFactory();
factory.setHost("192.168.99.100");
factory.setPort(5672);
factory.setUsername("guest");
factory.setPassword("guest");
factory.setVirtualHost("/");returnfactory.newConnection();
}
}
1.Direct类型交换-单播模式，也成为路由模式(Routing模式)
精准绑定，消息中的路由键(RoutingKey)和Binding的bindingKey一致。
生产者：
packagerabbitmq;importcom.rabbitmq.client.BuiltinExchangeType;importcom.rabbitmq.client.Channel;importcom.rabbitmq.client.Connection;public classDirectProducer {public static void main(String[] args) throwsException{
Connection connection=ConnectionUtils.getConnection();//8、创建频道-channel = connection.createChannel()
Channel channel =connection.createChannel();//声明交换机- channel.exchangeDeclare(交换机名字,交换机类型)
channel.exchangeDeclare("routing_exchange", BuiltinExchangeType.DIRECT);//连续发3条消息
for (int i = 0; i < 3; i++) {
String routingKey= "";//发送消息的时候根据相关逻辑指定相应的routing key。
switch(i){case 0: //假设i=0，为error消息
routingKey = "log.error";break;case 1: //假设i=1，为info消息
routingKey = "log.info";break;case 2: //假设i=2，为warning消息
routingKey = "log.warning";break;
}//10、创建消息-String m = xxx
String message = "hello,message！" +i;//11、消息发送-channel.basicPublish(交换机[默认Default Exchage],路由key[简单模式可以传递队列名称],消息其它属性,消息内容)
channel.basicPublish("routing_exchange",routingKey,null,message.getBytes("utf-8"));
}//12、关闭资源-channel.close();connection.close()
channel.close();
connection.close();
}
}
消费者一：
packagerabbitmq;importjava.io.IOException;importcom.rabbitmq.client.AMQP;importcom.rabbitmq.client.Channel;importcom.rabbitmq.client.Connection;importcom.rabbitmq.client.Consumer;importcom.rabbitmq.client.DefaultConsumer;importcom.rabbitmq.client.Envelope;public classDirectConsumerOne {public static void main(String[] args) throwsException{
Connection connection=ConnectionUtils.getConnection();//8、创建频道-channel = connection.createChannel()
Channel channel =connection.createChannel();//9、声明队列-channel.queueDeclare(名称，是否持久化，是否独占本连接,是否自动删除,附加参数)
channel.queueDeclare("routing_queue1",true,false,false,null);//队列绑定交换机-channel.queueBind(队列名, 交换机名, 路由key[广播消息设置为空串])
channel.queueBind("routing_queue1", "routing_exchange", "log.error");//创建消费者
Consumer callback = newDefaultConsumer(channel){/***@paramconsumerTag 消费者标签，在channel.basicConsume时候可以指定
*@paramenvelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志(收到消息失败后是否需要重新发送)
*@paramproperties 属性信息(生产者的发送时指定)
*@parambody 消息内容
*@throwsIOException*/@Overridepublic void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throwsIOException {//路由的key
String routingKey =envelope.getRoutingKey();//获取交换机信息
String exchange =envelope.getExchange();//获取消息ID
long deliveryTag =envelope.getDeliveryTag();//获取消息信息
String message = new String(body,"utf-8");
System.out.println("routingKey:" + routingKey +
",exchange:" + exchange +
",deliveryTag:" + deliveryTag +
",message:" +message);
}
};/*** 消息消费
* 参数1：队列名称
* 参数2：是否自动应答，true为自动应答[mq接收到回复会删除消息]，设置为false则需要手动应答
* 参数3：消息接收到后回调*/channel.basicConsume("routing_queue1",true,callback);//注意，此处不建议关闭资源，让程序一直处于读取消息
}
}
消费者二：
packagerabbitmq;importjava.io.IOException;importcom.rabbitmq.client.AMQP;importcom.rabbitmq.client.Channel;importcom.rabbitmq.client.Connection;importcom.rabbitmq.client.Consumer;importcom.rabbitmq.client.DefaultConsumer;importcom.rabbitmq.client.Envelope;public classDirectConsumerTwo {public static void main(String[] args) throwsException{
Connection connection=ConnectionUtils.getConnection();//8、创建频道-channel = connection.createChannel()
Channel channel =connection.createChannel();//9、声明队列-channel.queueDeclare(名称，是否持久化，是否独占本连接,是否自动删除,附加参数)
channel.queueDeclare("routing_queue2",true,false,false,null);//队列绑定交换机-channel.queueBind(队列名, 交换机名, 路由key[广播消息设置为空串])
channel.queueBind("routing_queue2", "routing_exchange", "log.error");//队列绑定交换机-channel.queueBind(队列名, 交换机名, 路由key[广播消息设置为空串])
channel.queueBind("routing_queue2", "routing_exchange", "log.info");//队列绑定交换机-channel.queueBind(队列名, 交换机名, 路由key[广播消息设置为空串])
channel.queueBind("routing_queue2", "routing_exchange", "log.warning");//创建消费者
Consumer callback = newDefaultConsumer(channel){/***@paramconsumerTag 消费者标签，在channel.basicConsume时候可以指定
*@paramenvelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志(收到消息失败后是否需要重新发送)
*@paramproperties 属性信息(生产者的发送时指定)
*@parambody 消息内容
*@throwsIOException*/@Overridepublic void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throwsIOException {//路由的key
String routingKey =envelope.getRoutingKey();//获取交换机信息
String exchange =envelope.getExchange();//获取消息ID
long deliveryTag =envelope.getDeliveryTag();//获取消息信息
String message = new String(body,"utf-8");
System.out.println("routingKey:" + routingKey +
",exchange:" + exchange +
",deliveryTag:" + deliveryTag +
",message:" +message);
}
};/*** 消息消费
* 参数1：队列名称
* 参数2：是否自动应答，true为自动应答[mq接收到回复会删除消息]，设置为false则需要手动应答
* 参数3：消息接收到后回调*/channel.basicConsume("routing_queue2",true,callback);//注意，此处不建议关闭资源，让程序一直处于读取消息
}
}
结果：
(1)消费者一
(2)消费者二
2.fanout多播模式，也称为Publish/Scribe模式
每个发到fanout类型交换器的消息会被分发到所有的队列中。fanout不处理路由键，发消息最快。
两个消费者：
消费者1：
packagerabbitmq;importjava.io.IOException;importcom.rabbitmq.client.AMQP;importcom.rabbitmq.client.Channel;importcom.rabbitmq.client.Connection;importcom.rabbitmq.client.Consumer;importcom.rabbitmq.client.DefaultConsumer;importcom.rabbitmq.client.Envelope;public classFanoutConsumerOne {public static void main(String[] args) throwsException{
Connection connection=ConnectionUtils.getConnection();//8、创建频道-channel = connection.createChannel()
Channel channel =connection.createChannel();//9、声明队列-channel.queueDeclare(名称，是否持久化，是否独占本连接,是否自动删除,附加参数)
channel.queueDeclare("fanout_queue1",true,false,false,null);//队列绑定交换机-channel.queueBind(队列名, 交换机名, 路由key[广播消息设置为空串])
channel.queueBind("fanout_queue1", "fanout_exchange", "");//创建消费者
Consumer callback = newDefaultConsumer(channel){/***@paramconsumerTag 消费者标签，在channel.basicConsume时候可以指定
*@paramenvelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志(收到消息失败后是否需要重新发送)
*@paramproperties 属性信息(生产者的发送时指定)
*@parambody 消息内容
*@throwsIOException*/@Overridepublic void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throwsIOException {//路由的key
String routingKey =envelope.getRoutingKey();//获取交换机信息
String exchange =envelope.getExchange();//获取消息ID
long deliveryTag =envelope.getDeliveryTag();//获取消息信息
String message = new String(body,"utf-8");
System.out.println("routingKey:" + routingKey +
",exchange:" + exchange +
",deliveryTag:" + deliveryTag +
",message:" +message);
}
};/*** 消息消费
* 参数1：队列名称
* 参数2：是否自动应答，true为自动应答[mq接收到回复会删除消息]，设置为false则需要手动应答
* 参数3：消息接收到后回调*/channel.basicConsume("fanout_queue1",true,callback);//注意，此处不建议关闭资源，让程序一直处于读取消息
}
}
消费者二：
packagerabbitmq;importjava.io.IOException;importcom.rabbitmq.client.AMQP;importcom.rabbitmq.client.Channel;importcom.rabbitmq.client.Connection;importcom.rabbitmq.client.Consumer;importcom.rabbitmq.client.DefaultConsumer;importcom.rabbitmq.client.Envelope;public classFanoutConsumerTwo {public static void main(String[] args) throwsException{
Connection connection=ConnectionUtils.getConnection();//8、创建频道-channel = connection.createChannel()
Channel channel =connection.createChannel();//9、声明队列-channel.queueDeclare(名称，是否持久化，是否独占本连接,是否自动删除,附加参数)
channel.queueDeclare("fanout_queue2",true,false,false,null);//队列绑定交换机-channel.queueBind(队列名, 交换机名, 路由key[广播消息设置为空串])
channel.queueBind("fanout_queue2", "fanout_exchange", "");//创建消费者
Consumer callback = newDefaultConsumer(channel){/***@paramconsumerTag 消费者标签，在channel.basicConsume时候可以指定
*@paramenvelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志(收到消息失败后是否需要重新发送)
*@paramproperties 属性信息(生产者的发送时指定)
*@parambody 消息内容
*@throwsIOException*/@Overridepublic void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throwsIOException {//路由的key
String routingKey =envelope.getRoutingKey();//获取交换机信息
String exchange =envelope.getExchange();//获取消息ID
long deliveryTag =envelope.getDeliveryTag();//获取消息信息
String message = new String(body,"utf-8");
System.out.println("routingKey:" + routingKey +
",exchange:" + exchange +
",deliveryTag:" + deliveryTag +
",message:" +message);
}
};/*** 消息消费
* 参数1：队列名称
* 参数2：是否自动应答，true为自动应答[mq接收到回复会删除消息]，设置为false则需要手动应答
* 参数3：消息接收到后回调*/channel.basicConsume("fanout_queue2",true,callback);//注意，此处不建议关闭资源，让程序一直处于读取消息
}
}
生产者：
packagerabbitmq;importcom.rabbitmq.client.BuiltinExchangeType;importcom.rabbitmq.client.Channel;importcom.rabbitmq.client.Connection;public classFanoutProducer {public static void main(String[] args) throwsException{
Connection connection=ConnectionUtils.getConnection();//8、创建频道-channel = connection.createChannel()
Channel channel =connection.createChannel();//声明交换机- channel.exchangeDeclare(交换机名字,交换机类型)
channel.exchangeDeclare("fanout_exchange", BuiltinExchangeType.FANOUT);//连续发10条消息
for (int i = 0; i < 10; i++) {//10、创建消息-String m = xxx
String message = "hello, message！" +i;//11、消息发送-channel.basicPublish(交换机[默认Default Exchage],路由key[简单模式可以传递队列名称],消息其它属性,消息内容)
channel.basicPublish("fanout_exchange","",null,message.getBytes("utf-8"));
System.out.println("发送消息成功: " +message);
}//12、关闭资源-channel.close();connection.close()
channel.close();
connection.close();
}
}
启动两个生产者，后启动消费者后消费消息。
3.Topic类型
处理routingKey和bindingKey，支持通配符。# 匹配0或多个单词，* 匹配单个单词。 Topic主题模式可以实现 Publish/Subscribe发布订阅模式 和 Routing路由模式 的双重功能
生产者：
packagerabbitmq;importcom.rabbitmq.client.BuiltinExchangeType;importcom.rabbitmq.client.Channel;importcom.rabbitmq.client.Connection;public classTopicProducer {public static void main(String[] args) throwsException{
Connection connection=ConnectionUtils.getConnection();//8、创建频道-channel = connection.createChannel()
Channel channel =connection.createChannel();//声明交换机- channel.exchangeDeclare(交换机名字,交换机类型)
channel.exchangeDeclare("topic_exchange", BuiltinExchangeType.TOPIC);//连续发3条消息
for (int i = 0; i < 5; i++) {
String routingKey= "";//发送消息的时候根据相关逻辑指定相应的routing key。
switch(i){case 0: //假设i=0，为error消息
routingKey = "log.error";break;case 1: //假设i=1，为info消息
routingKey = "log.info";break;case 2: //假设i=2，为warning消息
routingKey = "log.warning";break;case 3: //假设i=3，为log.info.add消息
routingKey = "log.info.add";break;case 4: //假设i=4，为log.info.update消息
routingKey = "log.info.update";break;
}//10、创建消息-String m = xxx
String message = "hello,message！" +i;//11、消息发送-channel.basicPublish(交换机[默认Default Exchage],路由key[简单模式可以传递队列名称],消息其它属性,消息内容)
channel.basicPublish("topic_exchange",routingKey,null,message.getBytes("utf-8"));
}//12、关闭资源-channel.close();connection.close()
channel.close();
connection.close();
}
}
消费者一：
packagerabbitmq;importjava.io.IOException;importcom.rabbitmq.client.AMQP;importcom.rabbitmq.client.Channel;importcom.rabbitmq.client.Connection;importcom.rabbitmq.client.Consumer;importcom.rabbitmq.client.DefaultConsumer;importcom.rabbitmq.client.Envelope;public classTopicConsumerOne {public static void main(String[] args) throwsException{
Connection connection=ConnectionUtils.getConnection();//8、创建频道-channel = connection.createChannel()
Channel channel =connection.createChannel();//9、声明队列-channel.queueDeclare(名称，是否持久化，是否独占本连接,是否自动删除,附加参数)
channel.queueDeclare("topic_queue1",true,false,false,null);//队列绑定交换机与路由key
channel.queueBind("topic_queue1", "topic_exchange", "log.*");//创建消费者
Consumer callback = newDefaultConsumer(channel){/***@paramconsumerTag 消费者标签，在channel.basicConsume时候可以指定
*@paramenvelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志(收到消息失败后是否需要重新发送)
*@paramproperties 属性信息(生产者的发送时指定)
*@parambody 消息内容
*@throwsIOException*/@Overridepublic void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throwsIOException {//路由的key
String routingKey =envelope.getRoutingKey();//获取交换机信息
String exchange =envelope.getExchange();//获取消息ID
long deliveryTag =envelope.getDeliveryTag();//获取消息信息
String message = new String(body,"utf-8");
System.out.println("routingKey:" + routingKey +
",exchange:" + exchange +
",deliveryTag:" + deliveryTag +
",message:" +message);
}
};/*** 消息消费
* 参数1：队列名称
* 参数2：是否自动应答，true为自动应答[mq接收到回复会删除消息]，设置为false则需要手动应答
* 参数3：消息接收到后回调*/channel.basicConsume("topic_queue1",true,callback);//注意，此处不建议关闭资源，让程序一直处于读取消息
}
}
消费者二：
packagerabbitmq;importjava.io.IOException;importcom.rabbitmq.client.AMQP;importcom.rabbitmq.client.Channel;importcom.rabbitmq.client.Connection;importcom.rabbitmq.client.Consumer;importcom.rabbitmq.client.DefaultConsumer;importcom.rabbitmq.client.Envelope;public classTopicConsumerTwo {public static void main(String[] args) throwsException{
Connection connection=ConnectionUtils.getConnection();//8、创建频道-channel = connection.createChannel()
Channel channel =connection.createChannel();//9、声明队列-channel.queueDeclare(名称，是否持久化，是否独占本连接,是否自动删除,附加参数)
channel.queueDeclare("topic_queue2",true,false,false,null);//队列绑定路由key
channel.queueBind("topic_queue2", "topic_exchange", "log.#");//创建消费者
Consumer callback = newDefaultConsumer(channel){/***@paramconsumerTag 消费者标签，在channel.basicConsume时候可以指定
*@paramenvelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志(收到消息失败后是否需要重新发送)
*@paramproperties 属性信息(生产者的发送时指定)
*@parambody 消息内容
*@throwsIOException*/@Overridepublic void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throwsIOException {//路由的key
String routingKey =envelope.getRoutingKey();//获取交换机信息
String exchange =envelope.getExchange();//获取消息ID
long deliveryTag =envelope.getDeliveryTag();//获取消息信息
String message = new String(body,"utf-8");
System.out.println("routingKey:" + routingKey +
",exchange:" + exchange +
",deliveryTag:" + deliveryTag +
",message:" +message);
}
};/*** 消息消费
* 参数1：队列名称
* 参数2：是否自动应答，true为自动应答[mq接收到回复会删除消息]，设置为false则需要手动应答
* 参数3：消息接收到后回调*/channel.basicConsume("topic_queue2",true,callback);//注意，此处不建议关闭资源，让程序一直处于读取消息
}
}
启动两个消费者后启动生产者，最终入下：
(1)消费者一
(2)消费者二
总结：
1、简单模式
一个生产者、一个消费者，不需要设置交换机(使用默认的交换机，一个direct类型的交换机,routing_key为queue名称)
2、工作队列模式Work Queue
一个生产者、多个消费者(竞争关系)，不需要设置交换机(使用默认的交换机,一个direct类型的交换机,routing_key为queue名称)
3、发布订阅模式Publish/subscribe
需要设置类型为fanout的交换机，并且交换机和队列进行绑定，当发送消息到交换机后，交换机会将消息发送到绑定的队列。多播模式，不进行RoutingKey的判断。
4、路由模式Routing
需要设置类型为direct的交换机，交换机和队列进行绑定，并且指定routing key，当发送消息到交换机后，交换机会根据routing key将消息发送到对应的队列
5、通配符模式Topic
需要设置类型为topic的交换机，交换机和队列进行绑定，并且指定通配符方式的routing key，当发送消息到交换机后，交换机会根据routing key将消息发送到对应的队列
补充一下，无论是fanout多播模式还是direct路由模式还是topic通配符模式，Exchanger收到消息是会发送到后面的queue列中。如果一个应用以多实例部署，多个实例监听一个Exchanger下面相同的队列，不会造成一个消息被相同的应用多实例重复消费，因为queue本质是不可重复消费。
开发中可以一个应用一个交换机，不同的消息类型放到不同的队列中。如果涉及死信队列，可以对每个应用再建立一个死信交换机，队列名称相同，便于处理死信消息。
补充：消息的属性可以通过BasicProperties进行设置
BasicProperties源码如下：
public static class BasicProperties extendscom.rabbitmq.client.impl.AMQBasicProperties {privateString contentType;privateString contentEncoding;private Mapheaders;privateInteger deliveryMode;privateInteger priority;privateString correlationId;privateString replyTo;privateString expiration;privateString messageId;privateDate timestamp;privateString type;privateString userId;privateString appId;private String clusterId;
测试：
(1)生产者发送消息时生成一些属性
packagerabbitmq;importjava.io.IOException;importjava.util.HashMap;importjava.util.Map;importjava.util.concurrent.TimeoutException;importcom.rabbitmq.client.Channel;importcom.rabbitmq.client.Connection;importcom.rabbitmq.client.ConnectionFactory;importcom.rabbitmq.client.AMQP.BasicProperties;public classProducer {public staticConnectionFactory getConnectionFactory() {//创建连接工程，下面给出的是默认的case
ConnectionFactory factory = newConnectionFactory();
factory.setHost("192.168.99.100");
factory.setPort(5672);
factory.setUsername("guest");
factory.setPassword("guest");
factory.setVirtualHost("/");returnfactory;
}public static void main(String[] args) throwsIOException, TimeoutException {
ConnectionFactory connectionFactory=getConnectionFactory();
Connection newConnection= null;
Channel createChannel= null;try{
newConnection=connectionFactory.newConnection();
createChannel=newConnection.createChannel();/*** 声明一个队列。
* 参数一：队列名称
* 参数二：是否持久化
* 参数三：是否排外 如果排外则这个队列只允许有一个消费者
* 参数四：是否自动删除队列，如果为true表示没有消息也没有消费者连接自动删除队列
* 参数五：队列的附加属性
* 注意：
* 1.声明队列时，如果已经存在则放弃声明，如果不存在则会声明一个新队列；
* 2.队列名可以任意取值，但需要与消息接收者一致。
* 3.下面的代码可有可无，一定在发送消息前确认队列名称已经存在RabbitMQ中，否则消息会发送失败。*/createChannel.queueDeclare("myQueue", true, false, false,null);
String message= "测试消息";//设置消息属性以及headers
Map headers = new HashMap<>();
headers.put("creator", "张三");
BasicProperties build= new BasicProperties().builder().appId("test001").messageId("001").headers(headers).build();/*** 发送消息到MQ
* 参数一：交换机名称，为""表示不用交换机
* 参数二:为队列名称或者routingKey.当指定了交换机就是routingKey
* 参数三：消息的属性信息
* 参数四：消息内容的字节数组*/createChannel.basicPublish("", "myQueue", build, message.getBytes());
System.out.println("消息发送成功");
}catch(Exception e) {
e.printStackTrace();
}finally{if (createChannel != null) {
createChannel.close();
}if (newConnection != null) {
newConnection.close();
}
}
}
}
(2)消息接收者
packagerabbitmq;importjava.io.IOException;importjava.util.concurrent.TimeoutException;importcom.rabbitmq.client.Channel;importcom.rabbitmq.client.Connection;importcom.rabbitmq.client.ConnectionFactory;importcom.rabbitmq.client.DefaultConsumer;importcom.rabbitmq.client.Envelope;importcom.rabbitmq.client.AMQP.BasicProperties;public classConsumer {public staticConnectionFactory getConnectionFactory() {//创建连接工程，下面给出的是默认的case
ConnectionFactory factory = newConnectionFactory();
factory.setHost("192.168.99.100");
factory.setPort(5672);
factory.setUsername("guest");
factory.setPassword("guest");
factory.setVirtualHost("/");returnfactory;
}public static void main(String[] args) throwsIOException, TimeoutException {
ConnectionFactory connectionFactory=getConnectionFactory();
Connection newConnection= null;
Channel createChannel= null;try{
newConnection=connectionFactory.newConnection();
createChannel=newConnection.createChannel();/*** 声明一个队列。
* 参数一：队列名称
* 参数二：是否持久化
* 参数三：是否排外 如果排外则这个队列只允许有一个消费者
* 参数四：是否自动删除队列，如果为true表示没有消息也没有消费者连接自动删除队列
* 参数五：队列的附加属性
* 注意：
* 1.声明队列时，如果已经存在则放弃声明，如果不存在则会声明一个新队列；
* 2.队列名可以任意取值，但需要与消息接收者一致。
* 3.下面的代码可有可无，一定在发送消息前确认队列名称已经存在RabbitMQ中，否则消息会发送失败。*/createChannel.queueDeclare("myQueue", true, false, false,null);/*** 接收消息。会持续坚挺，不能关闭channel和Connection
* 参数一：队列名称
* 参数二：消息是否自动确认，true表示自动确认接收完消息以后会自动将消息从队列移除。否则需要手动ack消息
* 参数三：消息接收者的标签，用于多个消费者同时监听一个队列时用于确认不同消费者。
* 参数四：消息接收者*/createChannel.basicConsume("myQueue", true, "", newDefaultConsumer(createChannel) {
@Overridepublic voidhandleDelivery(String consumerTag, Envelope envelope, BasicProperties properties,byte[] body) throwsIOException {
System.out.println(properties);
System.out.println(envelope);
String string= new String(body, "UTF-8");
System.out.println("接收到d消息： -》 " +string);
}
});
}catch(Exception e) {
e.printStackTrace();
}finally{
}
}
}
结果:
#contentHeader(content-type=null, content-encoding=null, headers={creator=张三}, delivery-mode=null, priority=null, correlation-id=null, reply-to=null, expiration=null, message-id=001, timestamp=null, type=null, user-id=null, app-id=test001, cluster-id=null)
Envelope(deliveryTag=1, redeliver=false, exchange=, routingKey=myQueue)
接收到d消息：-》 测试消息
补充： RabbitMQheaders消息类型的交换机使用方法如下：
x-match 为all是匹配所有的请求头和值，必须所有相等才会发送；any是满足任意一个即可。
packagerabbitmq;importjava.util.HashMap;importjava.util.Hashtable;importjava.util.Map;importcom.rabbitmq.client.AMQP.BasicProperties.Builder;importcom.rabbitmq.client.BuiltinExchangeType;importcom.rabbitmq.client.Channel;importcom.rabbitmq.client.Connection;public classHeadersProducer {public static voidmain(String[] args) {
Connection connection= null;
Channel channel= null;try{
connection=ConnectionUtils.getConnection();
channel=connection.createChannel();//声明交换机
channel.exchangeDeclare("header_exchange", BuiltinExchangeType.HEADERS);//声明queue
channel.queueDeclare("header_queue", true, false, false, null);//声明bind-x-match any 匹配任意一个头，x-match all 匹配所有key
Map bindingArgs = new HashMap();
bindingArgs.put("x-match", "all"); //any or all
bindingArgs.put("headName1", "val1");
bindingArgs.put("headName2", "val2");
channel.queueBind("header_queue", "header_exchange", "", bindingArgs);//设置消息头键值对信息
Map headers = new Hashtable();
headers.put("headName1", "val1");
headers.put("headName2", "val2");
Builder builder= newBuilder();
builder.headers(headers);
String message= "这是headers测试消息234";
channel.basicPublish("header_exchange", "", builder.build(), message.getBytes());
System.out.println("发送消息: " +message);
}catch(Exception e) {
e.printStackTrace();
}finally{try{if (channel != null) {//回滚。如果未异常会提交事务，此时回滚无影响
channel.txRollback();
channel.close();
}if (connection != null) {
connection.close();
}
}catch(Exception ignore) {//ignore
}
}
}
}