RabbitMQ-6种队列模式学习

最新推荐文章于 2024-08-15 18:04:28 发布
最新推荐文章于 2024-08-15 18:04:28 发布
阅读量284 收藏
点赞数
分类专栏： 学习 文章标签： rabbitmq java 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40780100/article/details/111143536
版权

RabbitMQ使用

安装

使用docker一步到位

Java客户端使用

首先导入依赖：amqp-client-5.7.1.jar
连接工具类

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

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

/*
*@Info :
*@Author：ZuoBro
*@FileName:
*@Date: 2020/12/6
*/
public class RabbitMqConnectionUtil {

    /**
     * 获取RabbitMQ连接
     * @return
     * @throws TimeoutException
     * @throws IOException
     */
    public static Connection getConnection() throws TimeoutException, IOException {
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("localhost");
        connectionFactory.setUsername("user");
        connectionFactory.setPassword("password");
        return connectionFactory.newConnection();
    }
}

  • Channels(信道)
    链接中的信道信息：Channel是在连接中存在的，一个Connection中可以有多个Channel。在Java代码中 通过连接来创建信道。

  • Exchanges（交换机）
    Exchange作为消费的生产者和消息队列的一个中介，其将Producer生产的消息进行分发给消息队列。在没有使用交换机的简单模式中，实际上则使用的是默认的交换机（AMQP-Default）

  • Queues(消息队列)
    消息队列，在控制台页面中我们在queues页签中我们可以看到服务器端当前的消息队列信息。在java代码中我们需要先对消息队列进行声明后才可以使用。点击某一队列，在队列中我们也可以查看当前队列的消息信息。

6种队列模式

  • 简单模式
  • 工作队列模式Work Queue
  • 发布/订阅模式Publish/Subscribe
  • 路由模式Routing
  • 通配符模式Topics

简单模式模式

Send.java

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import utils.RabbitMqConnectionUtil;

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

public class Send {
    private static final String QUEUE_NAME = "hello";
    public static void main(String[] args) {
        try {
            Connection connection = RabbitMqConnectionUtil.getConnection();
            Channel channel = connection.createChannel();
            channel.queueDeclare(QUEUE_NAME,false,false,false,null);
            int time = 1;
            while (true) {
                String message = String.format("Hello World%s!",time);
                channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
                System.out.println(" [x] Sent '" + message + "'");
                time ++;
                if (time > 10) {
                    break;
                }
                Thread.sleep(2000);
            }

            System.out.println("结束发送");
            channel.close();
            connection.close();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }
}

Reveiver.java


import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;
import utils.RabbitMqConnectionUtil;

/**
 * RabbitMQ简单模式  生产者-消费者
 */
public class Receiver {
    private final static String QUEUE_NAME = "hello";

    public static void main(String[] args) throws Exception {
        Connection connection = RabbitMqConnectionUtil.getConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" + message + "'");
        };
        // autoAck = true,会阻塞线程
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> {});
    }
}

在简单模式下，生产者发送消息到hello队列，消费者消费消息后从队列删除。

 [x] Sent 'Hello World1!'
 [x] Sent 'Hello World2!'
 [x] Sent 'Hello World3!'
 [x] Sent 'Hello World4!'
 [x] Sent 'Hello World5!'
 [x] Sent 'Hello World6!'
 [x] Sent 'Hello World7!'
 [x] Sent 'Hello World8!'
 [x] Sent 'Hello World9!'
 [x] Sent 'Hello World10!'
结束发送


 [*] Waiting for messages. To exit press CTRL+C
 [x] Received 'Hello World1!'
 [x] Received 'Hello World2!'
 [x] Received 'Hello World3!'
 [x] Received 'Hello World4!'
 [x] Received 'Hello World5!'
 [x] Received 'Hello World6!'
 [x] Received 'Hello World7!'
 [x] Received 'Hello World8!'
 [x] Received 'Hello World9!'
 [x] Received 'Hello World10!'

路由模式

日志信息有这样的简单分类：error,warning,info
我们可能想将error单独处理，其他统一由另一个队列处理，此时我们就可以使用路由模式。

Send.java

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import utils.RabbitMqConnectionUtil;

/*
*@Info : 路由模式-直接交换
*@Author：ZuoBro
*@FileName:
*@Date: 2020/12/5
*/
public class Send {
    private static final String EXCHANGE_NAME = "direct_logs";

    public static void main(String[] args) throws Exception {
        Connection connection = RabbitMqConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        // 声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME,"direct");
        String[] routingKeys = new String[]{
          "info",
          "warning",
          "error"
        };
        String[] messages = new String[]{
                "This is an information!",
                "This is a warning!",
                "This is an error!"
        };
        for( int i = 0; i < 3; i++) {
            channel.basicPublish(EXCHANGE_NAME,routingKeys[i],null,messages[i].getBytes());
            System.out.println(String.format("[x] Sent: {type=%s} => { %s }",routingKeys[i],messages[i]));
        }
    }
}

