RabbitMQ-Java-02-工作队列

最新推荐文章于 2024-06-09 23:24:29 发布
最新推荐文章于 2024-06-09 23:24:29 发布
阅读量1.6k 收藏
点赞数
分类专栏： Java RabbitMq 文章标签： rabbitmq java intellij-idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csdn_yasin/article/details/122289689
版权

说明

  • RabbitMQ-Java-02-工作队列
  • 本案例是一个Maven项目
  • 假设你已经实现了上一节简单队列
  • 官方文档已包含绝大多数本案例内容。请移步：https://docs.spring.io/spring-amqp/docs/current/reference/html/

核心概念

》原理

  • 执行资源密集型任务时往往有多个队列，每个队列有多个工作线程去处理
  • 注意：一个消息必须保证只能被处理一次

操作步骤

》搭建环境

  • idea创建一个空项目
  • 创建一个Maven管理的module
  • pom.xml添加插件：指定JDK编译版本（为了支持lambda表达式，如果不手动添加后期idea报错根据提示会自动添加好）
    <!-- 指定JDK编译版本 -->
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <configuration>
        <source>8</source>
        <target>8</target>
    </configuration>
</plugin>
  • pom.xml添加依赖：RabbitMQ相关
    <!-- https://mvnrepository.com/artifact/com.rabbitmq/amqp-client -->
<dependency>
    <groupId>com.rabbitmq</groupId>
    <artifactId>amqp-client</artifactId>
    <version>5.13.1</version>
</dependency>

<!-- https://mvnrepository.com/artifact/commons-io/commons-io -->
<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.11.0</version>
</dependency>

》工作队列案例（自动应答）

  • 说明
    • 主要是两步：提取工具类、分多线程同时处理一个队列
  • 代码组成
    • RabbitMQ工具类：RabbitMqUtils
      package cn.cnyasin.rabbit.utils;

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();

        // 配置
        factory.setHost("192.168.3.202");
        factory.setPort(5672);
        factory.setUsername("admin");
        factory.setPassword("123456");
        factory.setVirtualHost("/");

        // 获取连接
        Connection connection = factory.newConnection();

        // 获取信道
        Channel channel = connection.createChannel();

        return channel;
    }
}
    • 初始化：Init
      package cn.cnyasin.rabbit.worker;

import cn.cnyasin.rabbit.utils.RabbitMqUtils;
import com.rabbitmq.client.Channel;

public class Init {
    // 交换机名
    public static final String EXCHANGE_NAME = "exchange01";

    // 队列名
    public static final String QUEUE_NAME = "queue01";

    // 路由key
    public static final String ROUTING_KEY = "routing01";

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

        // 声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME, "direct", true);

        // 声明队列
        channel.queueDeclare(QUEUE_NAME, true, false, false, null);

        // 绑定队列、交换机、路由key
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, ROUTING_KEY);

        System.out.println("初始化成功。。。");

        System.exit(0);
    }
}
    • 工作队列01（线程一）：Worker01
      package cn.cnyasin.rabbit.worker;

import cn.cnyasin.rabbit.utils.RabbitMqUtils;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Delivery;

/**
 * 工作队列01（消费者）
 */
public class Worker01 {

    // 定义本工作队列要处理的队列名字
    public static final String QUEUE_NAME = "queue01";

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

        System.out.println("[*] 工作队列01正在等待接收消息。。。");

        // 处理消息
        channel.basicConsume(
                // 队列名
                QUEUE_NAME,
                // 自动应答
                true,
                // 成功处理消息回调
                (String consumerTag, Delivery message) -> {
                    // TODO 业务逻辑代码在这里
                    System.out.println(" [*] 成功处理消息：" + new String(message.getBody()));
                },
                // 处理消息失败回调
                (String consumerTag) -> {
                    System.out.println("处理消息失败");
                }
        );
    }
}
    • 工作队列02（线程二）：Worker02
      • 方式一：将上面Worker01代码复制一份，名字改为Worker02，然后运行
      • 方式二：idea支持同一个run方法并行运行：
        • idea | Run | Edit Configurations | Allow parallel run
    • 生产者：Task
      package cn.cnyasin.rabbit.worker;

