0.RabbitMq安装
不多介绍rabbitmq的安装过程,RabbitMq基于erlang开发,所以安装Rabbitmq之前需要先安装对应版本的erlang。
rabbitmq下载地址:https://www.rabbitmq.com/install-windows.html
erlang下载地址:https://www.erlang-solutions.com/resources/download.html
安装完,打开localhost:15672,使用guest,guest可登录rabbitmq,可以进行rabbitmq的操作。
1.三种交换机模式
在rabbitmq中有以下三种交换机,主要使用交换机将消息分发给各个队列,然后消费者从各个队列中获取消息,所以主要介绍以下三种发送、接受消息的模式。
1.direct直连型交换机
通过设置routingKey来推送给对应的队列,例如下图中,Q1具有orange的key,Q2具有black和green的key,发送的消息如果带有的是orange,则只发送给Q1,如果带有black或者green,则发送给Q2
2.fanout扇形交换机
分发给这个交换机所有绑定的队列,使用这个类型的交换机的时候,routingKey是无效的
3.topic主题模式交换机
同样根据routingKey来分发给对应的队列,跟direct不同的是,主题模式的交换机可以使用通配符#,*
#代表多个单词,可以是0个可以是多个
*代表一个单词,只能是一个
如下图所示Q1队列绑定*.oragne.*,Q2绑定*.*.rabbit和lazy.#
如果发送的消息是one.orange.two,那么会分发给Q1
如果发送的消息是one.two.rabbit,那么会分发给Q2
如果是one.orange.rabbit,那么会分发给Q1和Q2
如果是lazy.one或是lazy.one.two那么会分发给Q2
如果是lazy.orange.one,则会分发给Q1和Q2
2.在springboot中使用rabbitmq
2.0 新建springboot项目
直接使用springboot项目生成器生成,勾选上web和rabbitmq
2.1 配置springboot的配置文件
spring:
rabbitmq:
host: localhost
port: 5672
#登录账户和密码,自己设置
username: user
password: 123456
#虚拟地址,没设置不用写
virtual-host: /vhost_test
2.2 测试Direct模式
创建一个direct模式的配置类,里面配置exchange交换机,queue队列,和他们之前的绑定关系,设置routingKey为testDirectRouting
。
@Configuration
public class DirectRabbitMqConfig {
/** 注册队列 */
@Bean
public Queue testDirectQueue(){
/*
* Construct a new queue, given a name, durability flag, and auto-delete flag, and arguments.
* @param name 队列名
* @param durable 是否可持久化
* @param exclusive 是否排外的,有两个作用,一:当连接关闭时connection.close()该队列是否会自动删除;
* 二:该队列是否是私有的,如果不是排外的,可以使用两个消费者都访问同一个队列,没有任何问题,
* 如果是排外的,会对当前队列加锁,其他通道channel是不能访问的
* @param autoDelete 是否自动删除,当最后一个消费者断开连接后是否自动删除
* @param arguments 额外参数
* 默认都是false,可以设置一下持久化为true
*/
return new Queue("test_Direct_Queue",true);
}
/** 注册direct类型交换机 */
@Bean
public Exchange testDirectExchange(){
//属性:1.name 2.durable 3.autoDelete
return new DirectExchange("test_Direct_Exchange",true,false);
}
/** 将队列绑定到交换机上,并设置routingKey */
@Bean
public Binding bindingDirect(){
return BindingBuilder.bind(testDirectQueue()).to(testDirectExchange()).with("testDirectRouting").noargs();
}
}
然后新建一个控制器,使用springboot配置好的rabbitTemplate去发送消息,也可以使用rabbitTemplate去接收消息。
发送消息的时候需要带上配置绑定关系所配置的routingKey:testDirectRouting
@RestController
public class SendMessageController {
@Autowired
RabbitTemplate rabbitTemplate;
@RequestMapping("/direct/send")
public String directSend(){
String messageContext="Direct消息体.....";
String createTime=new Date().toString();
Map<String, Object> map=new HashMap<>();
map.put("messageContext",messageContext);
map.put("createTime",createTime);
//发送给交换机
rabbitTemplate.convertAndSend("test_Direct_Exchange","testDirectRouting",map);
return "ok";
}
}
然后进行测试,访问localhost:8080/direct/send返回一个ok,去rabbitMq管理页面查看,发现出现了一个消息,还未被消费
接下来,是去接收消息。主要有两种方式
1.使用rabbitTemplate中的receiveAndConvert方法来接收消息
在控制器中写,访问请求手动接受消息,并显示到控制台
@RequestMapping("/direct/receive")
public String directReceive(){
//接受消息
Object o = rabbitTemplate.receiveAndConvert("test_Direct_Queue");
String msg=o==null?"":o.toString();
System.out.println(msg);
return "ok";
}
访问/direct/receive后控制台正常打印消息
在rabbitmq管理页面看到消息已经被消费了
2.使用rabbitListener注解进行监听
创建一个类,并注册进spring容器,然后使用注解监听指定的队列,只要发送消息就会执行方法体
@Component
public class DirectReceiver {
@RabbitListener(queues = "test_Direct_Queue")
public void direct(Map msg){
System.out.println("Direct 接收到消息:"+msg);
}
}
连续发送3条消息进行测试,发送完,监听到消息后直接执行方法。
然后说一下convertAndSend和ReceiveAndConvert这两个方法,这俩方法会使用rabbitTemplate初始化时默认的格式化器,对发送的消息进行格式化。springboot的自动配置类中使用的是JDK默认格式化器,
我们可以自己配置一个messageConvert,然后将它注册进容器,就可以使用我们自定义的格式化器。
这里我使用jackson2的messageConvert将消息序列化成json形式。
@Bean
public MessageConverter messageConverter(){
return new Jackson2JsonMessageConverter();
}
2.3 测试Fanout模式
还是先创建相应的配置类,在里面创建一个fanout类型的交换机,和3个队列,然后将3个队列都绑定到这个fanout交换机上。代码如下:
/**
* fanout扇形交换机
* 会分发给所有绑定的队列,不管routingKey
* @author houhaotong
*/
@Configuration
public class FanoutRabbitMqConfig {
private static final String QUEUE_NAME_1="test_Fanout_Queue_1";
private static final String QUEUE_NAME_2="test_Fanout_Queue_2";
private static final String QUEUE_NAME_3="test_Fanout_Queue_3";
private static final String EXCHANGE_NAME="test_Fanout_Exchange";
/** 队列 */
@Bean
public Queue fanoutQueue1(){
return new Queue(QUEUE_NAME_1);
}
@Bean
public Queue fanoutQueue2(){
return new Queue(QUEUE_NAME_2);
}
@Bean
public Queue fanoutQueue3(){
return new Queue(QUEUE_NAME_3);
}
/** fanout扇形交换机 */
@Bean
public Exchange fanoutExchange(){
return new FanoutExchange(EXCHANGE_NAME);
}
/** 绑定队列和交换机 */
@Bean
public Binding fanoutBinding1(){
return BindingBuilder.bind(fanoutQueue1()).to(fanoutExchange()).with("").noargs();
}
@Bean
public Binding fanoutBinding2(){
return BindingBuilder.bind(fanoutQueue2()).to(fanoutExchange()).with("").noargs();
}
@Bean
public Binding fanoutBinding3(){
return BindingBuilder.bind(fanoutQueue3()).to(fanoutExchange()).with("").noargs();
}
}
不再介绍手动消费消息的方法,直接使用监听器监听队列。代码如下
/**
* Fanout类型消费者
* 使用注解监听队列
* @author houhaotong
*/
@Component
public class FanoutReceiver {
@RabbitListener(queues = "test_Fanout_Queue_1")
public void fanout1(Map msg){
System.out.println("Fanout_Queue_1 接收到消息:"+msg);
}
@RabbitListener(queues = "test_Fanout_Queue_2")
public void fanout2(Map msg){
System.out.println("Fanout_Queue_2 接收到消息:"+msg);
}
@RabbitListener(queues = "test_Fanout_Queue_3")
public void fanout3(Map msg){
System.out.println("Fanout_Queue_3 接收到消息:"+msg);
}
}
然后在控制器中写send方法,发送到fanout交换机。代码如下:
@RequestMapping("/fanout/send")
public String fanoutSend(){
String messageContext="Fanout消息体.....";
String createTime=new Date().toString();
Map<String, Object> map=new HashMap<>();
map.put("messageContext",messageContext);
map.put("createTime",createTime);
//发送给交换机
rabbitTemplate.convertAndSend("test_Fanout_Exchange","",map);
return "ok";
}
最后发送一条消息进行测试,可以看到,三个监听器监听各自的队列,都接收到了消息,fanout交换机把消息分发给了所有绑定的队列
2.4 测试Topic模式
先写配置类,这里定义的三个队列所绑定的routingKey分别是item.#
,#.add
,item.add
/**
* topic主题模式
* @author houhaotong
*/
@Configuration
public class TopicRabbitMqConfig {
private static final String QUEUE_NAME_1="test_Topic_Queue_1";
private static final String QUEUE_NAME_2="test_Topic_Queue_2";
private static final String QUEUE_NAME_3="test_Topic_Queue_3";
private static final String EXCHANGE_NAME="test_Topic_Exchange";
/** 队列 */
@Bean
public Queue topicQueue1(){
return new Queue(QUEUE_NAME_1);
}
@Bean
public Queue topicQueue2(){
return new Queue(QUEUE_NAME_2);
}
@Bean
public Queue topicQueue3(){
return new Queue(QUEUE_NAME_3);
}
/** topic主题模式交换机 */
@Bean
public Exchange topicExchange(){
return new TopicExchange(EXCHANGE_NAME);
}
/** 绑定队列和交换机,两个使用通配符,一个不使用 */
@Bean
public Binding topicBinding1(){
return BindingBuilder.bind(topicQueue1()).to(topicExchange()).with("item.#").noargs();
}
@Bean
public Binding topicBinding2(){
return BindingBuilder.bind(topicQueue2()).to(topicExchange()).with("#.add").noargs();
}
@Bean
public Binding topicBinding3(){
return BindingBuilder.bind(topicQueue3()).to(topicExchange()).with("item.add").noargs();
}
}
控制器中topic发送消息的方法如下:
这里要注意,先设置routingKey为item.add,因为我们的三个队列所绑定的routingKey分别是item.#
,#.add
,item.add
,所以这个时候发送的消息,交换机应该会分发给这三个队列。
@RequestMapping("/topic/send")
public String topicSend(){
String messageContext="Topic消息体.....";
String createTime=new Date().toString();
//定义routingKey
String routingKey="item.add";
Map<String, Object> map=new HashMap<>();
map.put("messageContext",messageContext);
map.put("createTime",createTime);
//发送给交换机
rabbitTemplate.convertAndSend("test_Topic_Exchange",routingKey,map);
return "ok";
}
监听器代码如下:
/**
* Topic类型消费者
* 使用注解监听队列
* @author houhaotong
*/
@Component
public class TopicReceiver {
@RabbitListener(queues = "test_Topic_Queue_1")
public void topic1(Map msg){
System.out.println("Topic_Queue_1 item.# 接收到消息:"+msg);
}
@RabbitListener(queues = "test_Topic_Queue_2")
public void topic2(Map msg){
System.out.println("Topic_Queue_2 #.add 接收到消息:"+msg);
}
@RabbitListener(queues = "test_Topic_Queue_3")
public void topic3(Map msg){
System.out.println("Topic_Queue_3 item.add 接收到消息:"+msg);
}
}
接下来进行测试,先测试的是发送消息带的routingKey是item.add
,三个队列都接受到消息,没有问题
然后测试发送绑定item.delete
,这个时候应该只有第一个队列能接收到消息,没有任何问题
然后测试one.add,这个时候只有第二个队列能收到消息,没有问题
*号和别的情况不再测试
2.4 生产者的消息确认
生产者的消息确认(回调)主要分为两种
- ConfirmCallback 只要到broker就会触发,找不到交换机则返回false
- ReturnCallback 交换机要分发给队列,但是找不到时,才会触发这个回调
要进行使用,首先需要配置springboot的配置文件
spring:
rabbitmq:
host: localhost
port: 5672
username: user
password: 123456
virtual-host: /vhost_test
#确定消息发送到队列
publisher-returns: true
#启用confirmCallback
publisher-confirm-type: correlated
然后在配置类中,重写一波rabbitTemplate,如下:
@Bean
public RabbitTemplate rabbitTemplate(RabbitTemplateConfigurer configurer, ConnectionFactory connectionFactory) {
RabbitTemplate template = new RabbitTemplate();
configurer.configure(template, connectionFactory);
//设置confirmCallback
template.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
@Override
public void confirm(CorrelationData correlationData, boolean ack, String cause) {
if(ack){
System.out.println("confirmCallback: 消息成功发送到交换机!!!!!");
}else {
System.out.println("confirmCallback: 消息发送失败!!!!!");
}
}
});
//设置returnCallback
template.setReturnCallback(new RabbitTemplate.ReturnCallback() {
@Override
public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
System.out.println("returnCallback: 找不到对应的队列");
System.out.println("returnCallback: 消息体为:"+message.toString());
}
});
return template;
}
进行测试:
①首先测试能发送到交换机,而且能分发到队列
confirmCallback返回true,因为分发到了队列,所以不会触发returnCallback
②测试能发送到交换机,不能分发到队列
confirmCallback返回true,找不到队列,触发了returnCallback
③测试不能发送到队列
confirmCallback返回false
2.5 消费者的消息确认
在使用rabbitListener监听器的时候,是默认自动确认的,为AcknowledgeMode.AUTO。
我们使用手动确认时,需要设置为AcknowledgeMode.MANUAL。
在手动确认中,消费者收到消息后,手动调用basic.ack/basic.nack/basic.reject后,RabbitMQ收到这些消息后,才认为本次投递成功。
- basic.ack用于肯定确认
- basic.nack用于否定确认
- basic.reject用于否定确认,跟nack不同在于一次只能拒绝单条消息
在配置类中重写SimpleMessageListenerContainer
,并且指定手动确认,指定自定义的监听处理器,并设置队列。
@Bean
public SimpleMessageListenerContainer simpleMessageListenerContainer(ConnectionFactory connectionFactory){
SimpleMessageListenerContainer container=new SimpleMessageListenerContainer(connectionFactory);
//设置一个队列
container.setQueueNames("test_Fanout_Queue_1");
//设置为手动确认消息
container.setAcknowledgeMode(AcknowledgeMode.MANUAL);
//设置自定义消息监听器
container.setMessageListener(new ChannelAwareMessageListener() {
@Override
public void onMessage(Message message, Channel channel) throws Exception {
//获取消息标识
long tag = message.getMessageProperties().getDeliveryTag();
try {
System.out.println("******消费者消息手动确认*******");
//消息确认,单条
channel.basicAck(tag,false);
}catch (Exception e){
//requeue:被拒绝后是否重新入队列
channel.basicReject(tag,false);
e.printStackTrace();
}
}
});
return container;
}
进行测试,发送消息到fanout队列,成功输出结果到控制台,手动确认生效