Receiver1.java

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.DeliverCallback;
import utils.RabbitMqConnectionUtil;

public class Receiver1 {
    /**
     * 接收error
     */
    private static final String EXCHANGE_NAME = "direct_logs";

    public static void main(String[] args) throws Exception {
        Connection connection = RabbitMqConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        // 声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME,"direct");
        // 获取随机队列，非持久，排他，自动删除
        String queueName = channel.queueDeclare().getQueue();
        // 绑定交换机
        channel.queueBind(queueName,EXCHANGE_NAME,"error");

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody());
            System.out.println(String.format("[x-receiver-1] Received: {RoutingKey=%s} => { %s }",delivery.getEnvelope().getRoutingKey(),message));
        };
        channel.basicConsume(queueName,true,deliverCallback,consumerTag -> {});
    }
}

Receiver2.java

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.DeliverCallback;
import utils.RabbitMqConnectionUtil;

public class Receiver2 {
    /**
     * 接收info/warning/error
     */
    private static final String EXCHANGE_NAME = "direct_logs";

    public static void main(String[] args) throws Exception {
        Connection connection = RabbitMqConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        // 声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME,"direct");
        // 获取随机队列，非持久，排他，自动删除
        String queueName = channel.queueDeclare().getQueue();
        // 绑定交换机
        channel.queueBind(queueName,EXCHANGE_NAME,"info");
        channel.queueBind(queueName,EXCHANGE_NAME,"warning");
        channel.queueBind(queueName,EXCHANGE_NAME,"error");

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody());
            System.out.println(String.format("[x-receiver-2] Received: {RoutingKey=%s} => { %s }",delivery.getEnvelope().getRoutingKey(),message));
        };
        channel.basicConsume(queueName,true,deliverCallback,consumerTag -> {});
    }
}

结果：

********* Send **************
[x] Sent: {type=info} => { This is an information! }
[x] Sent: {type=warning} => { This is a warning! }
[x] Sent: {type=error} => { This is an error! }

********Receiver1*************
[x-receiver-1] Received: {RoutingKey=error} => { This is an error! }

********Receiver2*************
[x-receiver-2] Received: {RoutingKey=info} => { This is an information! }
[x-receiver-2] Received: {RoutingKey=warning} => { This is a warning! }
[x-receiver-2] Received: {RoutingKey=error} => { This is an error! }

其他模式

参考官网教程：https://www.rabbitmq.com/getstarted.html

