RabbitMQ学习：RabbitMQ的六种工作模式之简单和工作模式(三)

悠悠 2022-10-22 10:57 158阅读 0赞

![fc02de17b4828ea3adf4450815c840f3.png][]

*来源**：my.oschina.net/u/4115134/blog/3228182*

## RabbitMQ的六种工作模式 ##

首先开启虚拟机上的rabbitmq服务器

# 启动服务
    systemctl start rabbitmq-server

### 一、简单模式 ###

RabbitMQ是一个消息中间件，你可以想象它是一个邮局。当你把信件放到邮箱里时，能够确信邮递员会正确地递送你的信件。RabbitMq就是一个邮箱、一个邮局和一个邮递员。

*  发送消息的程序是生产者
 *  队列就代表一个邮箱。虽然消息会流经RbbitMQ和你的应用程序，但消息只能被存储在队列里。队列存储空间只受服务器内存和磁盘限制，它本质上是一个大的消息缓冲区。多个生产者可以向同一个队列发送消息，多个消费者也可以从同一个队列接收消息.
 *  消费者等待从队列接收消息

![b04900523a40a6097fd53e1259e2c25a.png][]

### 创建Rabbitmq-demo 的测试项 ###

#### 1、pom.xml ####

添加 slf4j 依赖, 和 rabbitmq amqp 依赖

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>
      <groupId>com.qile</groupId>
      <artifactId>rabbitmq</artifactId>
      <version>0.0.1-SNAPSHOT</version>
      
      <dependencies>
      <dependency>
       <groupId>com.rabbitmq</groupId>
       <artifactId>amqp-client</artifactId>
       <version>5.4.3</version>
      </dependency>
      <dependency>
       <groupId>org.slf4j</groupId>
       <artifactId>slf4j-api</artifactId>
       <version>1.8.0-alpha2</version>
      </dependency>
      <dependency>
       <groupId>org.slf4j</groupId>
       <artifactId>slf4j-log4j12</artifactId>
       <version>1.8.0-alpha2</version>
      </dependency>
     </dependencies>
    
     <build>
      <plugins>
       <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.8.0</version>
        <configuration>
         <source>1.8</source>
         <target>1.8</target>
        </configuration>
       </plugin>
      </plugins>
     </build>
    
    </project>

#### 2. 生产者发送消息--HelloWorld ####

package rabbitmq.simple;
    
    import java.io.IOException;
    import java.util.concurrent.TimeoutException;
    
    import com.rabbitmq.client.Channel;
    import com.rabbitmq.client.Connection;
    import com.rabbitmq.client.ConnectionFactory;
    
    public class Test1 {
    
     public static void main(String[] args) throws IOException, TimeoutException {
      
      /**
       * 1. 建立连接
       * 2. 创建队列：helloworld
       * 3. 向队列发送数据
       */
      ConnectionFactory f = new ConnectionFactory();
      f.setHost("192.168.64.140");
      f.setPort(5672);
      f.setUsername("admin");
      f.setPassword("admin");
      
      /*
       * 与rabbitmq服务器建立连接,
       * rabbitmq服务器端使用的是nio,会复用tcp连接,
       * 并开辟多个信道与客户端通信
       * 以减轻服务器端建立连接的开销
       */
      Connection con = f.newConnection();
      //创建通道
      Channel c = con.createChannel();
      
      /*
       * 声明队列,会在rabbitmq中创建一个队列
       * 如果已经创建过该队列，就不能再使用其他参数来创建
       * 
       * 参数含义:
       *   -queue:      队列名称
       *   -durable:    队列持久化,true表示RabbitMQ重启后队列仍存在
       *   -exclusive:  排他,true表示限制仅当前连接可用
       *   -autoDelete: 当最后一个消费者断开后,是否删除队列
       *   -arguments:  其他参数
       */
         c.queueDeclare("helloworld",false,false,false,null);
      
         /*
       * 发布消息
       * 这里把消息向默认交换机发送.
       * 默认交换机隐含与所有队列绑定,routing key即为队列名称
       * 
       * 参数含义:
       *  -exchange: 交换机名称,空串表示默认交换机"(AMQP default)",不能用 null 
       *  -routingKey: 对于默认交换机,路由键就是目标队列名称
       *  -props: 其他参数,例如头信息
       *  -body: 消息内容byte[]数组
       */
         c.basicPublish("","helloworld",null, 
        ("Hello World!" + System.currentTimeMillis()).getBytes());
      System.out.println("消息已发出");
      
      c.close();
      con.close();
     }
    }

