rabbitMq入门一

最新推荐文章于 2023-07-18 11:30:17 发布

义明

最新推荐文章于 2023-07-18 11:30:17 发布

阅读量411

点赞数

分类专栏：中间件文章标签： java junit rabbitmq

本文链接：https://blog.youkuaiyun.com/ZYMruanjianjishu/article/details/125913276

版权

中间件专栏收录该内容

5 篇文章

订阅专栏

一、Hello world

在下图中，“ P”是我们的生产者，“ C”是我们的消费者。中间的框是一个队列-RabbitMQ 代
表使用者保留的消息缓冲区

项目 pom 配置如下

    <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>

1.生产者

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 {
    private final static String QUEUE_NAME = "hello";

    public static void main(String[] args) throws Exception {
        // 创建一个连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        // 工厂IP
        factory.setHost("192.168.168.220");
        // rabbitmq 用户名
        factory.setUsername("admin");
        // 密码
        factory.setPassword("123");

        // 创建一个连接
        Connection connection = factory.newConnection();
        // 获取信道
        Channel channel = connection.createChannel();

        /**
         * 生成一个队列
         * 第一个参数：队列名称
         * 第二个参数: 队列中的消息是否持久化，默认消息是存储在内存中
         * 第三个参数：消息消费时，可否被多个消费者消费
         * 第四个参数：是否自动删除，最后一个消费者断开连接后，该对列是否自动删除 true 自动删除
         * 第五个参数: 其它参数
         */
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        // 发送的消息
        String message = "hello world";
        /**
         * 发送消息
         * 第一个参数: 发送到哪个交换机
         * 第二个参数: 队列名称，消息发送到该队列
         * 第三个参数: 其它参数
         * 第四个参数： 发送消息的消息体
         */
        channel.basicPublish("",QUEUE_NAME,null,message.getBytes());
        System.out.println("消息发送完毕");
    }
}

2.消费者

import com.rabbitmq.client.*;

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

public class Consumer {

    private final static String QUEUE_NAME = "hello";

    public static void main(String[] args) throws Exception {
        // 创建一个连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        // 工厂IP
        factory.setHost("192.168.168.220");
        // rabbitmq 用户名
        factory.setUsername("admin");
        // 密码
        factory.setPassword("123");

        // 创建一个连接
        Connection connection = factory.newConnection();
        // 获取信道
        Channel channel = connection.createChannel();
        System.out.println("等待接收消息....");


        // 推送的消息如何消费的接口回调
        DeliverCallback deliverCallback = (consumerTag,delivery) ->{
            String msg = new String(delivery.getBody());
            System.out.println(msg);
        };

        // 取消消费的一个回调接口
        CancelCallback cancelCallback = (consumerTag)->{
            System.out.println("消息消费被中断");
        };

        /**
         * 消费者消费消息
         * 第一个参数: 消费哪个队列
         * 第二个参数： 消费成功后，是否需要自动应答，true 自动应答 false 手动应答
         */
        channel.basicConsume(QUEUE_NAME,true,deliverCallback,cancelCallback);

    }
}

3.测试

运行生产者

查看 rabbitmq 控制后台，提示有一条消息

运行消费者，已打印出消息

查看 rabbitmq 控制台，消息已经被消费

二、工作队列

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

0.创建信道工具抽取

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


public class RabbitMqUtils {

    public static Channel getChannel() throws Exception {
        // 创建一个连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        // 工厂IP
        factory.setHost("192.168.168.220");
        // rabbitmq 用户名
        factory.setUsername("admin");
        // 密码
        factory.setPassword("123");

        // 创建一个连接
        Connection connection = factory.newConnection();
        // 获取信道
        Channel channel = connection.createChannel();

        return channel;
    }
}

下面的案例启动两个消费线程，一个消息生产线程，看消息是如何被消费的，答案是轮训消费

1.消费线程1 ：worker01

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

public class Worker01 {

    private final static String QUEUE_NAME = "hello";

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

        // 推送的消息如何消费的接口回调
        DeliverCallback deliverCallback = (consumerTag, delivery) ->{
            String msg = new String(delivery.getBody());
            System.out.println(msg);
        };

        // 取消消费的一个回调接口
        CancelCallback cancelCallback = (consumerTag)->{
            System.out.println("消息消费被中断");
        };

        System.out.println("C1消费者启动等待消费....");
        /**
         * 消费者消费消息
         * 第一个参数: 消费哪个队列
         * 第二个参数： 消费成功后，是否需要自动应答，true 自动应答 false 手动应答
         */
        channel.basicConsume(QUEUE_NAME,true,deliverCallback,cancelCallback);
    }
}

2.消费线程2跟线程1代码一样：Worker02

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

public class Worker02 {
    private final static String QUEUE_NAME = "hello";

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

        // 推送的消息如何消费的接口回调
        DeliverCallback deliverCallback = (consumerTag, delivery) ->{
            String msg = new String(delivery.getBody());
            System.out.println(msg);
        };

        // 取消消费的一个回调接口
        CancelCallback cancelCallback = (consumerTag)->{
            System.out.println("消息消费被中断");
        };

        System.out.println("C2消费者启动等待消费....");
        /**
         * 消费者消费消息
         * 第一个参数: 消费哪个队列
         * 第二个参数： 消费成功后，是否需要自动应答，true 自动应答 false 手动应答
         */
        channel.basicConsume(QUEUE_NAME,true,deliverCallback,cancelCallback);
    }
}

3.生产消息线程：Task01

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

import java.util.Scanner;

public class Task01 {