ZuoBro
关注
专栏目录
rabbitmq队列模式
growing_duck的博客
09-06 436
1、简单队列： 生产者将消息发送到队列，消费者从队列中获取消息。 2、work模式： 队列的消息会平均分发给C1和C2 3、work模式的能者多劳： 在每个消费者的代码中加上红圈的内容，服务器同一时刻只发一条消息给消费者，待消费完成后再发下一条，  这样消费快的得到的消息就多。 4、消息的确认模式： 如果为true，则不需要最后一句代码
RabbitMQ 中的 7 种队列模式
qq3164069700的博客
12-10 1618
七种模式介绍与应用场景 简单模式（Hello World） 做最简单的事情，一个生产者对应一个消费者，RabbitMQ相当于一个消息代理，负责将A的消息转发给B 应用场景：将发送的电子邮件放到消息队列，然后邮件服务在队列中获取邮件并发送给收件人 工作队列模式（Work queues） 在多个消费者之间分配任务（竞争的消费者模式），一个生产者对应多个消费者，一般适用于执行资源密集型任务，单个消费者处理不过来，需要多个消费者进行处理 应用场景：一个订单的处理需要10s，有多个订单..
RabbitMQ的六种工作模式
小猪快跑
12-21 1537
一.基于erlang语言： 是一种支持高并发的语言 RabbitMQ的六种工作模式： 1.1 simple简单模式 消息产生着§将消息放入队列 消息的消费者(consumer) 监听(while) 消息队列,如果队列中有消息,就消费掉,消息被拿走后,自动从队列中删除(隐患 消息可能没有被消费者正确处理,已经从队列中消失了,造成消息的丢失)应用场景:聊天(中间有一个过度的服务器;p端,c端) ...
【RabbitMQ】 相关概念 + 工作模式
最新发布
p_fly的博客
08-15 803
本文将介绍一些MQ中常见的概念，同时也会简单实现一下RabbitMQ的工作流程。
RabbitMQ六种队列模式-简单队列模式
weixin_30673715的博客
09-02 212
前言 RabbitMQ六种队列模式-简单队列 [本文]RabbitMQ六种队列模式-工作队列RabbitMQ六种队列模式-发布订阅RabbitMQ六种队列模式-路由模式RabbitMQ六种队列模式-主题模式 在官网的教程中，描述了如上六类工作队列模式： 简单队列模式：最简单的工作队列，其中一个消息生产者，一个消息消费者，一个队列。也称为点对点模式 工作模式：...
RabbitMQ六种队列模式
m0_50732163的博客
01-16 340
RabbitMQ六种队列模式 详解
rabbitmq-server3.10.5
01-10
RabbitMQ服务器3.10.5是一款广泛使用的开源消息代理和队列服务器，它基于高级消息队列协议（AMQP）实现。这个版本的RabbitMQ提供了稳定且高效的中间件服务，允许分布式系统中的应用程序进行异步通信，确保数据可靠...
rabbitmq-java (2).zip
01-11
RabbitMQ是一个开源的消息代理和队列服务器，它基于AMQP（Advanced Message Queuing Protocol）协议，被广泛用于处理分布式系统中的异步任务和消息传递。在这个名为"rabbitmq-java (2).zip"的压缩包中，我们可以看到...
rabbitmq-server-3.9.14
05-04
3. **高可用性**：RabbitMQ支持多种模式以实现高可用性，例如镜像队列、 Federation和Shovel插件。3.9.14版本可能对这些特性进行了改进，提升了集群的稳定性和数据一致性。 4. **安全性**：RabbitMQ支持用户身份...
20210616最新版rabbitmq-server-3.8.17.exe
06-16
RabbitMQ是一个开源的消息代理和队列服务器，它基于AMQP（Advanced Message Queuing Protocol）协议，被广泛用于处理分布式系统中的异步任务和消息传递。20210616发布的“rabbitmq-server-3.8.17.exe”是RabbitMQ...
rabbitmq-server-3.8.9.exe
01-18
6. **集群**：RabbitMQ可以设置成集群模式，以提高可用性和可扩展性，当一个节点故障时，其他节点可以接管其任务。 7. **工作队列**：通过将大任务分解为小任务并分发给多个消费者处理，可以有效提升系统的并发处理...
RabbitMQ之六种队列模式
weixin_30399055的博客
03-16 94
　　先学习一下RabbitMQ中的六种队列，只学习前五种，具体的官方文档地址是：http://next.rabbitmq.com/getstarted.html 导入maven依赖： 1 <dependency> 2 <groupId>com.rabbitmq</groupId> 3 <artifactId&g...
rabbitmq入门（一）简单队列（Hello World!、Work queues）
念念不忘，必有回响
10-28 714
什么是直接模式： 我们需要将消息发给唯一一个节点时使用这种模式，这是最简单的一种形式。 特点： 这种模式下不需要将Exchange进行任何绑定(binding)操作 消息传递时需要一个“RouteKey”，可以简单的理解为要发送到的队列名字 如果vhost中不存在RouteKey中指定的队列名，则该消息会被抛弃 一般情况可以使用rabbitMQ自带的Exchange：”"(该Exchange的名...
RabbitMQ的6种工作模式---简单模式
qq_32923295的博客
04-06 708
上次说了交换机的四种绑定模式，这篇说一下RabbitMQ的6种工作模式，代码基于spring boot + JDK1.8 1.简单模式 望文生义，也就是RabbitMQ中最简单的一种，只适合demo级别的。 生产者把消息放入队列，消费者获取消息。这个模式只有一个消费者，一个生产者，一个队列，只需要配置主机参数，其他参数使用默认即可通信 代码： pom文件：（注意：如果引入jar包，但是在代码里面不能引入的，1重启IDEA，2更换springboot版本，我用的是2.1.4.RELEASE）
RabbitMQ6种模式
weixin_44399790的博客
02-21 2828
1.1 simple简单模式 一对一的消息模式，生产者往同一个队列里生产，只供一个消费者。 消息的消费者(consumer) 监听(while) 消息队列,如果队列中有消息,就消费掉,消息被拿走后,自动从队列中删除(隐患 消息可能没有被消费者正确处理,已经从队列中消失了,造成消息的丢失)应用场景:聊天(中间有一个过度的服务器;p端,c端) 1.2 work工作模式(资源的竞争) 一对多的消息模式，生产者往同一个消息队列里生产，供多个消费者消费（不会重复）。 应用场景:红包;大项目中的资源调度
rabbitmq六种模式
qq_38639813的博客
07-07 1678
二、工作队列模式：一个生产者，多个消费者，消费者之间负载均衡 三、发布订阅模式：生产者把消息给交换机，交换机把消息推送给与它绑定的所有队列，消费者监听自己的队列 该模式下，队列和交换机之间的绑定无需routingKey。因为无需routingKey，所以不需要进行字符串匹配，效率最高 四、路由模式：交换机与队列由routing key绑定，生产者发送消息时指定交换机和routing key，则对应的队列便会收到消息 因为需要进行字符串匹配，所以效率其次 五、主题模式（通配符模式）：交换机与队列由routi
RabbitMQ六种模式
smy166153的博客
06-08 3794
文章目录前言一、配置一、Hello World1.生产者2.消费者二、Work Queues1.生产者2.消费者三、Publish/Subscribe 前言 一、配置 xml配置文件 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值