消息队列的基本使用

最新推荐文章于 2024-06-01 15:43:23 发布
最新推荐文章于 2024-06-01 15:43:23 发布
阅读量1.4k 收藏 5
点赞数
文章标签： 分布式 rabbitmq java-rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_69776547/article/details/126529199
版权

基本概念：

  • 生产者

    向队列中发送消息的程序

  • 消费者

    从队列中消费消息的程序

  • 队列 queue

    消息的容器，FIFO数据结构

  • 交换机 exchange

    将消息复制分发到不同的队列中

  • 虚拟主机 host

    包含交换机和队列的空间

  • 连接 connection

    客户端和MQ服务的连接

  • 通道  channel

    通信的通道    

基本使用 

用户

虚拟主机

队列

交换机

五种消息模型 

RabbitMQ提供了多种消息模型，官网上第6种是RPC不属于常规的消息队列。 属于消息模型的是前5种：

  1. 简单的一对一模型

  2. 工作队列模型 ，一个生产者将消息分发给多个消费者

  3. 发布/订阅模型 ，生产者发布消息，多个消费者同时收取

  4. 路由模型 ，生产者通过关键字发送消息给特定消费者

  5. 主题模型 ，路由模式基础上，在关键字里加入了通配符

一对一模型

导入依赖

<dependency>
  <groupId>com.rabbitmq</groupId>
  <artifactId>amqp-client</artifactId>
  <version>3.4.1</version>
</dependency>

MQ工具类

package com.blb.rabbitmq_demo.until;

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

import java.io.IOException;

public class MQUntil {

    /**
     * 获得MQ连接
     * @return
     */
    public static Connection getMQConnection() throws IOException {
        ConnectionFactory connectionFactory = new ConnectionFactory();
//        配置服务名、端口、虚拟主机名、登录账号和密码
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("MyGuest");
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        return connectionFactory.newConnection();
    }
}

生产者

package com.blb.rabbitmq_demo.helloword;

import com.blb.rabbitmq_demo.until.MQUntil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

import java.io.IOException;

/**
 * 生产者发送简单的消息队列
 */
public class SimpleProduct{

    public static void main(String[] args) throws IOException {
//        获得连接
        Connection connection = MQUntil.getMQConnection();
//        创建通道
        Channel channel = connection.createChannel();
//        声明队列
        channel.queueDeclare("MyQueues",false,false,false,null);
//        发送消息 交换机名，队列名，手动确认false，配置属性，数据
        channel.basicPublish("","MyQueues",false,null,"hello world".getBytes());
        channel.close();
        connection.close();
    }
}

消费者

package com.blb.rabbitmq_demo.helloword;

import com.blb.rabbitmq_demo.until.MQUntil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;

import java.io.IOException;

public class SimpleConsumer {

    public static void main(String[] args) throws IOException, InterruptedException {
//        获得连接
        Connection connection = MQUntil.getMQConnection();
//       获得通道
        Channel channel = connection.createChannel();
//        在队列服务器上声明队列
        channel.queueDeclare("MyQueues",false,false,false,null);
//        创建消费者
        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
//        消费者消息通道中的消息
        channel.basicConsume("MyQueues",true,queueingConsumer);
//        读取消息
        while (true){
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            System.out.println(new String(delivery.getBody()));
        }

    }
}

运行结果

工作队列

生产者

package com.blb.rabbitmq_demo.work;

import com.blb.rabbitmq_demo.until.MQUntil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

import java.io.IOException;

/**
 * 工作队列生产者
 * 多对多模式
 */
public class WorkProduct {

    public static void main(String[] args) throws IOException {
//        获得连接
        Connection connection = MQUntil.getMQConnection();
//        创建通道
        Channel channel = connection.createChannel();
//        声明队列
        channel.queueDeclare("MyQueues",false,false,false,null);

        for (int i = 0; i < 10; i++) {
            String msg = "打印了-->" + i;
//          发送消息 交换机名，队列名，手动确认false，配置属性，数据
            channel.basicPublish("","MyQueues",false,null,msg.getBytes());
        }
        channel.close();
        connection.close();
    }
}

 消费者1

