MQ简单入门案例

小小说到老

已于 2022-07-01 16:52:37 修改

阅读量1.2k

点赞数

分类专栏：中间件文章标签： java 开发语言

于 2022-07-01 16:52:11 首次发布

本文链接：https://blog.csdn.net/qq_45382625/article/details/125417786

版权

中间件专栏收录该内容

3 篇文章 0 订阅

订阅专栏

前面mq服务器的安装就相当于交换机与队列已经安装好了，接下来用代码的方式来编写两个程序，分别作为生产者与消费者，实现消息的通信。

1、建立项目

2、引入依赖

 <!--指定 jdk 编译版本-->
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
    <dependencies>
        <!--rabbitmq 依赖客户端-->
        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <version>5.8.0</version>
        </dependency>
        <!--操作文件流的一个依赖-->
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.6</version>
        </dependency>
    </dependencies>

3、代码

Helloworld简单队列模式

消息生产者端代码：

package com.areio.rabbitmq.one;


import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

//生产者：发消息到队列
public class Producer {

    //转为大写字母的快捷键ctr+shift+u
    public static final String QUEUE_NAME="hello";

    public static void main(String[] args) throws IOException, TimeoutException {
        //1、创建一个连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //2、设置工厂ip，即rabbitmq服务所在的地址
        factory.setHost("192.168.30.100");
        //3、设置rabbitmq的用户名
        factory.setUsername("admin");
        //4、设置rabbitmq的密码
        factory.setPassword("123");
        //5、创建连接
        Connection connection = factory.newConnection();
        //6、获取连接中的信道
        Channel channel = connection.createChannel();
        //7、创建队列（使用默认交换机）
        //队列名称、队列里的消息是否持久化（默认存储在内存即不持久化，持久化则存于磁盘）、队列是否可供多个消费者消费、最后一个消费者端开链接后是否自动删除、其他参数
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        String message = "hello world";
        //8、发消息
        //发送到哪个交换机、路由的key（队列名）、其他参数、消息体
        channel.basicPublish("",QUEUE_NAME,null,message.getBytes());
        System.out.println("消息发送完毕");
    }
}

消息消费者端代码：

package com.areio.rabbitmq.one;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Consumer {

    public static final String QUEUE_NAME="hello";

    public static void main(String[] args) throws IOException, TimeoutException {
        //1、创建一个连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //2、设置工厂ip，即rabbitmq服务所在的地址
        factory.setHost("192.168.30.100");
        //3、设置rabbitmq的用户名
        factory.setUsername("admin");
        //4、设置rabbitmq的密码
        factory.setPassword("123");
        //5、创建连接
        Connection connection = factory.newConnection();
        //6、获取连接中的信道
        Channel channel = connection.createChannel();
        //7、创建队列（使用默认交换机）
        //队列名称、队列里的消息是否持久化（默认存储在内存即不持久化，持久化则存于磁盘）、队列是否可供多个消费者消费、最后一个消费者端开链接后是否自动删除、其他参数
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        //8、接受消息
        DeliverCallback deliverCallback = (consumerTag,message)->{
            System.out.println(new String(message.getBody()));
        };
        CancelCallback cancelCallback = consumerTag->{
            System.out.println("消费被中断");
        };
        //消费哪个队列、消费成功后是否自动应答、消费失败时的回调、消费者取消消费时回调
        channel.basicConsume(QUEUE_NAME,true,deliverCallback,cancelCallback);
        System.out.println("消息接收完毕");
    }
}

WorkQueue工作队列模式

工作队列(又称任务队列)的主要思想是避免立即执行资源密集型任务，而不得不等待它完成。相反我们安排任务在之后执行。我们把任务封装为消息并将其发送到队列。在后台运行的工作进程将弹出任务并最终执行作业。当有多个工作线程时，这些工作线程将一起处理这些任务。

注意：即使有多个工作线程，一个消息也只会被处理一次，因此一个消息被某个工作线程接收了，其他线程就不会收到该消息了（线程之间是竞争关系）

消息生产者端代码：

package com.areio.rabbitmq.workqueue;

import com.areio.rabbitmq.utils.RabbitMqUtils;
import com.rabbitmq.client.Channel;

import java.util.Scanner;

public class Producer {
    public static final String QUEUE_NAME = "hello";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            String mesg = scanner.next();
            channel.basicPublish("",QUEUE_NAME,null,mesg.getBytes());
            System.out.println("发送消息完成："+mesg);
        }
    }
}

消息消费者端代码：

package com.areio.rabbitmq.workqueue;