这时Run as 得到

![720de04e08e66d38af0b9fe0ad7bafb3.png][]

在rabbitmq客户端有：

![725e34581c0b77803a3ac308bc93d6f5.png][]  
之后编写消费者接受消息

#### 3、消费者接收消息 ####

package rabbitmq.simple;
    
    import java.io.IOException;
    import java.util.concurrent.TimeoutException;
    
    import com.rabbitmq.client.CancelCallback;
    import com.rabbitmq.client.Channel;
    import com.rabbitmq.client.Connection;
    import com.rabbitmq.client.ConnectionFactory;
    import com.rabbitmq.client.DeliverCallback;
    import com.rabbitmq.client.Delivery;
    
    public class Test2 {
    
     public static void main(String[] args) throws IOException, TimeoutException {
      
      /**
       * 1. 建立连接
       * 2. 创建队列：helloworld
       * 3. 向队列发送数据
       */
      ConnectionFactory f = new ConnectionFactory();
      f.setHost("192.168.64.140");
      f.setPort(5672);
      f.setUsername("admin");
      f.setPassword("admin");
      Connection con = f.newConnection();  //创建连接
      Channel c = con.createChannel();     //创建通道
      
      //定义队列，服务器没有这个队列会创建，若有什么都不做
         c.queueDeclare("helloworld",false,false,false,null);
      
         //收到消息后用来处理消息的回调对象
         DeliverCallback deliverCallback = new DeliverCallback() {
       @Override
       public void handle(String consumerTag, Delivery message) throws IOException {
        byte[] a = message.getBody();
        String msg = new String(a);
        System.out.println("收到" + msg);
       }
         };
         
         //消费者取消时的回调对象
         CancelCallback cancelCallback = new CancelCallback() {
       @Override
       public void handle(String consumerTag) throws IOException {
        
       }
      };
      
         //开始消费数据
         c.basicConsume("helloworld",true,deliverCallback,cancelCallback);
     }
    
    }

此时，在之前所积累的两条消息将会在你程序运转之时，显示出来，这是再去运转生产者，将会直接显示出发送的数据

![4fd4c6fbcc99d2df8494d704cfc3f823.png][]

### 二、工作模式 ###

![194e9364c4f7ef7732d00ab511a7c4d6.png][]

工作队列(即任务队列)背后的主要思想是避免立即执行资源密集型任务，并且必须等待它完成。相反，我们将任务安排在稍后完成。

我们将任务封装为消息并将其发送到队列。后台运行的工作进程将获取任务并最终执行任务。当运行多个消费者时，任务将在它们之间分发。

使用任务队列的一个优点是能够轻松地并行工作。如果我们正在积压工作任务，我们可以添加更多工作进程，这样就可以轻松扩展。推荐：[Java面试练题宝典][Java]

#### 1、生产者发送消息 ####

这里模拟耗时任务,发送的消息中,每个点使工作进程暂停一秒钟,例如"Hello…"将花费3秒钟来处理