package com.blb.rabbitmq_demo.work;

import com.blb.rabbitmq_demo.until.MQUntil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;

import java.io.IOException;

public class WorkConsumer01 {

    public static void main(String[] args) throws IOException, InterruptedException {
//        获得连接
        Connection connection = MQUntil.getMQConnection();
//       获得通道
        Channel channel = connection.createChannel();
//        在队列服务器上声明队列
        channel.queueDeclare("MyQueues",false,false,false,null);
//        限制队列一次发一个消息给消费者，等消费者有了反馈，再发下一条
        channel.basicQos(1);
//        创建消费者
        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
//        消费者消息通道中的消息  true是自动返回完成状态，false表示手动
        channel.basicConsume("MyQueues",false,queueingConsumer);
//        读取消息
        while (true){
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            System.out.println(new String(delivery.getBody()));
            Thread.sleep(100);
//            消费完消息后手动反馈，处理快的消费者就能处理更多消息
//            手动确定返回状态，不写就是自动确认
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
        }

    }
}

消费者2

package com.blb.rabbitmq_demo.work;

import com.blb.rabbitmq_demo.until.MQUntil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;

import java.io.IOException;

public class WorkConsumer02 {

    public static void main(String[] args) throws IOException, InterruptedException {
//        获得连接
        Connection connection = MQUntil.getMQConnection();
//       获得通道
        Channel channel = connection.createChannel();
//        在队列服务器上声明队列
        channel.queueDeclare("MyQueues",false,false,false,null);
        //        限制队列一次发一个消息给消费者，等消费者有了反馈，再发下一条
        channel.basicQos(1);
//        创建消费者
        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
//        消费者消息通道中的消息
        channel.basicConsume("MyQueues",false,queueingConsumer);
//        读取消息
        while (true){
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            System.out.println(new String(delivery.getBody()));
            Thread.sleep(300);
//            消费完消息后手动反馈，处理快的消费者就能处理更多消息
//            手动确定返回状态，不写就是自动确认
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
        }

    }
}

上边代码已经实现能者多劳：

  1. channel.basicQos(1);限制队列一次发一个消息给消费者，等消费者有了反馈，再发下一条

  2. channel.basicAck 消费完消息后手动反馈，处理快的消费者就能处理更多消息

  3. basicConsume 中的参数改为false

发布订阅模式

 生产者

package com.blb.rabbitmq_demo.publish;

import com.blb.rabbitmq_demo.until.MQUntil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

import java.io.IOException;

/**
 * 发布和订阅模式生产者
 * 消息会通过交换机发送到队列
 */
public class PublishProduct {

    public static void main(String[] args) throws IOException {
//        获得连接
        Connection connection = MQUntil.getMQConnection();
//        创建通道
        Channel channel = connection.createChannel();
//      声明交换机 fanout扇出
        channel.exchangeDeclare("MyExchange","fanout");
        String msg = "hello fanout";
//        发布到交换机
        channel.basicPublish("MyExchange","",null,msg.getBytes());
        channel.close();
        connection.close();
    }
}

消费者1

package com.blb.rabbitmq_demo.publish;

import com.blb.rabbitmq_demo.until.MQUntil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;

import java.io.IOException;

/**
 *   发布订阅模式的消费者1
 *   两个消费者绑定的消息队列不同
 *   通过交换机一个消息能被不同队列的两个消费者同时获取
 *   一个队列可以有多个消费者，队列中的消息只能被一个消费者获取
 */
public class PublishConsumer01 {