import com.areio.rabbitmq.utils.RabbitMqUtils;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;

//这是一个工作线程，即消费者
public class Worker01 {

    public static final String QUEUE_NAME = "hello";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();

        DeliverCallback deliverCallback = (consumerTag, message)->{
            System.out.println("接收到的消息："+new String(message.getBody()));
        };
        CancelCallback cancelCallback = consumerTag->{
            System.out.println(consumerTag+"消费者取消消费接口时回调此函数");
        };
        System.out.println("C2等待接收消息......");
        channel.basicConsume(QUEUE_NAME,true,deliverCallback,cancelCallback);

    }

}

此时如果我们运行两个工作线程，首先运行Worker01这个类，要再运行一次，其操作如下：

接着运行消息生产者，从控制台分别输入发送的消息AA，BB，CC，DD，此时两个工作线程轮询接收到消息：

概念1：轮询分发消息

比如有五个消息过来，第一个消息被线程1拿了，接下来第二消息就被线程2拿，第三个消息被线程3拿，一个线程分配一个消息。

概念2：消息应答

消费者完成一个任务可能需要一段时间，如果其中一个消费者处理一个长的任务并仅只完成了部分突然它挂掉了，会发生什么情况。RabbitMQ 一旦向消费者传递了一条消息，便立即将该消息标记为删除。在这种情况下，突然有个消费者挂掉了，我们将丢失正在处理的消息。以及后续发送给该消费这的消息，因为它无法接收到。

为了保证消息在发送过程中不丢失，rabbitmq 引入消息应答机制，消息应答就是: 消费者在接 收到消息并且处理该消息之后，告诉 rabbitmq 它已经处理了，rabbitmq 才可以把该消息删除。

①自动应答

消息发送后立即被认为已经传送成功，这种模式需要在 高吞吐量和数据传输安全性方面做权 衡 ,因为这种模式如果消息在接收到之前，消费者那边出现连接或者 channel 关闭，那么消息就丢失了,当然另一方面这种模式消费者那边可以传递过载的消息，没有对传递的消息数量进行限制 ，这样有可能使得消费者这边由于接收太多还来不及处理的消息，导致这些消息的积压，最终使得内存耗尽，那么这些消费者线程被操作系统杀死，所以这种模式仅适用在消费者可以高效并 以某种速率能够处理这些消息的情况下使用 。（接收到消息它就自动应答，但未必任务未必完全处理，不靠谱）

②手动应答

A .Channel.basicAck(用于肯定确认)

RabbitMQ 已知道该消息并且成功的处理消息，可以将其丢弃了

B .Channel.basicNack(用于否定确认)

C .Channel.basicReject(用于否定确认)

与 Channel.basicNack 相比少一个参数

不处理该消息了直接拒绝，可以将其丢弃了

手动应答的好处是可以批量应答并且减少网络拥堵

Channel.basicAck(deliveryTag,true);

multiple 的 true 和 false 代表不同意思

true 代表批量应答 channel 上未应答的消息

比如说 channel 上有传送 tag 的消息 5,6,7,8 当前 tag 是 8 那么此时

5-8 的这些还未应答的消息都会被确认收到消息应答（不推荐批量应答，因为8处理完成了不代表其他也完成了）

false 同上面相比,

只会应答 tag=8 的消息 5,6,7 这三个消息依然不会被确认收到消息应答

生产者代码：

public class ManualAckPro01 {
    public static final String QUEUE_NAME="ack_queue";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        /**
         *  队列名称
         *  队列里的消息是否持久化（默认存储在内存即不持久化，持久化则存于磁盘）
         *  队列是否可供多个消费者消费
         *  最后一个消费者端开链接后是否自动删除
         *  其他参数
         */
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            String mesg = scanner.next();
            channel.basicPublish("",QUEUE_NAME,null,mesg.getBytes("UTF-8"));
            System.out.println("发送消息完成："+mesg);
        }
    }
}

消费者1代码：

/*
自动应答：收到消息后不管任务是否处理完成都会立马应答并在队列中将消息删除
手动应答：任务处理完成才应答
实验目标：消息在手动应答模式下是不会丢失的，因为一旦消息在某个消费者处处理失败，它会将这个消息重新放回队列中，给其他队列消费，处理完成后，消费者才给出应答，此时消息才会被删除
异同：
    自动应答  消费者收到消息后立马应答-->应答后删除消息（未处理完成的消息被删除则丢失消息）
    立马应答  消费者处理完成后才会应答-->应答后删除消息（消息已处理完成，不丢失）
 */