package rabbitmq.work;
    
    import java.util.Scanner;
    
    import com.rabbitmq.client.Channel;
    import com.rabbitmq.client.Connection;
    import com.rabbitmq.client.ConnectionFactory;
    
    public class Test1 {
     public static void main(String[] args) throws Exception {
      /**
       * 1. 建立连接
       * 2. 创建队列：helloworld
       * 3. 向队列发送数据
       */
      ConnectionFactory f = new ConnectionFactory();
      f.setHost("192.168.64.140");
      f.setPort(5672);
      f.setUsername("admin");
      f.setPassword("admin");
      
      Connection c = f.newConnection();  //创建连接
      Channel ch = c.createChannel();  //创建通道
      //参数:queue,durable,exclusive,autoDelete,arguments
      ch.queueDeclare("helloworld", false,false,false,null);
    
      /**
       * 模拟耗时消息
       * 发送的字符串中，有一个点字符，消费者处理的时候就暂停1秒
       */
      //循环输入消息发送到rabbitmq
      while (true) {
       System.out.print("输入消息: ");
       String msg = new Scanner(System.in).nextLine();
       //如果输入的是"exit"则结束生产者进程
       if ("exit".equals(msg)) {
        break;
       }
       //参数:exchage,routingKey,props,body
       ch.basicPublish("", "helloworld", null, msg.getBytes());
       System.out.println("消息已发送: "+msg);
      }
    
      c.close();
     }
    }

#### 2、消费者接收消息 ####

package rabbitmq.work;
    
    import java.io.IOException;
    import java.util.concurrent.TimeoutException;
    
    import com.rabbitmq.client.CancelCallback;
    import com.rabbitmq.client.Channel;
    import com.rabbitmq.client.Connection;
    import com.rabbitmq.client.ConnectionFactory;
    import com.rabbitmq.client.DeliverCallback;
    import com.rabbitmq.client.Delivery;
    
    public class Test2 {
     public static void main(String[] args) throws Exception {
      
      /**
       * 1. 建立连接
       * 2. 创建队列：helloworld
       * 3. 向队列发送数据
       */
      ConnectionFactory f = new ConnectionFactory();
      f.setHost("192.168.64.140");
      f.setUsername("admin");
      f.setPassword("admin");
      Connection c = f.newConnection();  //创建连接
      Channel ch = c.createChannel();  //创建通道
      
      ch.queueDeclare("helloworld",false,false,false,null);
      System.out.println("等待接收数据");
      
      //收到消息后用来处理消息的回调对象
      DeliverCallback callback = new DeliverCallback() {
       @Override
       public void handle(String consumerTag, Delivery message) throws IOException {
        String msg = new String(message.getBody(), "UTF-8");
        System.out.println("收到: "+msg);
    
        //遍历字符串中的字符,每个点使进程暂停一秒
        for (int i = 0; i < msg.length(); i++) {
         if (msg.charAt(i)=='.') {
          try {
           Thread.sleep(1000);
          } catch (InterruptedException e) {
          }
         }
        }
        System.out.println("处理结束");
       }
      };
      
      //消费者取消时的回调对象
      CancelCallback cancel = new CancelCallback() {
       @Override
       public void handle(String consumerTag) throws IOException {
       }
      };
      
      ch.basicConsume("helloworld", true, callback, cancel);
     }
    }

#### 3.运行测试 ####

运行：

*  一个生产者
 *  两个消费者

生产者发送多条消息  
如：1，2，3，4，5，...两个消费者分别收到：

*  消费者一：1，3，5，...
 *  消费者二：2，4，...

rabbtimq在所有消费者中轮询分布消息，把消息均匀发送给所有消费者。

#### 4.消息确认 ####

一个消费者接收消息后,在消息没有完全处理完时就挂掉了,那么这时会发生什么呢?

就现在的代码来说,rabbitmq把消息发送给消费者后,会立即删除消息,那么消费者挂掉后,它没来得及处理的消息就会丢失

如果生产者发送以下消息:

> 1… 2 3 4 5

两个消费者分别收到:

> 费者一: 1…, 3, 5
> 
> 费者二: 2, 4

当消费者一收到所有消息后,要话费7秒时间来处理第一条消息,这期间如果关闭该消费者,那么1未处理完成,3,5则没有被处理