    public static void main(String[] args) throws IOException, InterruptedException {
//        获得连接
        Connection connection = MQUntil.getMQConnection();
//       获得通道
        Channel channel = connection.createChannel();
//        在队列服务器上声明队列
        channel.queueDeclare("MyQueues",false,false,false,null);
//      绑定队列1到交换机上
        channel.queueBind("MyQueues","MyExchange","");
        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
        channel.basicConsume("MyQueues",true,queueingConsumer);
//        读取消息
        while (true){
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            System.out.println("消费者1-->"+new String(delivery.getBody()));
        }

    }
}

消费者2

package com.blb.rabbitmq_demo.publish;

import com.blb.rabbitmq_demo.until.MQUntil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;

import java.io.IOException;

public class PublishConsumer02 {

    public static void main(String[] args) throws IOException, InterruptedException {
//        获得连接
        Connection connection = MQUntil.getMQConnection();
//       获得通道
        Channel channel = connection.createChannel();
//        在队列服务器上声明队列
        channel.queueDeclare("MyQueues1",false,false,false,null);
//      绑定队列1到交换机上
        channel.queueBind("MyQueues1","MyExchange","");
        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
        channel.basicConsume("MyQueues1",true,queueingConsumer);
//        读取消息
        while (true){
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            System.out.println("消费者2-->"+new String(delivery.getBody()));
        }

    }
}

路由模式

生产者

package com.blb.rabbitmq_demo.direct;

import com.blb.rabbitmq_demo.until.MQUntil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

import java.io.IOException;

/**
 * 路由模式的生产者，发布消息会有特定的Key，消息会被绑定特定Key的消费者获取
 */
public class DirectProduct {

    public static void main(String[] args) throws IOException {
//        获得连接
        Connection connection = MQUntil.getMQConnection();
//        创建通道
        Channel channel = connection.createChannel();
//      声明交换机 direct
        channel.exchangeDeclare("MyExchange2","direct");
        String msg = "hello direct";
//        绑定队列1到交换机，指定key为error
        channel.queueBind("MyQueues1","MyExchange2","error");
//        绑定队列2到交换机，指定key为error
        channel.queueBind("MyQueues2","MyExchange2","debug");
//        发布到交换机
        channel.basicPublish("MyExchange2","error",null,msg.getBytes());
        channel.basicPublish("MyExchange2","debug",null,msg.getBytes());
        channel.close();
        connection.close();
    }
}

消费者1

package com.blb.rabbitmq_demo.direct;

import com.blb.rabbitmq_demo.until.MQUntil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;

import java.io.IOException;

/**
 * 路由模式的消费者1
 * 可以指定Key，消费特定的消息
 */
public class DirectConsumer01 {

    public static void main(String[] args) throws IOException, InterruptedException {
//        获得连接
        Connection connection = MQUntil.getMQConnection();
//       获得通道
        Channel channel = connection.createChannel();
//        在队列服务器上声明队列
        channel.queueDeclare("MyQueues1",false,false,false,null);
        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
        channel.basicConsume("MyQueues1",true,queueingConsumer);
//        读取消息
        while (true){
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            System.out.println("消费者1-->"+new String(delivery.getBody()));
        }

    }
}

消费者2

package com.blb.rabbitmq_demo.direct;

import com.blb.rabbitmq_demo.until.MQUntil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;

import java.io.IOException;

/**
 * 路由模式的消费者1
 * 可以指定Key，消费特定的消息
 */
public class DirectConsumer02 {

    public static void main(String[] args) throws IOException, InterruptedException {
//        获得连接
        Connection connection = MQUntil.getMQConnection();
//       获得通道
        Channel channel = connection.createChannel();
//        在队列服务器上声明队列
        channel.queueDeclare("MyQueues2",false,false,false,null);
        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
        channel.basicConsume("MyQueues2",true,queueingConsumer);
//        读取消息
        while (true){
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            System.out.println("消费者2-->"+new String(delivery.getBody()));
        }

    }
}

主题模式

生产者

package com.blb.rabbitmq_demo.topic;