public class ManualAckCon01 {

    public static final String QUEUE_NAME="ack_queue";

    public static void main(String[] args) throws Exception {

        Channel channel = RabbitMqUtils.getChannel();
        System.out.println("C1等待接收消息处理时间较短");

        //采用手动应答
        boolean autoAck = false;
        channel.basicConsume(QUEUE_NAME,autoAck,(consumerTag,message)->{
            SleepUtils.sleep(1);
            System.out.println("接收到消息："+new String(message.getBody(),"UTF-8"));
            /**
             * 手动应答
             *
             * 1、消息的标记
             * 2、是否批量应答
             * 3、
             */
            channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
            },(consumerTag)->{
                    System.out.println(consumerTag+":消费者取消消费时接口回调");
        });
    }
}

消费者2代码：

/*
自动应答：收到消息后不管任务是否处理完成都会立马应答并在队列中将消息删除
手动应答：任务处理完成才应答
实验目标：消息在手动应答模式下是不会丢失的，因为一旦消息在某个消费者处处理失败，它会将这个消息重新放回队列中，给其他队列消费，处理完成后，消费者才给出应答，此时消息才会被删除
异同：
    自动应答  消费者收到消息后立马应答-->应答后删除消息（未处理完成的消息被删除则丢失消息）
    立马应答  消费者处理完成后才会应答-->应答后删除消息（消息已处理完成，不丢失）
 */
public class ManualAckCon02 {

    public static final String QUEUE_NAME="ack_queue";

    public static void main(String[] args) throws Exception {

        Channel channel = RabbitMqUtils.getChannel();
        System.out.println("C2等待接收消息处理时间较长");

        //采用手动应答
        boolean autoAck = false;
        channel.basicConsume(QUEUE_NAME,autoAck,(consumerTag,message)->{
            SleepUtils.sleep(30);
            System.out.println("接收到消息："+new String(message.getBody(),"UTF-8"));
            /**
             * 手动应答
             *
             * 1、消息的标记
             * 2、是否批量应答
             * 3、
             */
            channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
        },(consumerTag)->{
            System.out.println(consumerTag+":消费者取消消费时接口回调");
        });
    }
}

操作：启动生产者，再启动两个消费者，接着在控制台分别输入AA、BB，看到C1收到AA，此时C2在30s后可看到BB。如果再发送CC、DD，且把C2的程序在30s内关闭，此时C1能收到CC，DD（C2没有处理完成DD，此时消息放回队列重新被消费）

预期：生产者发送AA、BB，此时消费者1间隔1s后收到AA，如果未出现错误，消费者2在30s后可收到BB，如果宕机等，那么BB回到队列，由消费者1来处理

概念3：消息自动重新入队

如果消费者由于某些原因失去连接(其通道已关闭，连接已关闭或 TCP 连接丢失)，导致消息未发送 ACK 确认，RabbitMQ 将了解到消息未完全处理，并将对其重新排队。如果此时其他消费者可以处理，它将很快将其重新分发给另一个消费者。这样，即使某个消费者偶尔死亡，也可以确保不会丢失任何消息。

概念4：队列持久化

前面我们已经知道了如何处理任务不丢失的情况，但是如何保障当 RabbitMQ 服务停掉以后消息生产者发送过来的消息不丢失。默认情况下 RabbitMQ 退出或由于某种原因崩溃时，它会忽视（丢失）队列和消息，除非告知它不要这样做。确保消息不会丢失需要做两件事：我们需要将队列和消息都标 记为持久化 。

操作：只需要在生成队列时将durable标志设为true

注意：如果之前声明的队列不是持久化的，需要把原先队列先删除，或者重新创建一个持久化的队列，不然就会出现错误

此时这个队列在mq管理界面可以看到字母D

概念5：消息持久化（生产者方设置）

要想让消息实现持久化需要在消息生产者修改代码，在发布消息时的channel.basicPlush()方法添加MessageProperties.PERSISTENT_TEXT_PLAIN 这个属性。

将消息标记为持久化并不能完全保证不会丢失消息。尽管它告诉 RabbitMQ 将消息保存到磁盘，但是这里依然存在当消息刚准备存储在磁盘的时候但是还没有存储完，消息还在缓存的一个间隔点。此时并没有真正写入磁盘。持久性保证并不强，但是对于我们的简单任务队列而言，这已经绰绰有余了。如果需要更强有力的持久化策略，参考后边发布确认章节。

概念6：不公平分发（消费者方设置）