    private final static String QUEUE_NAME = "hello";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        /**
         * 生成一个队列
         * 第一个参数：队列名称
         * 第二个参数: 队列中的消息是否持久化，默认消息是存储在内存中
         * 第三个参数：消息消费时，可否被多个消费者消费
         * 第四个参数：是否自动删除，最后一个消费者断开连接后，该对列是否自动删除 true 自动删除
         * 第五个参数: 其它参数
         */
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        Scanner scanner = new Scanner(System.in);
        while(scanner.hasNext()){
            String message = scanner.next();
            channel.basicPublish("",QUEUE_NAME,null,message.getBytes());
            System.out.println("消息发送完成:"+message);
        }

    }
}

4.测试结果

在消息生产控制台输入四次消息

查看消费线程1

查看消费线程2

三、消息应答

1.概念

消费者完成一个任务可能需要一段时间，如果其中一个消费者处理一个长的任务并仅只完成
了部分突然它挂掉了，会发生什么情况。 RabbitMQ 一旦向消费者传递了一条消息，便立即将该消息标记为删除。在这种情况下，突然有个消费者挂掉了，我们将丢失正在处理的消息。以及后续
发送给该消费这的消息，因为它无法接收到。为了保证消息在发送过程中不丢失， rabbitmq 引入消息应答机制，消息应答就是:消费者在接收到消息并且处理该消息之后，告诉 rabbitmq 它已经处理了， rabbitmq 可以把该消息删除了。

1.1自动应答

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

1.2手动应答

默认消息采用的是自动应答，所以我们要想实现消息消费过程中不丢失，需要把自动应答改为手动应答。

1.3消息重新入队

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

2.消费者手动应答案例

这里依然创建两个消费线程一个生产线程，一个消费线程等待1秒，一个消费线程等待30秒（为了演示消费者接收消息后，未处理完，我们关闭该消费线程，看看另一个消费线程是否接收重新入队消息进行消费）；

睡眠工具类

public class SleepUtils {
    public static void sleep(int second){try {
        Thread.sleep(1000*second);
    } catch (InterruptedException _ignored) {
        Thread.currentThread().interrupt();
    }
    }
}

消费线程1：work03

import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.zym.rabbitmq.utils.RabbitMqUtils;
import com.zym.rabbitmq.utils.SleepUtils;

public class Work03 {
    private final static String ACK_QUEUE_NAME = "ack_queue";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        System.out.println("c1等待接受消息处理时间较短");
        // 推送的消息如何消费的接口回调
        DeliverCallback deliverCallback = (consumerTag, delivery) ->{
            String msg = new String(delivery.getBody());
            SleepUtils.sleep(1);
            System.out.println("接收到的消息: "+msg);
            // 第一个参数: 消息标记 tag
            // 第二个参数：是否批量应答未应答消息 false 不批量
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
        };

        // 取消消费的一个回调接口
        CancelCallback cancelCallback = (consumerTag)->{
            System.out.println("消息消费被中断");
        };

        // 采用手动应答
        boolean autoAck = false;
        /**
         * 消费者消费消息
         * 第一个参数: 消费哪个队列
         * 第二个参数： 消费成功后，是否需要自动应答，true 自动应答 false 手动应答
         */
        channel.basicConsume(ACK_QUEUE_NAME,autoAck,deliverCallback,cancelCallback);
    }
}

消费线程2：work04

import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.zym.rabbitmq.utils.RabbitMqUtils;
import com.zym.rabbitmq.utils.SleepUtils;

public class Work04 {
    private final static String ACK_QUEUE_NAME = "ack_queue";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        System.out.println("c1等待接受消息处理时间较长");
        // 推送的消息如何消费的接口回调
        DeliverCallback deliverCallback = (consumerTag, delivery) ->{
            String msg = new String(delivery.getBody());
            SleepUtils.sleep(30);
            System.out.println("接收到的消息: "+msg);
            // 第一个参数: 消息标记 tag
            // 第二个参数：是否批量应答未应答消息 false 不批量
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
        };

        // 取消消费的一个回调接口
        CancelCallback cancelCallback = (consumerTag)->{
            System.out.println("消息消费被中断");
        };

        // 采用手动应答
        boolean autoAck = false;
        /**
         * 消费者消费消息
         * 第一个参数: 消费哪个队列
         * 第二个参数： 消费成功后，是否需要自动应答，true 自动应答 false 手动应答
         */
        channel.basicConsume(ACK_QUEUE_NAME,autoAck,deliverCallback,cancelCallback);
    }
}

生产线程：Task02

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

import java.util.Scanner;

public class Task02 {

    private static final String TASK_QUEUE_NAME = "ack_queue";

    public static void main(String[] argv) throws Exception {
        try (Channel channel = RabbitMqUtils.getChannel()) {
            channel.queueDeclare(TASK_QUEUE_NAME, false, false, false, null);
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入信息");
            while (sc.hasNext()) {
                String message = sc.nextLine();channel.basicPublish("", TASK_QUEUE_NAME, null, message.getBytes("UTF-8"));
                System.out.println("生产者发出消息" + message);
            }
        }
    }
}

测试：

启动生产线程 Task02 --> 启动两个消费线程 --> 在生产线程发送四条信息 ---> 运行二三十秒后故意关闭消费线程2，查看结果

Task02

work03

work04

四、队列持久化

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

2.队列持久化

在声明队列的时候把 durable 参数设置为持久化

// 让队列持久化
boolean durable = true;
channel.queueDeclare(TASK_QUEUE_NAME, durable, false, false, null);

D 代表改队列是持久化的

3.消息持久化

要想让消息实现持久化需要在消息生产者修改代码MessageProperties.PERSISTENT_TEXT_PLAIN 添加这个属性。

channel.basicPublish("", TASK_QUEUE_NAME, MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes("UTF-8"));