import com.blb.rabbitmq_demo.until.MQUntil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

import java.io.IOException;

/**
 * 主题模式的生产者
 *   *		  匹配任意一个单词    com.*
 *   #        匹配.号隔开的多个单词 com.#
 */
public class TopicProduct {

    public static void main(String[] args) throws IOException {
//        获得连接
        Connection connection = MQUntil.getMQConnection();
//        创建通道
        Channel channel = connection.createChannel();
//      声明交换机 direct
        channel.exchangeDeclare("MyExchange3","topic");
//        绑定队列1到交换机，指定key
        channel.queueBind("MyQueues1","MyExchange3","*.cn");
//        绑定队列2到交换机，指定key
        channel.queueBind("MyQueues2","MyExchange3","#.com");
//        发布到交换机
        channel.basicPublish("MyExchange3","blb.lg.com",null,"blb.lg.cn".getBytes());
        channel.basicPublish("MyExchange3","blb.cn",null,"blb.cn".getBytes());
        channel.basicPublish("MyExchange3","blb.com",null,"blb.com".getBytes());
        channel.close();
        connection.close();
    }
}

消费者1

package com.blb.rabbitmq_demo.topic;

import com.blb.rabbitmq_demo.until.MQUntil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;

import java.io.IOException;

/**
 * 主题模式的消费者1 ，类似路由模式，可以使用通配符对Key进行筛选
 *   #匹配1个或多个单词，*匹配一个单词
 */
public class TopicConsumer01 {

    public static void main(String[] args) throws IOException, InterruptedException {
//        获得连接
        Connection connection = MQUntil.getMQConnection();
//       获得通道
        Channel channel = connection.createChannel();
//        在队列服务器上声明队列
        channel.queueDeclare("MyQueues1",false,false,false,null);
        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
        channel.basicConsume("MyQueues1",true,queueingConsumer);
//        读取消息
        while (true){
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            System.out.println("消费者1-->"+new String(delivery.getBody()));
        }

    }
}

消费者2

package com.blb.rabbitmq_demo.topic;

import com.blb.rabbitmq_demo.until.MQUntil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;

import java.io.IOException;

/**
 * 主题模式的消费者2 ，类似路由模式，可以使用通配符对Key进行筛选
 *   #匹配1个或多个单词，*匹配一个单词
 */
public class TopicConsumer02 {

    public static void main(String[] args) throws IOException, InterruptedException {
//        获得连接
        Connection connection = MQUntil.getMQConnection();
//       获得通道
        Channel channel = connection.createChannel();
//        在队列服务器上声明队列
        channel.queueDeclare("MyQueues2",false,false,false,null);
        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
        channel.basicConsume("MyQueues2",true,queueingConsumer);
//        读取消息
        while (true){
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            System.out.println("消费者2-->"+new String(delivery.getBody()));
        }

    }
}

总结

模式有：

  1. 一对一

  2. 一对多

    前两种都只有一个队列，多个消费者共享一个队列中的消息

  3. 发布订阅模式

    由交换机绑定多个队列，每个消费者消费自己的队列中的消息

  4. 路由模式

    在发布订阅模式的基础上，加入路由键，消息通过键路由到不同的队列

  5. 主题模式

    在路由模式基础上，键中加入通配符