我们并不想丢失任何消息, 如果一个消费者挂掉,我们想把它的任务消息派发给其他消费者

为了确保消息不会丢失，rabbitmq支持消息确认(回执)。当一个消息被消费者接收到并且执行完成后，消费者会发送一个ack (acknowledgment) 给rabbitmq服务器, 告诉他我已经执行完成了，你可以把这条消息删除了。

如果一个消费者没有返回消息确认就挂掉了（信道关闭，连接关闭或者TCP链接丢失），rabbitmq就会明白，这个消息没有被处理完成，rabbitmq就会把这条消息重新放入队列，如果在这时有其他的消费者在线，那么rabbitmq就会迅速的把这条消息传递给其他的消费者，这样就确保了没有消息会丢失。

这里不存在消息超时, rabbitmq只在消费者挂掉时重新分派消息, 即使消费者花非常久的时间来处理消息也可以

手动消息确认默认是开启的，前面的例子我们通过autoAck=ture把它关闭了。我们现在要把它设置为false，然后工作进程处理完意向任务时,发送一个消息确认(回执)。

package rabbitmq.work;
    
    import java.io.IOException;
    import java.util.concurrent.TimeoutException;
    
    import com.rabbitmq.client.CancelCallback;
    import com.rabbitmq.client.Channel;
    import com.rabbitmq.client.Connection;
    import com.rabbitmq.client.ConnectionFactory;
    import com.rabbitmq.client.DeliverCallback;
    import com.rabbitmq.client.Delivery;
    
    public class Test2 {
     public static void main(String[] args) throws Exception {
      
      /**
       * 1. 建立连接
       * 2. 创建队列：helloworld
       * 3. 向队列发送数据
       */
      ConnectionFactory f = new ConnectionFactory();
      f.setHost("192.168.64.140");
      f.setUsername("admin");
      f.setPassword("admin");
      Connection c = f.newConnection();  //创建连接
      Channel ch = c.createChannel();  //创建通道
      
      //声明队列
      ch.queueDeclare("helloworld",false,false,false,null);
      System.out.println("等待接收数据");
      
      //收到消息后用来处理消息的回调对象
      DeliverCallback callback = new DeliverCallback() {
       @Override
       public void handle(String consumerTag, Delivery message) throws IOException {
        String msg = new String(message.getBody(), "UTF-8");
        System.out.println("收到: "+msg);
        for (int i = 0; i < msg.length(); i++) {
         if (msg.charAt(i)=='.') {
          try {
           Thread.sleep(1000);
          } catch (InterruptedException e) {
          }
         }
        }
        System.out.println("处理结束");
        //发送回执
        ch.basicAck(message.getEnvelope().getDeliveryTag(), false);
       }
      };
      
      //消费者取消时的回调对象
      CancelCallback cancel = new CancelCallback() {
       @Override
       public void handle(String consumerTag) throws IOException {
       }
      };
      
      //autoAck设置为false,则需要手动确认发送回执
      ch.basicConsume("helloworld", false, callback, cancel);
     }
    }

使用以上代码，就算杀掉一个正在处理消息的工作进程也不会丢失任何消息，工作进程挂掉之后，没有确认的消息就会被自动重新传递。推荐：[Java面试练题宝典][Java]

忘记确认(ack)是一个常见的错误, 这样后果是很严重的, 由于未确认的消息不会被释放, rabbitmq会吃掉越来越多的内存

可以使用下面命令打印工作队列中未确认消息的数量

rabbitmqctl list_queues name messages_ready messages_unacknowledged

当处理消息时异常中断, 可以选择让消息重回队列重新发送. nack 操作可以是消息重回队列, 可以使用 basicNack() 方法:

// requeue为true时重回队列, 反之消息被丢弃或被发送到死信队列
    c.basicNack(tag, multiple, requeue)

#### 5.合理地分发 ####

rabbitmq会一次把多个消息分发给消费者, 这样可能造成有的消费者非常繁忙, 而其它消费者空闲. 而rabbitmq对此一无所知, 仍然会均匀的分发消息

