一、写在前面
- 什么是消息队列?
顾名思义,消息队列就是一个能够存放消息的队列,通常有一个生产者生产消息,一个或多个消费者消费消息。
消息队列在分布式系统中运用十分广泛,有异步处理、应用解耦、流量削峰等用途。
当然,RabbitMQ不是消息队列的唯一选择,除它以外还有在大数据中十分常见的Kafka、阿里的RocketMQ、Apache的ActiveMQ,甚至Redis也可以当成消息队列使用。
不过,正常情况下RabbitMQ是比较通用的选择。
- RabbitMQ基础模型
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DPuLCnGj-1693195054817)(http://www.siyemao.xyz/images/1640611813402.png)]
上面是rabbitmq的基础模型,可以看到Server包裹着虚拟主机,一般来说,虚拟主机和用户相对应,一个Rabbitmq可以有多个虚拟主机、多个用户,以对应不同的系统不同的功能模块。
此外,虚拟主机还包含着交换机和数个队列,生产者会将消息交给交换机,然后队列通过某种规则从交换机中取得消息,再由消费者拿到消息。当然,生产者是否要将消息交给交换机,取决于使用了哪种消息模型。
二、消息模型
-
1.HelloWorld(直连)模型。
一个生产者生产消息交给队列,消费者通过队列取得消息,非常简单的一对一消息模型。
首先编写一个获取RabbitMQ工厂对象的工具类:
package utils; import com.rabbitmq.client.Channel; import com.rabbitmq.client.Connection; import com.rabbitmq.client.ConnectionFactory; public class RabbitMQUtil { private static ConnectionFactory connectionFactory; static { connectionFactory = new ConnectionFactory(); connectionFactory.setHost("www.siyemao.xyz"); connectionFactory.setPort(5672); connectionFactory.setVirtualHost("/mao"); connectionFactory.setUsername("siye"); connectionFactory.setPassword("siye"); } //定义提供连接对象的方法 public static Connection getConnection() { try { return connectionFactory.newConnection(); } catch (Exception e) { e.printStackTrace(); } return null; } //定义关闭通道和关闭连接工具的方法 public static void closeConnectionAndChanel(Channel channel,Connection connection){ try{ if (channel != null) channel.close(); if (connection != null) connection.close(); }catch (Exception e){ e.printStackTrace(); } } }
接着再创建生产者类和消费者类:
public class Provider { public static void main(String args[]) throws IOException, TimeoutException { Connection connection = RabbitMQUtil.getConnection(); //通过连接获取通道 Channel channel = connection.createChannel(); //通道绑定对应消息队列 //参数1:队列名称,如果队列不存在自动创建 //参数2:队列是否持久化,true持久化队列,false不持久化 //参数3:是否独占队列,true独占队列,false不独占 //参数4:是否再消费完成后自动删除队列 //参数5:额外附加参数 channel.queueDeclare("hello",true,false,false,null); //发布消息 //参数1:交换机名称,参数2:队列名称,参数3:传递消息额外设置(如果想要消息持久化,则使用MessageProperties.PERSISTENT_TEXT_PLAIN),参数4:消息具体类容 channel.basicPublish("","hello", MessageProperties.PERSISTENT_TEXT_PLAIN,"hello world".getBytes()); RabbitMQUtil.closeConnectionAndChanel(channel,connection); } } public class Consumer { public static void main(String args[]) throws IOException, TimeoutException { //获取连接工厂 Connection connection = RabbitMQUtil.getConnection(); //创建通道 Channel channel = connection.createChannel(); //通道绑定对象 channel.queueDeclare("hello",true,false,false,null); //消费消息 //参数1:消费哪个队列 队列名称 //参数2:开启消息的自动确认机制 //参数3:消费时的回调接口 channel.basicConsume("hello",true,new DefaultConsumer(channel){ @Override//最后一个参数:消息队列中取出的消息 public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException { System.out.println("获取消息 " + new String(body)); } }); } }
运行生产者类,然后再运行消费者类,就可以看到,消费者类拿到生产者的消息了~
-
2.work quene(工作队列)模型
一个消费者消费的速度还赶不上生产的速度,GDP上不来,那怎么办,创造多个消费者好了。
一样还是有一个生产者:
public class Provider { public static void main(String[] args) throws IOException { //获取连接 Connection connection = RabbitMQUtil.getConnection(); Channel channel = connection.createChannel(); //通过通道声明队列 channel.queueDeclare("work", true, false, false, null); //生产消息 for (int i = 0; i < 10; i++) { channel.basicPublish("", "work", null, (i+"hello workqueue").getBytes()); } //关闭资源 RabbitMQUtil.closeConnectionAndChanel(channel, connection); } }
不同的是有两个消费者:
public class Consumer1 { public static void main(String[] args) throws IOException { Connection connection = RabbitMQUtil.getConnection(); Channel channel = connection.createChannel(); channel.basicQos(1);//一次只能消费一个消息 channel.queueDeclare("work",true,false,false,null); //参数2:消费者自动向rabbitmq确认消息消费,这里设置为false,避免消费者死掉后消息随之消失 channel.basicConsume("work",false,new DefaultConsumer(channel){ @Override public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException { System.out.println("消费者-1:" + new String(body)); //手动确认消息消费完毕,参数1:确认标识 参数2:false每次确认一个 channel.basicAck(envelope.getDeliveryTag(),false); } }); } } public class Consumer2 { ......代码跟Consumer1一样 }
可以看到,和直连模型相比,工作模型并没有多出什么额外的东西,只是新增了一个消费者而已。
需要注意的是,为了避免消费者拿到消息后死掉,使消息也丢失,我们需要将通道设置为每次只能消费一个消息(channel.basicQos(1)),同时将消费消息时的第二个参数设置为false,取消自动确认,改为在消费完毕后手动确认。
另外。
默认情况下,消费者们采用轮询的方式获取消息,你一条我一条,哪怕其中一个消费者效率很慢也是这样。但按照上述设置后,就可以实现能者多劳的效果。
-
3.Fanout(广播)模型
在广播模型中,可以有多个消费者,每个消费者有自己的临时队列,生产者的消息交给交换机,交换机来决定交给哪个消费者的队列。一般情况下所有的消费者都能拿到消息,实现一条消息被多个消费者消费。
同样有一个生产者,但是生产者不声明队列,而是声明并指向交换机:
public class Provider { public static void main(String[] args) throws IOException { Connection connection = RabbitMQUtil.getConnection(); Channel channel = connection.createChannel(); //将通道指向交换机 //参数1:交换机名称 参数2:交换机类型 channel.exchangeDeclare("logs","fanout"); //发送消息 参数1:交换机名称 参数2:路由key,在广播模型中可以忽略 参数3:消息体 channel.basicPublish("logs","",null,"fanout type messgae".getBytes()); RabbitMQUtil.closeConnectionAndChanel(channel,connection); } }
消费者同样绑定交换机,并创建临时队列,临时队列绑定交换机:
public class Consumer1 { public static void main(String[] args) throws IOException { Connection connection = RabbitMQUtil.getConnection(); Channel channel = connection.createChannel(); //通道绑定交换机 channel.exchangeDeclare("logs","fanout"); //创建临时队列 String queueName = channel.queueDeclare().getQueue(); //绑定交换机和队列 channel.queueBind(queueName,"logs",""); //消费消息 channel.basicConsume(queueName,true,new DefaultConsumer(channel){ @Override public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException { System.out.println("消费者-1:" + new String(body)); } }); } }
消费者2、消费者3都是同样的代码,这里就省略掉了。
此时启动消费者,然后再启动生产者,就能看到所有消费者都拿到了同一条消息。
-
Routing(路由)模型
在广播模型中,所有消费者都能拿到消息,但是如果我们不想让他拿到呢?如果我们想要不同的消费去拿不同类型的消息呢?这个时候就能用到路由模型了。
-
4.路由之订阅模型-Direct(直连/订阅制)
在直连模型下,队列不能直接绑定交换机了,而是要指定一个routerkey,消息发送方在向交换机发送消息时也必须指定routerkey,这样交换机在把消息交给队列时,就会通过routerkey进行判断,实现"订阅制"。
和上面的所有模型一样,首先创建一个生产者:
public class Provider { public static void main(String[] args) throws IOException { Connection connection = RabbitMQUtil.getConnection(); Channel channel = connection.createChannel(); //通过通道声明交换机,参数1:交换机名称 参数2:路由模式 channel.exchangeDeclare("logs_direct","direct"); //发送消息 String routerKey = "info"; channel.basicPublish("logs_direct",routerKey,null,("这是direct模型发布的基于RouterKey:[" + routerKey + "]发送的消息").getBytes()); RabbitMQUtil.closeConnectionAndChanel(channel,connection); } }
可以看到,这次指定了模式为direct路由模式,同时指定routerkey为info。
创建消费者1和消费者2:
public class Consumer1 { public static void main(String[] args) throws IOException { Connection connection = RabbitMQUtil.getConnection(); Channel channel = connection.createChannel(); channel.exchangeDeclare("logs_direct","direct"); //创建临时队列 String queueName = channel.queueDeclare().getQueue(); //基于routerkey绑定交换机 channel.queueBind(queueName,"logs_direct","error"); //消费消息 channel.basicConsume(queueName,true,new DefaultConsumer(channel){ @Override public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException { System.out.println("消费者1:" + new String(body)); } }); } } public class Consumer2 { public static void main(String[] args) throws IOException { Connection connection = RabbitMQUtil.getConnection(); Channel channel = connection.createChannel(); channel.exchangeDeclare("logs_direct","direct"); //创建临时队列 String queueName = channel.queueDeclare().getQueue(); //基于routerkey绑定交换机 channel.queueBind(queueName,"logs_direct","info"); channel.queueBind(queueName,"logs_direct","error"); channel.queueBind(queueName,"logs_direct","warning"); //消费消息 channel.basicConsume(queueName,true,new DefaultConsumer(channel){ @Override public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException { System.out.println("消费者2:" + new String(body)); } }); } }
很明显的,消费者1只指定了一个routerkey:error,而消费者2则是有多个routerkey:info、error、warning......如果此时运行消费者1和2,然后运行生产者,消费者1空手而归,而消费者2就会拿到消息。这是因为2绑定了和生产者一样的routerkey:info。
-
5.Routing路由模型之Topics(动态路由)模型
在direct订阅模型中,如果需要接受多种消息,就要指定多个routerkey,如果数量一多就很很麻烦,这种情况就能使用topics模型。
public class Provider { public static void main(String[] args) throws IOException { Connection connection = RabbitMQUtil.getConnection(); Channel channel = connection.createChannel(); //声明交换机和交换机类型 channel.exchangeDeclare("topics","topic"); //发布消息 String routerKey = "user.save.info"; channel.basicPublish("topics",routerKey,null,("这里是topic动态路由模型,routerkey:[" + routerKey + "]发布的消息").getBytes()); RabbitMQUtil.closeConnectionAndChanel(channel,connection); } } public class Consumer1 { public static void main(String[] args) throws IOException { Connection connection = RabbitMQUtil.getConnection(); Channel channel = connection.createChannel(); //声明交换机 channel.exchangeDeclare("topics","topic"); //创建临时队列 String queueName = channel.queueDeclare().getQueue(); //绑定交换机和队列 动态通配符形式的routerkey channel.queueBind(queueName,"topics","user.#"); channel.basicConsume(queueName,true,new DefaultConsumer(channel){ @Override public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException { System.out.println("消费者1:" + new String(body)); } }); } }
可以看到,消费者能够通过*或#通配符来动态指定routerkey,来匹配生产者user.info.xx这种形式,这样就比direct模型要灵活强大很多。
注:*匹配一个词,#匹配多个。
-
-
6.RPC模型
RPC模型并不适用于消息队列,而是用于RPC通信,所以这里就暂时不进行学习了。
-
7.PublisherConfirms(发布和订阅模型)
这是新出的一种模型,并没有得到广泛使用,也暂时不学习了。
三、Spirngboot整合RabbitMQ
和jdbc一样,rabbitmq的这种原始方式虽然可用,但是同样会产生大量样板代码,所以Springboot封装了一套东西供我们使用(所以上面这么多内容时闹什么呢......)。
-
1.初来乍到Hello直连模型
使用RabbitTemplate可以轻松发送消息:
@SpringBootTest(classes = RabbitMQApplication.class) @RunWith(SpringRunner.class) public class TestRabbitMQ { @Autowired private RabbitTemplate rabbitTemplate; @Test public void test(){ rabbitTemplate.convertAndSend("hello","helloworld"); } }
在消费者类上使用注解@RabbitListener可以监听消息,具体使用如下:
@Component //声明并创建队列 @RabbitListener(queuesToDeclare = @Queue(value = "hello")) //也可以设置队列是否持久化、是否自动删除等参数 //@RabbitListener(queuesToDeclare = @Queue(value = "hello",durable = "false",autoDelete = "true")) public class HelloConsumer { //具体接收消息的方法 @RabbitHandler public void receivel(String message){ System.out.println("message: " + message); } }
-
2.Work模型
@RabbitListener不止可以用在类上,还可以用在方法上,表明这个方法就是一个消费者,这样就能造出多个消费者,实现Work模型了。
//work模型 @Test public void testWork(){ for (int i = 0;i < 10;i++){ rabbitTemplate.convertAndSend("work","work模型" + i); } } @Component public class WorkConsumer { @RabbitListener(queuesToDeclare = @Queue("work")) public void receiver1(String message){ System.out.println("消费者1:" + message); } @RabbitListener(queuesToDeclare = @Queue("work")) public void receiver2(String message){ System.out.println("消费者2:" + message); } }
-
3.Fanout广播模型
//Fanout模型 @Test public void testFanout(){ rabbitTemplate.convertAndSend("logs","","Fanout广播模型"); } @Component public class FanoutConsumer { @RabbitListener(bindings = { @QueueBinding(value = @Queue,//创建临时队列 exchange = @Exchange(value = "logs",type = "fanout"))//绑定交换机 }) public void receive1(String message){ System.out.println("消费者1:" + message); } @RabbitListener(bindings = { @QueueBinding(value = @Queue,//创建临时队列 exchange = @Exchange(value = "logs",type = "fanout"))//绑定交换机 }) public void receive2(String message){ System.out.println("消费者2:" + message); } }
-
4.路由direct模型
//路由direct模型 @Test public void testDirect(){ rabbitTemplate.convertAndSend("directs","info","路由direct模型"); } @Component public class DirectConsumer { @RabbitListener(bindings = { @QueueBinding( value = @Queue, exchange = @Exchange(value = "directs",type = "direct"), key = {"info","error","warn"} ) }) public void receiv1(String message){ System.out.println("消费者1:" + message); } @RabbitListener(bindings = { @QueueBinding( value = @Queue, exchange = @Exchange(value = "directs",type = "direct"), key = {"error"} ) }) public void receiv2(String message){ System.out.println("消费者2:" + message); } }
-
5.动态路由topic模型
//动态路由topic模型 @Test public void testTopic(){ rabbitTemplate.convertAndSend("topics","user.save","动态路由topic模型"); } @Component public class TopicConsumer { @RabbitListener(bindings = { @QueueBinding( value = @Queue, exchange = @Exchange(type = "topic",name = "topics"), key = {"user.save","user.*"} ) }) public void receive1(String message){ System.out.println("消费者1:" + message); } @RabbitListener(bindings = { @QueueBinding( value = @Queue, exchange = @Exchange(type = "topic",name = "topics"), key = {"user.delete"} ) }) public void receive2(String message){ System.out.println("消费者2:" + message); } }
四、RabbitMQ集群
待更新......