MQ全称 Message Queue(消息队列),是在消息的传输过程中保存消息的容器。多用于分布式系统之间进行通信
加入MQ后应用之间的调用
MQ相当于一个中介,生产方通过MQ与消费方交互,它将应用程序进行解耦合
使用 MQ 使得应用间解耦,提升容错性和可维护性
将不需要同步处理的并且耗时长的操作由消息队列通知消息接收方进行异步处理。提高了应用程序的响应时间
如订单系统,在下单的时候就会往数据库写数据。但是数据库只能支撑每秒1000左右的并发写入,并发量再高就容易宕机。低峰期的时候并发也就100多个,但是在高峰期时候,并发量会突然激增到5000以上,这个时候数据库肯定卡死了
消息被MQ保存起来了,然后系统就可以按照自己的消费能力来消费,比如每秒1000个消息,这样慢慢写入数据库,这样就不会卡死数据库了
但是使用了MQ之后,限制消费消息的速度为1000,但是这样一来,高峰期产生的数据势必会被积压在MQ中,高峰就被“削”掉了。但是因为消息积压,在高峰期过后的一段时间内,消费消息的速度还是会维持在1000QPS,直到消费完积压的消息,这就叫做“填谷”
实现MQ的大致有两种主流方式:AMQP、JMS。
AMQP,即 Advanced Message Queuing Protocol(高级消息队列协议),是一个网络协议,是应用
层协议的一个开放标准,为面向消息的中间件设计。基于此协议的客户端与消息中间件可传递消息,遵循此协议,不收客户端和中间件产品和开发语言限制。2006年,AMQP 规范发布。类比HTTP
JMS 即 Java 消息服务(JavaMessage Service)应用程序接口,是一个 Java 平台中关于面向消息中间
件的API
JMS 是 JavaEE 规范中的一种,类比JDBC
很多消息中间件都实现了JMS规范,例如:ActiveMQ。RabbitMQ 官方没有提供 JMS 的实现包,但是开源社区有
官网地址:http://www.rabbitmq.com/
架构图:
相关概念:
RabbitMQ提供了6种模式:简单模式,work模式,Publish/Subscribe发布与订阅模式,Routing路由
模式,Topics主题模式,RPC远程调用模式(远程调用,不太算MQ;暂不作介绍)
模型:
在上图的模型种,有以下概念:
添加依赖
com.rabbitmq
amqp-client
5.6.0
创建工具类,用来给后面的几个模式的创建工程进行调用
package com.study.rabbitmq.utils;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class ConnectionUtils {
public static Connection getConnetion() throws IOException, TimeoutException {
//创建连接工厂
ConnectionFactory connectionFactory = new ConnectionFactory();
//主机地址;默认为 localhost (这里是我的虚拟机ip)
connectionFactory.setHost("192.168.249.4");
//连接端口;默认为 5672
connectionFactory.setPort(5672);
//虚拟主机名称;默认为 / (先在rabbitmq管理台创建该虚拟机)
connectionFactory.setVirtualHost("/xzk");
//连接用户名;默认为guest (先在rabbitmq管理台创建该用户)
connectionFactory.setUsername("wx");
//连接密码;默认为guest
connectionFactory.setPassword("wx");
Connection connection = connectionFactory.newConnection();
return connection;
}
}
编写消息的生产者,也就是发送消息的程序
package com.study.rabbitmq.simple;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.study.rabbitmq.utils.ConnectionUtils;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 模拟生成者
*/
public class Producer {
public static String QUEUE_NAME="simple_queue";
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtils.getConnetion();
//创建频道
Channel channel = connection.createChannel();
//声明(创建)队列
/**
* 参数1:队列名称
* 参数2:是否定义持久化队列
* 参数3:是否独占本次连接,只能有一个Consumer监听这个队列
* 参数4:是否在不使用的时候自动删除队列,当没有Consumer时,自动删除
* 参数5:队列其它参数
*/
channel.queueDeclare(QUEUE_NAME, true, false, false, null);
//发送消息
String message = "你好:小兔子";
/**
* 参数1:交换机名称,如果没有指定则使用默认Default Exchage
* 参数2:路由key,简单模式可以传递队列名称
* 参数3:消息其它属性
* 参数4:消息内容
*/
channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
System.out.println("已发送消息:" + message);
//释放资源
channel.close();
connection.close();
}
}
package com.study.rabbitmq.simple;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
import com.rabbitmq.client.*;
import com.study.rabbitmq.utils.ConnectionUtils;
/**
* 模拟消费者
*/
public class Consumer {
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtils.getConnetion();
//创建频道(channel)
Channel channel = connection.createChannel();
//声明(创建)队列
/**
* 参数1:队列名称
* 参数2:是否定义持久化队列
* 参数3:是否独占本次连接,只能有一个Consumer监听(消费)这个队列
* 参数4:是否在不使用的时候自动删除队列,当没有Consumer时,自动删除
* 参数5:队列其它参数
*/
channel.queueDeclare(Producer.QUEUE_NAME,true,false,false,null);
//接受消息
DefaultConsumer consumer = new DefaultConsumer(channel){
/**
* 接受到消息执行的回调
* consumerTag 消息者标签,在channel.basicConsume时候可以指定
* envelope 消息包的内容,可从中获取消息id,消息routingkey,交换机,消息和重
传标志(收到消息失败后是否需要重新发送)
* properties 属性信息
* body 消息
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//路由key
System.out.println("路由key为:" + envelope.getRoutingKey());
//交换机
System.out.println("交换机为:" + envelope.getExchange());
//消息id
System.out.println("消息id为:" + envelope.getDeliveryTag());
//收到的消息
System.out.println("接收到的消息为:" + new String(body, "utf-8"));
}
};
/**
* 参数1:队列名称
* 参数2:是否自动确认,设置为true为表示消息接收到自动向mq回复接收到了,mq接收到回复
会删除消息,设置为false则需要手动确认
* 参数3:消息接收到后回调
*/
channel.basicConsume(Producer.QUEUE_NAME,true,consumer);
//释放资源
// channel.close();
// connection.close();
}
}
在管理台登录上述工具类当中的账号时,启动生产者程序,发现rabbitmq管理台多了一个消息,如下所示
启动消费者程序,发现队列中的消息已经被消费了
Work Queues 与简单模式 相比,多了一个或一些消费端,多个消费端共同消费同一个队列中的消息
package com.study.rabbitmq.work;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.study.rabbitmq.utils.ConnectionUtils;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 模拟生成者
*/
public class Producer {
public static String QUEUE_NAME="work_queue";
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtils.getConnetion();
//创建频道(channel)
Channel channel = connection.createChannel();
//声明(创建)队列
/**
* 参数1:队列名称
* 参数2:是否定义持久化队列
* 参数3:是否独占本次连接,只能有一个Consumer监听(消费)这个队列
* 参数4:是否在不使用的时候自动删除队列,当没有Consumer时,自动删除
* 参数5:队列其它参数
*/
channel.queueDeclare(QUEUE_NAME,true,false,false,null);
//发送消息
for(int i=1;i<=30;i++){
String message = "你好,rabbit----work queue模式" + i ;
/**
* 参数1:交换机名称,如果没有指定则使用默认Default Exchage
* 参数2:路由key,简单模式可以传递队列名称
* 参数3:消息其它属性
* 参数4:消息内容
*/
channel.basicPublish("",QUEUE_NAME,null,message.getBytes());
System.out.println("已发送消息" + message);
}
//释放资源
channel.close();
connection.close();
}
}
package com.study.rabbitmq.work;
import com.rabbitmq.client.*;
import com.study.rabbitmq.utils.ConnectionUtils;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 模拟消费者
*/
public class Consumer1 {
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtils.getConnetion();
//创建频道(channel)
Channel channel = connection.createChannel();
//声明(创建)队列
/**
* 参数1:队列名称
* 参数2:是否定义持久化队列
* 参数3:是否独占本次连接,只能有一个Consumer监听(消费)这个队列
* 参数4:是否在不使用的时候自动删除队列,当没有Consumer时,自动删除
* 参数5:队列其它参数
*/
channel.queueDeclare(Producer.QUEUE_NAME,true,false,false,null);
//接受消息
DefaultConsumer consumer = new DefaultConsumer(channel){
/**
* 接受到消息执行的回调
* consumerTag 消息者标签,在channel.basicConsume时候可以指定
* envelope 消息包的内容,可从中获取消息id,消息routingkey,交换机,消息和重
传标志(收到消息失败后是否需要重新发送)
* properties 属性信息
* body 消息
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//路由key
System.out.println("路由key为:" + envelope.getRoutingKey());
//交换机
System.out.println("交换机为:" + envelope.getExchange());
//消息id
System.out.println("消息id为:" + envelope.getDeliveryTag());
//收到的消息
System.out.println("消费者1---接收到的消息为:" + new String(body, "utf-8"));
}
};
/**
* 参数1:队列名称
* 参数2:是否自动确认,设置为true为表示消息接收到自动向mq回复接收到了,mq接收到回复
会删除消息,设置为false则需要手动确认
* 参数3:消息接收到后回调
*/
channel.basicConsume(Producer.QUEUE_NAME,true,consumer);
//释放资源
// channel.close();
// connection.close();
}
}
package com.study.rabbitmq.work;
import com.rabbitmq.client.*;
import com.study.rabbitmq.utils.ConnectionUtils;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 模拟消费者
*/
public class Consumer2 {
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtils.getConnetion();
//创建频道(channel)
Channel channel = connection.createChannel();
//声明(创建)队列
/**
* 参数1:队列名称
* 参数2:是否定义持久化队列
* 参数3:是否独占本次连接,只能有一个Consumer监听(消费)这个队列
* 参数4:是否在不使用的时候自动删除队列,当没有Consumer时,自动删除
* 参数5:队列其它参数
*/
channel.queueDeclare(Producer.QUEUE_NAME,true,false,false,null);
//接受消息
DefaultConsumer consumer = new DefaultConsumer(channel){
/**
* 接受到消息执行的回调
* consumerTag 消息者标签,在channel.basicConsume时候可以指定
* envelope 消息包的内容,可从中获取消息id,消息routingkey,交换机,消息和重
传标志(收到消息失败后是否需要重新发送)
* properties 属性信息
* body 消息
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//路由key
System.out.println("路由key为:" + envelope.getRoutingKey());
//交换机
System.out.println("交换机为:" + envelope.getExchange());
//消息id
System.out.println("消息id为:" + envelope.getDeliveryTag());
//收到的消息
System.out.println("消费者2---接收到的消息为:" + new String(body, "utf-8"));
}
};
/**
* 参数1:队列名称
* 参数2:是否自动确认,设置为true为表示消息接收到自动向mq回复接收到了,mq接收到回复
会删除消息,设置为false则需要手动确认
* 参数3:消息接收到后回调
*/
channel.basicConsume(Producer.QUEUE_NAME,true,consumer);
//释放资源
// channel.close();
// connection.close();
}
}
先启动俩个消费者,再启动生产者,不然的话消息就立刻被一个消费者全部消费了, 当生产者发送消息时,俩个消费者存在竞争的关系,即一个消息被一个消费者消费后,就不能被另一个消费者消费了
发布订阅模式: 1、每个消费者监听自己的队列。 2、生产者将消息发给broker,由交换机将消息转发到绑定此交换机的每个队列,每个绑定交换机的队列都将接收到消息
package com.study.rabbitmq.ps;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.study.rabbitmq.utils.ConnectionUtils;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 模拟生成者
*/
public class Producer {
public static String FANOUT_EXCHANGE="fanout_exchange";
public static String FANOUT_QUEUE_1="fanout_queue_1";
public static String FANOUT_QUEUE_2="fanout_queue_2";
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtils.getConnetion();
//创建频道(channel)
Channel channel = connection.createChannel();
//声明交换机
/**
* 参数1: 交换机名称
* 参数2: 交换机类型 fanout,topic,direct,headers(不常见)
*/
channel.exchangeDeclare(FANOUT_EXCHANGE, BuiltinExchangeType.FANOUT);
//声明(创建)队列
/**
* 参数1:队列名称
* 参数2:是否定义持久化队列
* 参数3:是否独占本次连接,只能有一个Consumer监听(消费)这个队列
* 参数4:是否在不使用的时候自动删除队列,当没有Consumer时,自动删除
* 参数5:队列其它参数
*/
channel.queueDeclare(FANOUT_QUEUE_1,true,false,false,null);
channel.queueDeclare(FANOUT_QUEUE_2,true,false,false,null);
//队列绑定交换机
channel.queueBind(FANOUT_QUEUE_1,FANOUT_EXCHANGE,"");
channel.queueBind(FANOUT_QUEUE_2,FANOUT_EXCHANGE,"");
//发送消息
for(int i=1;i<=10;i++){
String message = "你好,rabbit----fanout 模式" + i ;
/**
* 参数1:交换机名称,如果没有指定则使用默认Default Exchage
* 参数2:路由key,简单模式可以传递队列名称
* 参数3:消息其它属性
* 参数4:消息内容
*/
channel.basicPublish(FANOUT_EXCHANGE,"",null,message.getBytes());
System.out.println("已发送消息" + message);
}
//释放资源
channel.close();
connection.close();
}
}
package com.study.rabbitmq.ps;
import com.rabbitmq.client.*;
import com.study.rabbitmq.utils.ConnectionUtils;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 模拟消费者
*/
public class Consumer1 {
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtils.getConnetion();
//创建频道(channel)
Channel channel = connection.createChannel();
//声明(创建)队列
/**
* 参数1:队列名称
* 参数2:是否定义持久化队列
* 参数3:是否独占本次连接,只能有一个Consumer监听(消费)这个队列
* 参数4:是否在不使用的时候自动删除队列,当没有Consumer时,自动删除
* 参数5:队列其它参数
*/
channel.queueDeclare(Producer.FANOUT_QUEUE_1,true,false,false,null);
//队列绑定交换机
channel.queueBind(Producer.FANOUT_QUEUE_1,Producer.FANOUT_EXCHANGE,"");
//接受消息
DefaultConsumer consumer = new DefaultConsumer(channel){
/**
* 接受到消息执行的回调
* consumerTag 消息者标签,在channel.basicConsume时候可以指定
* envelope 消息包的内容,可从中获取消息id,消息routingkey,交换机,消息和重
传标志(收到消息失败后是否需要重新发送)
* properties 属性信息
* body 消息
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//路由key
System.out.println("路由key为:" + envelope.getRoutingKey());
//交换机
System.out.println("交换机为:" + envelope.getExchange());
//消息id
System.out.println("消息id为:" + envelope.getDeliveryTag());
//收到的消息
System.out.println("消费者1---接收到的消息为:" + new String(body, "utf-8"));
}
};
/**
* 参数1:队列名称
* 参数2:是否自动确认,设置为true为表示消息接收到自动向mq回复接收到了,mq接收到回复
会删除消息,设置为false则需要手动确认
* 参数3:消息接收到后回调
*/
channel.basicConsume(Producer.FANOUT_QUEUE_1,true,consumer);
//释放资源
// channel.close();
// connection.close();
}
}
package com.study.rabbitmq.ps;
import com.rabbitmq.client.*;
import com.study.rabbitmq.utils.ConnectionUtils;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 模拟消费者
*/
public class Consumer2 {
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtils.getConnetion();
//创建频道(channel)
Channel channel = connection.createChannel();
//声明(创建)队列
/**
* 参数1:队列名称
* 参数2:是否定义持久化队列
* 参数3:是否独占本次连接,只能有一个Consumer监听(消费)这个队列
* 参数4:是否在不使用的时候自动删除队列,当没有Consumer时,自动删除
* 参数5:队列其它参数
*/
channel.queueDeclare(Producer.FANOUT_QUEUE_2,true,false,false,null);
//队列绑定交换机
channel.queueBind(Producer.FANOUT_QUEUE_2,Producer.FANOUT_EXCHANGE,"");
//接受消息
DefaultConsumer consumer = new DefaultConsumer(channel){
/**
* 接受到消息执行的回调
* consumerTag 消息者标签,在channel.basicConsume时候可以指定
* envelope 消息包的内容,可从中获取消息id,消息routingkey,交换机,消息和重
传标志(收到消息失败后是否需要重新发送)
* properties 属性信息
* body 消息
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//路由key
System.out.println("路由key为:" + envelope.getRoutingKey());
//交换机
System.out.println("交换机为:" + envelope.getExchange());
//消息id
System.out.println("消息id为:" + envelope.getDeliveryTag());
//收到的消息
System.out.println("消费者2---接收到的消息为:" + new String(body, "utf-8"));
}
};
/**
* 参数1:队列名称
* 参数2:是否自动确认,设置为true为表示消息接收到自动向mq回复接收到了,mq接收到回复
会删除消息,设置为false则需要手动确认
* 参数3:消息接收到后回调
*/
channel.basicConsume(Producer.FANOUT_QUEUE_2,true,consumer);
//释放资源
// channel.close();
// connection.close();
}
}
启动所有消费者,然后使用生产者发送消息;在每个消费者对应的控制台可以查看到生产者发送的所有消息;到达广播的效果
在执行完测试代码后,其实到RabbitMQ的管理后台找到 Exchanges 选项卡,点击 fanout_exchange的交换机,可以查看到如下的绑定
交换机需要与队列进行绑定,绑定之后:一个消息可以被多个消费者都收到,而不是像工作模式一样进行争夺消息
发布订阅模式与工作队列模式的区别:
路由模式的特点:
图解:
p: 生产者,向Exchange发送消息,发送消息时,会指定一个routing key
X:Exchange(交换机),接收生产者的消息,然后把消息递交给 与routing key完全匹配的队列
C1:消费者,其所在队列指定了需要routing key 为 error 的消息
消费者,其所在队列指定了需要routing key 为 info、error、warning 的消息
package com.study.rabbitmq.routing;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.study.rabbitmq.utils.ConnectionUtils;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 模拟生成者
*/
public class Producer {
public static String DIRECT_EXCHANGE="direct_exchange";
public static String DIRECT_QUEUE_INSERT="direct_queue_1";
public static String DIRECT_QUEUE_UPDATE="direct_queue_2";
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtils.getConnetion();
//创建频道(channel)
Channel channel = connection.createChannel();
//声明交换机
/**
* 参数1: 交换机名称
* 参数2: 交换机类型 fanout(广播类型),topic,direct(路由类型),headers(不常见)
*/
channel.exchangeDeclare(DIRECT_EXCHANGE, BuiltinExchangeType.DIRECT);
//声明(创建)队列
/**
* 参数1:队列名称
* 参数2:是否定义持久化队列
* 参数3:是否独占本次连接,只能有一个Consumer监听(消费)这个队列
* 参数4:是否在不使用的时候自动删除队列,当没有Consumer时,自动删除
* 参数5:队列其它参数
*/
channel.queueDeclare(DIRECT_QUEUE_INSERT,true,false,false,null);
channel.queueDeclare(DIRECT_QUEUE_UPDATE,true,false,false,null);
//队列绑定交换机
channel.queueBind(DIRECT_QUEUE_INSERT,DIRECT_EXCHANGE,"insert");
channel.queueBind(DIRECT_QUEUE_UPDATE,DIRECT_EXCHANGE,"update");
//发送消息
String message = "新增商品 路由模式 ---- routingKey=insert";
/**
* 参数1:交换机名称,如果没有指定则使用默认Default Exchage
* 参数2:路由key,简单模式可以传递队列名称
* 参数3:消息其它属性
* 参数4:消息内容
*/
channel.basicPublish(DIRECT_EXCHANGE,"insert",null,message.getBytes());
System.out.println("已发送消息" + message);
//发送消息
message = "修改商品 路由模式 ---- routingKey=update";
/**
* 参数1:交换机名称,如果没有指定则使用默认Default Exchage
* 参数2:路由key,简单模式可以传递队列名称
* 参数3:消息其它属性
* 参数4:消息内容
*/
channel.basicPublish(DIRECT_EXCHANGE,"update",null,message.getBytes());
System.out.println("已发送消息" + message);
//释放资源
channel.close();
connection.close();
}
}
package com.study.rabbitmq.routing;
import com.rabbitmq.client.*;
import com.study.rabbitmq.utils.ConnectionUtils;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 模拟消费者
*/
public class Consumer1 {
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtils.getConnetion();
//创建频道(channel)
Channel channel = connection.createChannel();
//声明(创建)队列
/**
* 参数1:队列名称
* 参数2:是否定义持久化队列
* 参数3:是否独占本次连接,只能有一个Consumer监听(消费)这个队列
* 参数4:是否在不使用的时候自动删除队列,当没有Consumer时,自动删除
* 参数5:队列其它参数
*/
channel.queueDeclare(Producer.DIRECT_QUEUE_INSERT,true,false,false,null);
//队列绑定交换机
channel.queueBind(Producer.DIRECT_QUEUE_INSERT, Producer.DIRECT_EXCHANGE,"insert");
//接受消息
DefaultConsumer consumer = new DefaultConsumer(channel){
/**
* 接受到消息执行的回调
* consumerTag 消息者标签,在channel.basicConsume时候可以指定
* envelope 消息包的内容,可从中获取消息id,消息routingkey,交换机,消息和重
传标志(收到消息失败后是否需要重新发送)
* properties 属性信息
* body 消息
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//路由key
System.out.println("路由key为:" + envelope.getRoutingKey());
//交换机
System.out.println("交换机为:" + envelope.getExchange());
//消息id
System.out.println("消息id为:" + envelope.getDeliveryTag());
//收到的消息
System.out.println("消费者1---接收到的消息为:" + new String(body, "utf-8"));
}
};
/**
* 参数1:队列名称
* 参数2:是否自动确认,设置为true为表示消息接收到自动向mq回复接收到了,mq接收到回复
会删除消息,设置为false则需要手动确认
* 参数3:消息接收到后回调
*/
channel.basicConsume(Producer.DIRECT_QUEUE_INSERT,true,consumer);
//释放资源
// channel.close();
// connection.close();
}
}
package com.study.rabbitmq.routing;
import com.rabbitmq.client.*;
import com.study.rabbitmq.utils.ConnectionUtils;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 模拟消费者
*/
public class Consumer2 {
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtils.getConnetion();
//创建频道(channel)
Channel channel = connection.createChannel();
//声明(创建)队列
/**
* 参数1:队列名称
* 参数2:是否定义持久化队列
* 参数3:是否独占本次连接,只能有一个Consumer监听(消费)这个队列
* 参数4:是否在不使用的时候自动删除队列,当没有Consumer时,自动删除
* 参数5:队列其它参数
*/
channel.queueDeclare(Producer.DIRECT_QUEUE_UPDATE,true,false,false,null);
//队列绑定交换机
channel.queueBind(Producer.DIRECT_QUEUE_UPDATE, Producer.DIRECT_EXCHANGE,"update");
//接受消息
DefaultConsumer consumer = new DefaultConsumer(channel){
/**
* 接受到消息执行的回调
* consumerTag 消息者标签,在channel.basicConsume时候可以指定
* envelope 消息包的内容,可从中获取消息id,消息routingkey,交换机,消息和重
传标志(收到消息失败后是否需要重新发送)
* properties 属性信息
* body 消息
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//路由key
System.out.println("路由key为:" + envelope.getRoutingKey());
//交换机
System.out.println("交换机为:" + envelope.getExchange());
//消息id
System.out.println("消息id为:" + envelope.getDeliveryTag());
//收到的消息
System.out.println("消费者2---接收到的消息为:" + new String(body, "utf-8"));
}
};
/**
* 参数1:队列名称
* 参数2:是否自动确认,设置为true为表示消息接收到自动向mq回复接收到了,mq接收到回复
会删除消息,设置为false则需要手动确认
* 参数3:消息接收到后回调
*/
channel.basicConsume(Producer.DIRECT_QUEUE_UPDATE,true,consumer);
//释放资源
// channel.close();
// connection.close();
}
}
启动所有消费者,然后使用生产者发送消息;在消费者对应的控制台可以查看到生产者发送对应routing key对应队列的消息;到达按照需要接收的效果
在执行完测试代码后,其实到RabbitMQ的管理后台找到 Exchanges 选项卡,点击 direct_exchange的交换机,可以查看到如下的绑定
Routing模式要求队列在绑定交换机时要指定routing key,消息会转发到符合routing key的队列
模式说明:
Topic 类型与 Direct 相比,都是可以根据 RoutingKey 把消息路由到不同的队列。只不过 Topic 类型
Exchange 可以让队列在绑定 Routing key 的时候使用通配符!
Routingkey
一般都是有一个或多个单词组成,多个单词之间以”.”分割,例如:item.insert
通配符规则:
#
:匹配一个或多个词
*
:匹配不多不少恰好1个词
举例:
item.#
:能够匹配item.insert.abc
或者item.insert
item.*
:只能匹配item.insert
图解:
package com.study.rabbitmq.topic;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.study.rabbitmq.utils.ConnectionUtils;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 模拟生成者
*/
public class Producer {
public static String TOPIC_EXCHANGE="topic_exchange";
public static String TOPIC_QUEUE_ALL="topic_queue_all";
public static String TOPIC_QUEUE_INSERT_UPDATE="topic_queue_insert_update";
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtils.getConnetion();
//创建频道(channel)
Channel channel = connection.createChannel();
//声明交换机
/**
* 参数1: 交换机名称
* 参数2: 交换机类型 fanout(广播类型),topic,direct(路由类型),headers(不常见)
*/
channel.exchangeDeclare(TOPIC_EXCHANGE, BuiltinExchangeType.TOPIC);
//发送消息
String message = "新增商品 topic模式 ---- routingKey=item.insert";
/**
* 参数1:交换机名称,如果没有指定则使用默认Default Exchage
* 参数2:路由key,简单模式可以传递队列名称
* 参数3:消息其它属性
* 参数4:消息内容
*/
channel.basicPublish(TOPIC_EXCHANGE,"item.insert",null,message.getBytes());
System.out.println("已发送消息" + message);
//发送消息
message = "修改商品 topic模式 ---- routingKey=item.update";
/**
* 参数1:交换机名称,如果没有指定则使用默认Default Exchage
* 参数2:路由key,简单模式可以传递队列名称
* 参数3:消息其它属性
* 参数4:消息内容
*/
channel.basicPublish(TOPIC_EXCHANGE,"item.update",null,message.getBytes());
System.out.println("已发送消息" + message);
//发送消息
message = "删除商品 topic模式 ---- routingKey=item.delete";
/**
* 参数1:交换机名称,如果没有指定则使用默认Default Exchage
* 参数2:路由key,简单模式可以传递队列名称
* 参数3:消息其它属性
* 参数4:消息内容
*/
channel.basicPublish(TOPIC_EXCHANGE,"item.delete",null,message.getBytes());
System.out.println("已发送消息" + message);
//释放资源
channel.close();
connection.close();
}
}
package com.study.rabbitmq.topic;
import com.rabbitmq.client.*;
import com.study.rabbitmq.utils.ConnectionUtils;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 模拟消费者
*/
public class Consumer1 {
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtils.getConnetion();
//创建频道(channel)
Channel channel = connection.createChannel();
//声明交换机
channel.exchangeDeclare(Producer.TOPIC_EXCHANGE,BuiltinExchangeType.TOPIC);
//声明(创建)队列
/**
* 参数1:队列名称
* 参数2:是否定义持久化队列
* 参数3:是否独占本次连接,只能有一个Consumer监听(消费)这个队列
* 参数4:是否在不使用的时候自动删除队列,当没有Consumer时,自动删除
* 参数5:队列其它参数
*/
channel.queueDeclare(Producer.TOPIC_QUEUE_ALL,true,false,false,null);
//队列绑定交换机
channel.queueBind(Producer.TOPIC_QUEUE_ALL, Producer.TOPIC_EXCHANGE,"item.*");
//接受消息
DefaultConsumer consumer = new DefaultConsumer(channel){
/**
* 接受到消息执行的回调
* consumerTag 消息者标签,在channel.basicConsume时候可以指定
* envelope 消息包的内容,可从中获取消息id,消息routingkey,交换机,消息和重
传标志(收到消息失败后是否需要重新发送)
* properties 属性信息
* body 消息
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//路由key
System.out.println("路由key为:" + envelope.getRoutingKey());
//交换机
System.out.println("交换机为:" + envelope.getExchange());
//消息id
System.out.println("消息id为:" + envelope.getDeliveryTag());
//收到的消息
System.out.println("消费者1---接收到的消息为:" + new String(body, "utf-8"));
}
};
/**
* 参数1:队列名称
* 参数2:是否自动确认,设置为true为表示消息接收到自动向mq回复接收到了,mq接收到回复
会删除消息,设置为false则需要手动确认
* 参数3:消息接收到后回调
*/
channel.basicConsume(Producer.TOPIC_QUEUE_ALL,true,consumer);
//释放资源
// channel.close();
// connection.close();
}
}
package com.study.rabbitmq.topic;
import com.rabbitmq.client.*;
import com.study.rabbitmq.utils.ConnectionUtils;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 模拟消费者
*/
public class Consumer2 {
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtils.getConnetion();
//创建频道(channel)
Channel channel = connection.createChannel();
//声明交换机
channel.exchangeDeclare(Producer.TOPIC_EXCHANGE,BuiltinExchangeType.TOPIC);
//声明(创建)队列
/**
* 参数1:队列名称
* 参数2:是否定义持久化队列
* 参数3:是否独占本次连接,只能有一个Consumer监听(消费)这个队列
* 参数4:是否在不使用的时候自动删除队列,当没有Consumer时,自动删除
* 参数5:队列其它参数
*/
channel.queueDeclare(Producer.TOPIC_QUEUE_INSERT_UPDATE,true,false,false,null);
//队列绑定交换机
channel.queueBind(Producer.TOPIC_QUEUE_INSERT_UPDATE, Producer.TOPIC_EXCHANGE,"item.update");
channel.queueBind(Producer.TOPIC_QUEUE_INSERT_UPDATE, Producer.TOPIC_EXCHANGE,"item.insert");
//接受消息
DefaultConsumer consumer = new DefaultConsumer(channel){
/**
* 接受到消息执行的回调
* consumerTag 消息者标签,在channel.basicConsume时候可以指定
* envelope 消息包的内容,可从中获取消息id,消息routingkey,交换机,消息和重
传标志(收到消息失败后是否需要重新发送)
* properties 属性信息
* body 消息
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//路由key
System.out.println("路由key为:" + envelope.getRoutingKey());
//交换机
System.out.println("交换机为:" + envelope.getExchange());
//消息id
System.out.println("消息id为:" + envelope.getDeliveryTag());
//收到的消息
System.out.println("消费者2---接收到的消息为:" + new String(body, "utf-8"));
}
};
/**
* 参数1:队列名称
* 参数2:是否自动确认,设置为true为表示消息接收到自动向mq回复接收到了,mq接收到回复
会删除消息,设置为false则需要手动确认
* 参数3:消息接收到后回调
*/
channel.basicConsume(Producer.TOPIC_QUEUE_INSERT_UPDATE,true,consumer);
//释放资源
// channel.close();
// connection.close();
}
}
启动所有消费者,然后使用生产者发送消息;在消费者对应的控制台可以查看到生产者发送对应
routing key对应队列的消息;到达按照需要接收的效果;并且这些routing key可以使用通配符
在执行完测试代码后,其实到RabbitMQ的管理后台找到 Exchanges 选项卡,点击 topic_exchange的交换机,可以查看到如下的绑定
Topic主题模式可以实现 Publish/Subscribe发布与订阅模式 和 Routing路由模式 的功能;只是Topic
在配置routing key 的时候可以使用通配符,显得更加灵活
RabbitMQ工作模式: