rabbitMq入门一

 一、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"));

 


 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值