我们可以使用 basicQos(1) 方法, 这告诉rabbitmq\_一次只向消费者发送一条消息\_, 在返回确认回执前, 不要向消费者发送新消息. 而是把消息发给下一个空闲的消费者

![990ffc4f23f320251d9dbb526f81d6fc.png][]

#### 6.消息持久化 ####

当rabbitmq关闭时, 我们队列中的消息仍然会丢失, 除非明确要求它不要丢失数据

要求rabbitmq不丢失数据要做如下两点: 把队列和消息都设置为可持久化(durable)

队列设置为可持久化, 可以在定义队列时指定参数durable为true

//第二个参数是持久化参数durable
    ch.queueDeclare("helloworld", true, false, false, null);

由于之前我们已经定义过队列"hello"是不可持久化的, 对已存在的队列, rabbitmq不允许对其定义不同的参数, 否则会出错, 所以这里我们定义一个不同名字的队列"task\_queue"

//定义一个新的队列,名为 task_queue
    //第二个参数是持久化参数 durable
    ch.queueDeclare("task_queue", true, false, false, null);

生产者和消费者代码都要修改

这样即使rabbitmq重新启动, 队列也不会丢失. 现在我们再设置队列中消息的持久化, 使用`MessageProperties.PERSISTENT_TEXT_PLAIN`参数

//第三个参数设置消息持久化
    ch.basicPublish("", "task_queue",
                MessageProperties.PERSISTENT_TEXT_PLAIN,
                msg.getBytes());

下面是"工作模式"最终完成的生产者和消费者代码

#### 7.生产者代码 ####

package rabbitmq.work;
    
    import java.util.Scanner;
    
    import com.rabbitmq.client.Channel;
    import com.rabbitmq.client.Connection;
    import com.rabbitmq.client.ConnectionFactory;
    import com.rabbitmq.client.MessageProperties;
    
    public class Test3 {
     public static void main(String[] args) throws Exception {
      ConnectionFactory f = new ConnectionFactory();
      f.setHost("192.168.64.140");
      f.setPort(5672);
      f.setUsername("admin");
      f.setPassword("admin");
      
      Connection c = f.newConnection();
      Channel ch = c.createChannel();
      
      //第二个参数设置队列持久化
      ch.queueDeclare("task_queue", true,false,false,null);
    
      while (true) {
       System.out.print("输入消息: ");
       String msg = new Scanner(System.in).nextLine();
       if ("exit".equals(msg)) {
        break;
       }
       
       //第三个参数设置消息持久化
       ch.basicPublish("", "task_queue", MessageProperties.PERSISTENT_TEXT_PLAIN, msg.getBytes("UTF-8"));
       System.out.println("消息已发送: "+msg);
      }
    
      c.close();
     }
    }

#### 8.消费者代码 ####

package rabbitmq.work;
    
    import java.io.IOException;
    import java.util.concurrent.TimeoutException;
    
    import com.rabbitmq.client.CancelCallback;
    import com.rabbitmq.client.Channel;
    import com.rabbitmq.client.Connection;
    import com.rabbitmq.client.ConnectionFactory;
    import com.rabbitmq.client.DeliverCallback;
    import com.rabbitmq.client.Delivery;
    
    public class Test4 {
     public static void main(String[] args) throws Exception {
      ConnectionFactory f = new ConnectionFactory();
      f.setHost("192.168.64.140");
      f.setUsername("admin");
      f.setPassword("admin");
      Connection c = f.newConnection();
      Channel ch = c.createChannel();
      
      //定义一个新的队列,名为 task_queue
      //设定第二个参数是持久化参数 durable为true
      ch.queueDeclare("task_queue",true,false,false,null);
      
      System.out.println("等待接收数据");
      
      ch.basicQos(1); //一次只接收一条消息
      
      //收到消息后用来处理消息的回调对象
      DeliverCallback callback = new DeliverCallback() {
       @Override
       public void handle(String consumerTag, Delivery message) throws IOException {
        String msg = new String(message.getBody(), "UTF-8");
        System.out.println("收到: "+msg);
        for (int i = 0; i < msg.length(); i++) {
         if (msg.charAt(i)=='.') {
          try {
           Thread.sleep(1000);
          } catch (InterruptedException e) {
          }
         }
        }
        System.out.println("处理结束");
        //发送回执
        ch.basicAck(message.getEnvelope().getDeliveryTag(), false);
       }
      };
      
      //消费者取消时的回调对象
      CancelCallback cancel = new CancelCallback() {
       @Override
       public void handle(String consumerTag) throws IOException {
       }
      };
      
      //autoAck设置为false,则需要手动确认发送回执
      ch.basicConsume("task_queue", false, callback, cancel);
     }
    }