快起来学习哇
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
1.操作系统实验2_8消息队列基本使用1
08-04
操作系统实验2_8主要关注的是消息队列在嵌入式实时操作系统RT-Thread中的应用，实验目的是让学习者了解和熟练使用消息队列进行多线程间的通信。实验平台选择了RealTouch评估板，该板子基于STM32微控制器，且配备了...
C#消息队列发送及接收
03-25
以上就是C#中使用MSMQ进行消息队列发送和接收的基本步骤。在实际应用中，你可能需要考虑更多的细节，比如异常处理、队列的持久化、事务支持等。MSMQ还提供了丰富的功能，如消息确认、队列管理、消息筛选等，可以根据...
消息队列详解与应用
m0_68987535的博客
05-30 689
概 念。
消息队列使用
smlzhang的专栏
06-10 409
应用场景：商城订单取消，火车票取消，七天自动确认收货，自动评价功能，充电桩解决方案有两个1，定时器2，延迟队列。
消息队列基本使用
最新发布
weixin_63687273的博客
06-01 375
数据隔离：不同的项目使用同一个MQ的时候想要数据隔离开来，就需要创建不同的用户，给不同的用户配置不同的虚拟主机。在控制台创建这些容易出错，推荐的做法是由程序在代码里创建，项目启动时检查队列和交换机是否存在，如果不存在自动创建。异步通讯：就如同发微信聊天，双方的交互不是实时的，你不需要立刻给对方回应。因此你可以多线操作，同时跟多人聊天。同步通讯：就如同打视频电话，双方的交互都是实时的。·多个消费者绑定到一个队列，同一条消息只会被一个消费者处理。·交换机作用：只用发送一次消息，能够被处理多次。
一文让你彻底理解关于消息队列的使用
嵌入式Linux内核的博客
02-25 1434
消息队列中间件是分布式系统中重要的组件，主要解决应用解耦，异步消息，流量削锋等问题，实现高性能，高可用，可伸缩和最终一致性架构。目前使用较多的消息队列有ActiveMQ，RabbitMQ，ZeroMQ，Kafka，MetaMQ，RocketMQ。
RabbitMQ从零开始学（三）通信模型之Work型—channel.basicQos()
孔明的博客
03-12 2949
work模型 称为工作队列或者竞争消费者模式，多个消费者消费的数据之和才是原来队列中的所有数据，适用于流量的消峰 生产者的编写 public class Producer { private static final String QUEUE_NAME = "queue_work_1"; public static void main(String[] args) throws ...
（一）「消息队列」之 RabbitMQ 入门
YMGogre的博客
06-07 1350
想要实现两个应用程序之间的通信，我们可以借助“消息队列”技术。本文将介绍使用 C# 语言在 .NET 下实现 RabbitMQ 消息队列；当然无论是哪种编程语言或框架，要使用消息队列，都需要完成以下两个基本步骤：①下载并安装相应的消息队列服务器软件，并根据需要进行配置；②在您的应用程序代码中引入相应的消息队列客户端库，并使用客户端库提供的API来建立与消息队列服务器的连接并进行通信；这些步骤对于大多数消息队列中间件都是适用的。
消息队列Kafka简介基本用法
05-06
消息队列kafka的基本用法与介绍
RabbitMQ .NET消息队列使用详解
10-21
在本文中，我们将深入探讨如何在.NET环境中使用RabbitMQ进行消息队列操作。首先，我们需要在RabbitMQ官方网站下载适用于Windows 64位系统的安装包，包括otp_win64_19.0.exe和rabbitmq-server-3.6.3.exe，并完成安装...
linux 消息队列使用示例
08-23
本文将详细解析标题“linux消息队列使用示例”中涉及的知识点，并通过描述中的简单示例代码来理解消息队列的工作原理。 首先，我们需要了解消息队列的基本概念。消息队列是内核维护的一个特殊的数据结构，它存储由...
RabbitMQ详解
u012758488的博客
11-01 2076
RabbitMQ五种队列形式 1.点对点(简单)的队列 2.工作(公平性)队列模式 3.发布订阅模式 4.路由模式Routing 5.通配符模式Topics
关于消息队列的使用
cc874944236的博客
07-06 569
一、消息队列概述 消息队列中间件是分布式系统中重要的组件，主要解决应用解耦，异步消息，流量削锋等问题，实现高性能，高可用，可伸缩和最终一致性架构。目前使用较多的消息队列有ActiveMQ，RabbitMQ，ZeroMQ，Kafka，MetaMQ，RocketMQ 二、消息队列应用场景 以下介绍消息队列在实际应用中常用的使用场景。异步处理，应用解耦，流量削锋和消息通讯四个场景。 2.1异步处理 场景说明：用户注册后，需要发注册邮件和注册短信。传统的做法有两种 1.串行的方式；2.并行方式 a、串行方式：将注册
rabbitMQ 学习笔记
weixin_43822267的博客
07-18 623
RabbitMQ消息队列 默认账号密码：guest cmd启动进入安装目录的sbin目录启动rabbitmq_management管理界面：.\rabbitmq-plugins enable rabbitmq_management。 管理界面rabbitmq_management管理界面启动访问路径：localhost:15672 已声明的队列不能在进行持久化修改。 一个队列只能有一个事务模式。 channel.basicPublish(交换机名,路由名或队列名,props,body)；发送消息到交换器或队
消息队列（Message Queue，MQ）的使用
qq_27561019的博客
06-13 1305
消息队列（Message Queue，MQ）是一种跨进程、跨服务器的通讯机制，它的基本思想是生产者把消息发送到消息队列中，然后消费者从消息队列中获取消息并进行处理，从而实现了生产与消费的解耦。通过MQ可以将消息生产者和消费者进行解耦，生产者只需要将消息发送到MQ中，而不需要知道谁会来处理这个消息，消费者也只需要从MQ中获取消息，并进行相应的处理即可。MQ是一种跨进程、跨服务器的通讯机制，它的基本思想是生产者把消息发送到消息队列中，然后消费者从消息队列中获取消息并进行处理，从而实现了生产与消费的解耦。
消息队列的使用
weixin_48256350的博客
03-20 435
消息队列 管道： 不能读取特定，只要管道中有数据，就会全部读取 消息队列： 可以读取相对应的数据 1. 根据key值申请消息队列ID号 --> msgget() --> man 2 msgget 功能： msgget - get a message queue identifier //获取消息队列的ID号 #include <sys/types.h> #include <sys/ipc.h> #include <sys/msg.h>
Linux初学第九天＜进程间通信 二、消息队列＞
qq1140920745的博客
11-19 387
一、消息队列概念及原理        消息队列是消息的结构体，我们在发送消息的时候，是以结构体的方式发送，结构体的元素包含消息类型和消息内容。消息队列存放内核当中，一个消息队列由一个标识符（即队列ID）来标识；。 消息队列的特点 （1） 消息队列是面向记录的，其中的消息具有特定的格式以及特定的优先级； （2） 消息队列独立于发送与接收进程。进程终止时，消息队列的内容并不会被删除； （3） 消息队列可以实现消息的随机查询，消息不一定要以先进
图文并茂的RabbitMQ工作模式
王华春_Jason
09-15 772
一、简单模式 1、简单模式 一对一模式，一个生产者、一个消费者，生产者发送消息，消费者消费消息。 生产者：也就是要发送消息的程序 消费者：消息的接收者，会一直等待消息到来 消息队列：类似一个邮箱，可以缓存消息；生产者向其中投递消息，消费者从其中取出消息 2、实例代码： //生产者 public class Producer { public static void main(String[] args) throws IOException, TimeoutException
RabbitMQ basicQos预取方法参数解析
Taysuesue的博客
02-22 1720
一个参数 channel.basicQos(1); //basicQos(int prefetchCount) 两个参数 channel.basicQos(3,false); //basicQos(int prefetchCount, boolean global) 三个参数 channel.basicQos(0,3,false); //basicQos(int prefetchSize, int prefetchCount, boolean global) prefetchSize：可接收消息的大小的 p
试描述消息队列的基本使用流程
07-11
下面是消息队列的基本使用流程： 1. 创建消息队列：首先，需要创建一个消息队列。这可以通过调用操作系统提供的相关函数或使用特定的消息队列库来完成。 2. 发送消息：在发送进程中，将要发送的消息写入到消息队列...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值