RabbitMQ入门笔记

一、写在前面

  • 什么是消息队列?

顾名思义,消息队列就是一个能够存放消息的队列,通常有一个生产者生产消息,一个或多个消费者消费消息。

消息队列在分布式系统中运用十分广泛,有异步处理、应用解耦、流量削峰等用途。

当然,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集群

待更新......

相关推荐
厌世小晨宇yu.28 分钟前
Git超详细笔记包含IDEA整合操作
笔记·git·intellij-idea
songqq2733 分钟前
【快速入门】Kafka的安装部署
分布式·kafka
学生信的大叔43 分钟前
Conpair: 配对样本一致性concordance与污染contamination分析
笔记
天冬忘忧1 小时前
Spark 中 RDD 的诞生:原理、操作与分区规则
大数据·分布式·spark
dal118网工任子仪2 小时前
web安全漏洞之命令注入
笔记·学习·安全·web安全·网络安全
java亮小白19972 小时前
ArcGIS软件之“计算面积几何”地图制作
经验分享·笔记
黄俊懿3 小时前
【架构师从入门到进阶】第一章:架构设计基础——第五节:架构演进(缓存到微服务)
分布式·后端·缓存·微服务·架构·系统架构·架构设计
ljt27249606614 小时前
鸿蒙笔记--skills
笔记·harmonyos
songqq274 小时前
kafka面试夺命30问
分布式·面试·kafka
mailangduoduo4 小时前
Web前端开发--HTML语言
前端·经验分享·笔记·html·爬虫前提知识