#### 9.总结 ####

![2bdbad711a92e8000fc8638011cb24c6.png][]

前文

[RabbitMQ学习：安装RabbitMQ及RabbitMQ的初步配置(一)][RabbitMQ_RabbitMQ_RabbitMQ]

[RabbitMQ学习：RabbitMQ的基本概念及RabbitMQ使用场景(二)][RabbitMQ_RabbitMQ_RabbitMQ 1]

推荐好文
    
    强大，10k+点赞的 SpringBoot 后台管理系统竟然出了详细教程！
    
    分享一套基于SpringBoot和Vue的企业级中后台开源项目，代码很规范！
    能挣钱的，开源 SpringBoot 商城系统，功能超全，超漂亮！

[fc02de17b4828ea3adf4450815c840f3.png]: /images/20221022/3d2c96414bbf4bfea5294966cd9c690a.png
[b04900523a40a6097fd53e1259e2c25a.png]: /images/20221022/d84f8f4484c8447ab179ef43885d146c.png
[720de04e08e66d38af0b9fe0ad7bafb3.png]: /images/20221022/8fee1a7d9c214a99a74b24f90d1f2f2f.png
[725e34581c0b77803a3ac308bc93d6f5.png]: /images/20221022/73b2184ebf20485e902b82f6588eebfe.png
[4fd4c6fbcc99d2df8494d704cfc3f823.png]: /images/20221022/149e85b2a9aa44f2925cc4d8b1ebdd9d.png
[194e9364c4f7ef7732d00ab511a7c4d6.png]: /images/20221022/5f5ec0d9b5c54e98a0add4985aa2261a.png
[Java]: https://mp.weixin.qq.com/s?__biz=MzIyNDU2ODA4OQ%3D%3D&idx=1&mid=2247486846&scene=21&sn=75bd4dcdbaad73191a1e4dbf691c118a#wechat_redirect
[990ffc4f23f320251d9dbb526f81d6fc.png]: /images/20221022/82d501b01ad44598b04475a10d5f86ad.png
[2bdbad711a92e8000fc8638011cb24c6.png]: /images/20221022/364fa6f7daa24a9c85c10a8d3d4ad5ba.png
[RabbitMQ_RabbitMQ_RabbitMQ]: http://mp.weixin.qq.com/s?__biz=MzU2MTI4MjI0MQ%3D%3D&chksm=fc79aba4cb0e22b2574741e00c47f293e72d45d3ce246bd15149908e7dc318f58e3527a871df&idx=2&mid=2247501322&scene=21&sn=d05387ede5468f92b64e7961a8da9374#wechat_redirect
[RabbitMQ_RabbitMQ_RabbitMQ 1]: http://mp.weixin.qq.com/s?__biz=MzU2MTI4MjI0MQ%3D%3D&chksm=fc79ab97cb0e22816041eb4dd3612907246ee0b0a9fbe57d75b17c37cb61951a72745195f072&idx=3&mid=2247501369&scene=21&sn=6910fc33e7d3a22758914f64cc6c3f86#wechat_redirect