import cn.cnyasin.rabbit.utils.RabbitMqUtils;
import com.rabbitmq.client.Channel;

import java.util.Scanner;

public class Task {
    // 交换机名
    public static final String EXCHANGE_NAME = "exchange01";

    // 路由key
    public static final String ROUTING_KEY = "routing01";

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

        // 接收控制台输入
        Scanner scanner = new Scanner(System.in);

        System.out.println("[*] 等待控制台输入消息内容。。。");

        while (scanner.hasNext()) {
            String input = scanner.next();

            if (input.equals("exit")) {
                break;
            }

            // 发送消息
            channel.basicPublish(EXCHANGE_NAME, ROUTING_KEY, null, input.getBytes());

            System.out.println("[*] 消息发送成功。。。");
        }

        channel.close();

        System.out.println("[*] 用户退出。。。");

        System.exit(0);
    }
}
  • 运行初始化：
    • Init -> main -> run
  • 开启两个工作队列：
    • Worker01 -> main -> run
    • Worker02 -> main -> run
  • 运行生产者：
    • Task -> main -> run

》工作队列案例（手动应答与自动重新入队）

  • 说明
    • 为了防止消息丢失，往往都使用手动应答机制
    • 如果消息处理失败，自动重新入队
    • 代码还是基于上一节：工作队列案例（自动应答）
  • 代码组成
    • RabbitMQ工具类：RabbitMqUtils
      • 代码同：工作队列案例（自动应答）
    • 初始化：Init
      • 代码同：工作队列案例（自动应答）
    • 工作队列01（线程一）：Worker01
      package cn.cnyasin.rabbit.ack;

import cn.cnyasin.rabbit.utils.RabbitMqUtils;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Delivery;

/**
 * 工作队列01（消费者）
 */
public class Worker01 {

    // 定义本工作队列要处理的队列名字
    public static final String QUEUE_NAME = "queue_ack";

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

        System.out.println("[*] 工作队列01正在等待接收消息。。。");

        // 处理消息
        channel.basicConsume(
                // 队列名
                QUEUE_NAME,
                // 自动应答
                false,
                // 成功处理消息回调
                (String consumerTag, Delivery message) -> {
                    try {
                    	// 沉睡1秒
                        Thread.sleep(1000 * 1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    // TODO 业务逻辑代码在这里
                    System.out.println(" [*] 工作队列01成功处理消息：" + new String(message.getBody()));

                    // TODO 手动应答
                    channel.basicAck(message.getEnvelope().getDeliveryTag(), false);
                },
                // 处理消息失败回调
                (String consumerTag) -> {
                    System.out.println("处理消息失败");
                }
        );
    }
}
    • 工作队列02（线程二）：Worker02
      package cn.cnyasin.rabbit.ack;

import cn.cnyasin.rabbit.utils.RabbitMqUtils;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Delivery;

/**
 * 工作队列02（消费者）
 */
public class Worker02 {

    // 定义本工作队列要处理的队列名字
    public static final String QUEUE_NAME = "queue_ack";

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

        System.out.println("[*] 工作队列02正在等待接收消息。。。");

        // 处理消息
        channel.basicConsume(
                // 队列名
                QUEUE_NAME,
                // 自动应答
                true,
                // 成功处理消息回调
                (String consumerTag, Delivery message) -> {
                    try {
                    	// 沉睡10秒
                        Thread.sleep(1000 * 10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    // TODO 业务逻辑代码在这里
                    System.out.println(" [*] 工作队列02成功处理消息：" + new String(message.getBody()));

                    // TODO 手动应答
                    channel.basicAck(message.getEnvelope().getDeliveryTag(), false);
                },
                // 处理消息失败回调
                (String consumerTag) -> {
                    System.out.println("处理消息失败");
                }
        );
    }
}
    • 生产者：Task
      • 代码同：工作队列案例（自动应答）
  • 运行初始化：
    • Init -> main -> run
  • 开启两个工作队列：
    • Worker01 -> main -> run
    • Worker02 -> main -> run
  • 运行生产者：
    • Task -> main -> run

》消息持久化