在最开始的时候我们学习到 RabbitMQ 分发消息采用的轮训分发，但是在某种场景下这种策略并不是很好，但是有两个消费者在处理任务，其中有个消费者 1 处理任务的速度非常快，而另外一个消费者 2 处理速度却很慢，此时采用轮训分发的化就会到这处理速度快的这个消费者很大一部分时间处于空闲状态，而处理慢的那个消费者一直在干活。

为了避免这种情况，我们可以设置参数 channel.basicQos(1);

概念7：预取值

本身消息的发送就是异步发送的，所以在任何时候， channel 上肯定不止只有一个消息，另外来自消费者的手动确认本质上也是异步的。因此这里就存在一个未确认的消息缓冲区，因此希望开发人员能限制此 缓冲区的大小，以避免缓冲区里面无限制的未确认消息问题 。这个时候就可以通过使用 basic.qos 方法设置“预取计数”值来完成的。该值定义通道上允许的未确认消息的最大数量 。一旦数量达到配置的数量，RabbitMQ 将停止在通道上传递更多消息，除非至少有一个未处理的消息被确认，例如，假设在通道上有未确认的消息 5 、 6 、 7 ， 8 ，并且通道的预取计数设置为 4 ，此时 RabbitMQ 将不会在该通道上再传递任何消息，除非至少有一个未应答的消息被 ack 。比方说 tag=6 这个消息刚刚被确认 ACK ， RabbitMQ 将会感知这个情况到并再发送一条消息。

这里的2、5是堆积在信道的消息数，而不是最终处理的消息数，假如11 22分别进入C1、C2的信道，接着C1把11处理完成，22堆积在C2信道中，此时生产者再发送33 44 55, 33 44堆积在C1信道，（此时信道C1只有两个，因为前面的11已经被处理完成）

发布确认模式

单个确认发布

它是一种 同步确认发布 的方式，也就是发布一个消息之后只有它被确认发布，后续的消息才能继续发布,waitForConfirmsOrDie(long)这个方法只有在消息被确认的时候才返回，如果在指定时间范围内这个消息没有被确认那么它将抛出异常。

最大的缺点就是: 发布速度特别的慢， 因为如果没有确认发布的消息就会阻塞所有后续消息的发布，这种方式最多提供每秒不超过数百条发布消息的吞吐量。

//发布1000条单独确认的消息，耗时：1207ms
public class SingleConfirmPro {

    //批量发消息的个数
    public static final int MESSAGE_COUNT=1000;

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        String queueName = UUID.randomUUID().toString();
        channel.queueDeclare(queueName,true,false,false,null);
        //开启发布确认
        channel.confirmSelect();
        //开始时间
        long begin = System.currentTimeMillis();
        //批量发消息
        for(int i=0;i<MESSAGE_COUNT;i++){
            String message = i+"";
            channel.basicPublish("",queueName,null,message.getBytes());
            //单个消息就立马进行确认
            boolean flag = channel.waitForConfirms();
            if (flag){
                System.out.println("消息发送成功");
            }
        }
        //结束时间
        long end = System.currentTimeMillis();
        System.out.println("发布"+MESSAGE_COUNT+"条单独确认的消息，耗时："+(end-begin)+"ms");
    }
}

批量发布确认

先发布一批消息然后一起确认可以极大地提高吞吐量，当然这种方式的缺点就是:当发生故障导致发布出现问题时，不知道是哪个消息出现问题了，我们必须将整个批处理保存在内存中，以记录重要的信息而后重新发布消息。当然这种方案仍然是同步的，也一样阻塞消息的发布。

//发布1000条消息，间隔消息数量为100时批量确认，耗时：123ms
public class BatchConfirmPro {
    //批量发消息的个数
    public static final int MESSAGE_COUNT=1000;

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        String queueName = UUID.randomUUID().toString();
        channel.queueDeclare(queueName,true,false,false,null);
        //开启发布确认
        channel.confirmSelect();
        //开始时间
        long begin = System.currentTimeMillis();
        //多少条就批量确认一次
        int batchSize=100;
        //批量发消息并进行批量确认
        for(int i=0;i<MESSAGE_COUNT;i++){
            String message = i+"";
            channel.basicPublish("",queueName,null,message.getBytes());
            //消息积累100条再批量确认一次
            if (i%batchSize==0){
                channel.waitForConfirms();
            }
        }
        //结束时间
        long end = System.currentTimeMillis();
        System.out.println("发布"+MESSAGE_COUNT+"条消息，间隔消息数量为100时批量确认，耗时："+(end-begin)+"ms");
    }
}