  • 说明
    • 代码借用上一节代码，在此基础上只需要在生产者（Task）代码中进行以下改动
      • 发送消息的时候，第三个参数改为：MessageProperties.PERSISTENT_TEXT_PLAIN，即可使消息持久化存储，即使RabbitMQ宕机消息也不会丢失。
  • 核心代码
    // 消息持久化
AMQP.BasicProperties properties = MessageProperties.PERSISTENT_TEXT_PLAIN;

// 发送消息
channel.basicPublish(EXCHANGE_NAME, ROUTING_KEY, properties, input.getBytes());

》不公平分发

  • 说明

    • 代码借用上一节代码，在此基础上只需要在消费者（Worker01、Worker02）代码中进行以下改动
      • 处理消息之前，信道设置一下：channel.basicQos()
      • 该函数接收一个int类型值（0=公平分发，大于0=不公平分发，默认0），该值的意思是预取值，代表该工作线程一次取的消息数量

  • 核心代码

    // 设置不公平分发
int prefetchCount = 1; // 预取值
channel.basicQos(prefetchCount);

备注

  • 该教程部分内容收集自网络，感谢原作者。

附录

  • 无
csdn_yasin
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java工作队列_RabbitMQ入门：工作队列(Work Queue)
weixin_33328904的博客
02-16 165
在上一篇博客《RabbitMQ入门：Hello RabbitMQ 代码实例》中，我们通过指定的队列发送和接收消息，代码还算是比较简单的。假设有这一些比较耗时的任务，按照上一次的那种方式，我们要一直等前面的耗时任务完成了之后才能接着处理后面耗时的任务，那要等多久才能处理完？别担心，我们今天的主角--工作队列就可以解决该问题。我们将围绕下面这个索引展开：什么是工作队列代码准备循环分发消息确认公平分发消...
RabbitMQ(Java操作直连式)
led1114的博客
02-03 1491
1 - maven依赖 <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</artifactId> <version>5.7.2</version> </dependency> 2 - 生产者 public class Provider { public static void main(St
RabbitMQ（一）：Java简单操作RabbitMQ
每个人为不同的理由带着面具说谎，动机也只有一种名字那 叫做欲望
09-02 235
使用java rabbitmq clent 实现一个简单的rabbitmq 程序 新手入门必尝试 方法参数有详细解释
JAVA操作RabbitMQ-work工作队列模式
程序猿的博客
10-03 244
工作队列模式：一个生产者，多个消费者，多个消费者共同监听一个队列，一个消息只能被一个消费者获取。工作队列模式又分为两种，轮询模式分发和公平分发。 轮询模式分发：一条消息一个消费者，按均分配。 公平分发：根据消费者的消费能力进行公平分发，处理快的处理的多，处理慢的处理的少；按劳分配。 P：消息的生产者 C1，C2：消息的消费者 红色：队列 生产者将消息发送到队列（通过默认交换机），消费者从队列中获取消息。 1. pom.xml引入rabbitmq依赖 <...
RabbitMQ——Hello World
前尘忆梦的博客
04-25 369
文章目录1、RabbitMQ四个核心概念1.1、四大核心概念1.2、各个名词介绍1.3、安装2、Hello World2.1、依赖2.2、消息生产者 1、RabbitMQ四个核心概念 RabbitMQ 是一个消息中间件：它接受并转发消息。你可以把它当做一个快递站点，当你要发送一个包裹时，你把你的包裹放到快递站，快递员最终会把你的快递送到收件人那里，按照这种逻辑 RabbitMQ 是一个快递站，一个快递员帮你传递快件。 RabbitMQ 与快递站的主要区别在于，它不处理快件而是接收，存储和转发消息数据。 1.
RabbitMQ-Java-死信队列
Cancer_pmx的博客
05-12 1732
这里的描述来自官方： 死信交换 来自队列的消息可以是“死信”；也就是说，当发生以下任何事件时，重新发布到交易所： 消费者使用basic.reject或 basic.nack否定确认消息，并将requeue参数设置为false。 消息由于每条消息的 TTL而过期 消息被丢弃，因为它的队列超过了长度限制 请注意，队列到期不会死信其中的消息。 死信交换 (DLX) 是正常的交换。它们可以是任何常用类型，并像往常一样声明。 对于任何给定的队列，DLX 可以由客户端使用 队列的参数定义，或者在服务器中使用策略定义
RabbitMQ-Java-01-简单队列
csdn_yasin的博客
01-03 3137
说明 RabbitMQ-Java-01-简单队列 本案例是一个Maven项目 官方文档已包含绝大多数本案例内容。请移步：https://docs.spring.io/spring-amqp/docs/current/reference/html/ 操作步骤 》安装RabbitMQ 可自行安装，也可参考我的相关教程（CentOS7离线安装RabbitMq），本章假设你已经安装好了RabbitMQ。 》搭建环境 idea创建一个空项目 创建一个Maven管理的module pom.xml添加
RabbitMQ-Java-05-死信队列
csdn_yasin的博客
01-03 3361
说明 RabbitMQ-Java-05-死信队列 本案例是一个Maven项目 假设你已经实现了上一节发布订阅模式 官方文档已包含绝大多数本案例内容。请移步：https://docs.spring.io/spring-amqp/docs/current/reference/html/ 核心概念 》死信来源 消息TTL过期 队列满了 消息被拒绝 》死信实现过程概览 定义消费者01 声明两个交换机：正常交换机、死信交换机 声明两个队列：正常队列、死信队列 正常队列声明的时候传入第五个参数argume
RabbitMQ--基础--5.1--部署--命令
zhou920786312的博客
10-20 1393
ha-mode:指明镜像队列的模式ha-params: ha-mode模式需要用到的参数ha-svnc-mode:进行队列中消息的同步方式，有效值为automatic和manual。
java队列源码-rabbitmq-repository:RabbitMQ消息队列学习的源码记录
05-24
rabbitmq-java-helloworld 只是第一个rabbitmq的例子 => hello world 消费者不能关闭连接，需要一直轮询查看是否存在消息 rabbitmq-java-queque rabbitmq任务队列示例 rabbitmq-java-publish-receive rabbitmq发布...
rabbitmq-server-3.8.4.exe
06-11
官网下载太慢，这里给一个现成的，消息队列交换机，RabbitMQ是实现了高级消息队列协议（AMQP）的开源消息代理软件（亦称面向消息的中间件）。RabbitMQ服务器是用Erlang语言编写的，而集群和故障转移是构建在开放电信...
rabbitmq-server-3.8.5.exe
11-18
rabbitmq-server-3.8.5.exe 消息队列下载，自己再用，非常好用
rabbitmq-java-client-3.4.1.zip
03-03
消息队列的开源jar包，将该jar放入lib文件夹下就可以使用消息队列了
RabbitMQ-performance-test
05-16
＃POC3中的RabbitMQ性能测试 ###代码： : ### POC3 CPU信息： model name : Intel(R) Xeon(R) CPU E5-2650 v2 @ 2.60GHz cat /proc/cpuinfo | grep "processor" | wc -l 8 cat /proc/cpuinfo | grep "physical ...
RabbitMQ（五）集群配置、Management UI
爱喝星冰乐的博客
06-06 826
RabbitMQ（五）集群配置、Management UI
RabbitMQ 2万字面试题及参考答案
linweidong的专栏
06-07 388
RabbitMQ是一个开源的消息代理软件，也是一种面向消息的中间件（MOM），主要用于系统之间的异步消息通信。它基于高级消息队列协议（AMQP）和其他消息协议，提供了一个可靠的消息队列功能，支持多种编程语言。RabbitMQ服务器使用Erlang语言编写，具有高并发处理能力，并且具有集群和故障转移的特性。它广泛应用于分布式系统的解耦、异步处理、消息传递和数据持久化等场景。
rabbitmq单机安装及性能测试
最新发布
codelearning的专栏
06-09 482
本文使用CentOS7.9安装RabbitMQ单机环境，并进行测试测试。
RabbitMQ系列-rabbitmq无法重新加入集群，启动失败的问题
CodeV的博客
06-06 308
当前存在3个节点：rabbitmq5672、rabbitmq5673、rabbitmq5674当rabbitmq5673节点掉线之后，重启失败。
springboot-rabbitMQ-websocket java 实现
05-13
在 RabbitMQ 中创建一个交换机和一个队列，然后将队列绑定到交换机上。这里我们使用 RabbitMQ 的默认交换机和队列。 ```java @Configuration public class RabbitMQConfig { @Bean public Queue queue() { ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值