AI 助理
备案控制台
开发者社区 微服务 文章 正文

RocketMQ-初体验RocketMQ(06)-使用API操作RocketMQ ,理解RocketMQ的存储结构

2024-01-02 206
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
日志服务 SLS，月写入数据量 50GB 1个月
简介： RocketMQ-初体验RocketMQ(06)-使用API操作RocketMQ ,理解RocketMQ的存储结构

RocketMQ集群基本信息

右侧的部署模式 ，双机互为主备

如何搭建的，请移步： RocketMQ-初体验RocketMQ(03)_RocketMQ多机集群部署

为了更好的观察RocketMQ在我们发送和消费消息的过程中，给我们产生了什么样的文件，我们把 storePathRootDir 和 storePathCommitLog 自定义到一个新的目录下

130 节点的 broker-m.conf 和 broker-s.conf中的 storePathRootDir 和 storePathCommitlog配置

一个broker节点对应一个commitlog, 所以130主机的 master broker 和 slave broker 会对应两个存储路径和两个commitlog . 注意看存储路径

broker-m.conf

broker-s.conf

启动 130的 namesrv 和 master broker 、 slave broker 节点，观察我们配置的

storePathRootDir 和 storePathCommitlog

同样的 也把131 修改下

目标

1. 使用RocketMQ 发送3种类型的消息： reliable synchronous、 reliable asynchronous、one-way transmission

2. 使用RocketMQ消费消息

知识预习

发送方式

在Producer端

org.apache.rocketmq.client.impl.CommunicationMode 枚举类中定义了3种发送方式

public enum CommunicationMode {
    SYNC,
    ASYNC,
    ONEWAY,
}
  • Sync：同步的发送方式，会等待发送结果后才返回
  • Async：异步的发送方式，发送完后，立刻返回。Client 在拿到 Broker 的响应结果后，会回调指定的 callback. 可以指定 Timeout。默认的 3000ms.
  • Oneway：发出去后，什么都不管直接返回

发送结果

org.apache.rocketmq.client.produce.SendStatus 枚举类中定义了如下4种发送结果

package org.apache.rocketmq.client.producer;
public enum SendStatus {
    SEND_OK,
    FLUSH_DISK_TIMEOUT,
    FLUSH_SLAVE_TIMEOUT,
    SLAVE_NOT_AVAILABLE,
}

1. SEND_OK ： 消息发送成功。要注意的是消息发送成功也不意味着它是可靠的。要确保不会丢失任何消息，还应启用同步Master服务器或同步刷盘，即SYNC_MASTER或 SYNC_FLUSH。

2. FLUSH_DISK_TIMEOUT：消息发送成功但是服务器刷盘超时。此时消息已经进入服务器队列（内存），只有服务器宕机，消息才会丢失。消息存储配置参数中可以设置刷盘方式和同步刷盘时间长度，如果Broker服务器设置了刷盘方式为同步刷盘，即FlushDiskType=SYNC_FLUSH（默认为异步刷盘方式），当Broker服务器未在同步刷盘时间内（默认为5s）完成刷盘，则将返回该状态——刷盘超时。

3. FLUSH_SLAVE_TIMEOUT ：消息发送成功，但是服务器同步到Slave时超时。此时消息已经进入服务器队列，只有服务器宕机，消息才会丢失。如果Broker服务器的角色是同步Master，即SYNC_MASTER（默认是异步Master即ASYNC_MASTER），并且从Broker服务器未在同步刷盘时间（默认为5秒）内完成与主服务器的同步，则将返回该状态——数据同步到Slave服务器超时

4. SLAVE_NOT_AVAILABLE：消息发送成功，但是此时Slave不可用。如果Broker服务器的角色是同步Master，即SYNC_MASTER（默认是异步Master服务器即ASYNC_MASTER），但没有配置slaveBroker服务器，则将返回该状态——无Slave服务器可用。

环境搭建

移步 ： IDEA-使用IDEA创建maven多模块父子工程

使用Java API操作RocketMQ—Simple Message

官方指导： 戳这里

Step1. pom.xml增加依赖和bulid 插件

<?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"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>rocketmqMaster</artifactId>
        <groupId>com.artisan</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>rocketmq_base</artifactId>
    <dependencies>
        <dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-client</artifactId>
            <version>4.3.2</version>
        </dependency>
    </dependencies>
    <build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>2.3.2</version>
                    <configuration>
                        <source>1.8</source>
                        <target>1.8</target>
                        <encoding>utf8</encoding>
                        <compilerArgument>-XDignore.symbol.file=true -Xlint</compilerArgument>
                        <testCompilerArgument>-XDignore.symbol.file=true -Xlint</testCompilerArgument>
                    </configuration>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
</project>

Step2.日志文件 logback.xml

<configuration>
    <!-- 应用名称 -->
    <property name="APP_NAME" value="rocketmq_base" />
    <!--日志文件的保存路径,首先查找系统属性-Dlog.dir,如果存在就使用其；
        否则，在当前目录下创建名为logs目录做日志存放的目录 -->
    <property name="LOG_HOME" value="${log.dir:-logs}/${APP_NAME}" />
    <!-- 日志输出格式 -->
    <property name="ENCODER_PATTERN"
              value="%d{yyyy-MM-dd  HH:mm:ss.SSS} [%thread] %-5level %logger{80} - %msg%n" />
    <contextName>${APP_NAME}</contextName>
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>${ENCODER_PATTERN}</pattern>
        </encoder>
    </appender>
    <!-- 文件日志：输出全部日志到文件 -->
    <appender name="FILE"
              class="ch.qos.logback.core.rolling.RollingFileAppender">
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${LOG_HOME}/output.%d{yyyy-MM-dd}.log</fileNamePattern>
            <maxHistory>7</maxHistory>
        </rollingPolicy>
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${ENCODER_PATTERN}</pattern>
        </encoder>
    </appender>
    <!-- 错误日志：用于将错误日志输出到独立文件 -->
    <appender name="ERROR_FILE"
              class="ch.qos.logback.core.rolling.RollingFileAppender">
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${LOG_HOME}/error.%d{yyyy-MM-dd}.log</fileNamePattern>
            <maxHistory>7</maxHistory>
        </rollingPolicy>
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${ENCODER_PATTERN}</pattern>
        </encoder>
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>WARN</level>
        </filter>
    </appender>
    <!-- 独立输出的同步日志 -->
    <appender name="SYNC_FILE"  class="ch.qos.logback.core.rolling.RollingFileAppender">
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${LOG_HOME}/sync.%d{yyyy-MM-dd}.log</fileNamePattern>
            <maxHistory>7</maxHistory>
        </rollingPolicy>
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${ENCODER_PATTERN}</pattern>
        </encoder>
    </appender>
    <logger name="rocketmq_base" level="ERROR" addtivity="true">
        <appender-ref ref="SYNC_FILE" />
    </logger>
    <root level="ERROR">
        <appender-ref ref="STDOUT" />
        <appender-ref ref="FILE" />
        <appender-ref ref="ERROR_FILE" />
    </root>
</configuration>

发送同步消息

package com.artisan.rocketmq.simple.producer;
import org.apache.rocketmq.client.exception.MQBrokerException;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.common.RemotingHelper;
import org.apache.rocketmq.remoting.exception.RemotingException;
import java.io.UnsupportedEncodingException;
/**
 * @author 小工匠
 * @version v1.0
 * @create 2019-11-10 1:46
 * @motto show me the code ,change the word
 * @blog https://artisan.blog.csdn.net/
 * @description 同步发送消息
 **/
public class SyncProducer {
    public static void main(String[] args) throws MQClientException, RemotingException, InterruptedException, MQBrokerException, UnsupportedEncodingException {
        //Instantiate with a producer group name.
        DefaultMQProducer producer = new
                DefaultMQProducer("Artisan_ProducerGroup");
        // Specify name server addresses.
        producer.setNamesrvAddr("192.168.18.130:9876;192.168.18.131:9876");
        // 设置超时时间，默认3秒
        producer.setSendMsgTimeout(10_000);
        //Launch the instance.
        producer.start();
//        for (int i = 0; i < 100; i++) {
//            //Create a message instance, specifying topic, tag and message body.
//            Message msg = new Message("TopicArtisan" /* Topic */,
//                    "TagArtisan" /* Tag */,
//                    ("Artisan:Hello RocketMQ  " + i).getBytes(RemotingHelper.DEFAULT_CHARSET) /* Message body */
//            );
//            //Call send message to deliver message to one of brokers.
//            SendResult sendResult = producer.send(msg);
//            System.out.printf("%s%n", sendResult);
//        }
        //Create a message instance, specifying topic, tag and message body.
        Message msg = new Message("TopicArtisan" /* Topic */,
                "TagArtisan" /* Tag */,
                ("Artisan:Hello RocketMQ  ").getBytes(RemotingHelper.DEFAULT_CHARSET) /* Message body */
        );
        //Call send message to deliver message to one of brokers.
        SendResult sendResult = producer.send(msg);
        System.out.printf("%s%n", sendResult);
        //Shut down once the producer instance is not longer in use.
        producer.shutdown();
    }
}

如果超时的话，设置下超时时间 producer.setSendMsgTimeout(10_000);

发送一条消息

返回：

SendResult [sendStatus=SEND_OK, msgId=C0A81F891D2418B4AAC230A647AD0000, offsetMsgId=C0A8128300002A9F00000000000025B0, messageQueue=MessageQueue [topic=TopicArtisan, brokerName=broker‐b, queueId=3], queueOffset=13]

可知 发送到了 集群中的 节点 的queueId=3 第四个队列里去了

到控制台根据msgId查看一下

发送异步消息

package com.artisan.rocketmq.simple.producer;
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendCallback;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.common.RemotingHelper;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
/**
 * @author 小工匠
 * @version v1.0
 * @create 2019-11-10 12:18
 * @motto show me the code ,change the word
 * @blog https://artisan.blog.csdn.net/
 * @description 异步消息
 **/
public class AsyncProducer {
    public static void main(String[] args) throws Exception {
        DefaultMQProducer producer = new DefaultMQProducer("Artisan_ProducerGroup");
        producer.setNamesrvAddr("192.168.18.130:9876;192.168.18.131:9876");
        //设置发送失败重试机制
        producer.setRetryTimesWhenSendAsyncFailed(5);
        producer.start();
        int messageCount = 1;
        final CountDownLatch countDownLatch = new CountDownLatch(messageCount);
        for (int i = 0; i < messageCount; i++) {
            final int index = i;
            Message msg = new Message("TopicAsyn",
                    "TagAsyn",
                    "OrderID188",
                    "I m sending msg content xxx".getBytes(RemotingHelper.DEFAULT_CHARSET));
            //消息发送成功后，执行回调函数
            producer.send(msg, new SendCallback() {
                @Override
                public void onSuccess(SendResult sendResult) {
                    countDownLatch.countDown();
                    System.out.printf("%-10d OK %s %n", index,
                            sendResult.getMsgId());
                }
                @Override
                public void onException(Throwable e) {
                    countDownLatch.countDown();
                    System.out.printf("%-10d Exception %s %n", index, e);
                    e.printStackTrace();
                }
            });
        }
        countDownLatch.await(5, TimeUnit.SECONDS);
        producer.shutdown();
    }
}

日志：

控制台查询

发送one way 消息

package com.artisan.rocketmq.simple.producer;
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.common.RemotingHelper;
/**
 * @author 小工匠
 * @version v1.0
 * @create 2019-11-10 12:45
 * @motto show me the code ,change the word
 * @blog https://artisan.blog.csdn.net/
 * @description
 **/
public class OnewayProducer {
    public static void main(String[] args) throws Exception{
        DefaultMQProducer producer = new DefaultMQProducer("tl_message_group");
        // Specify name server addresses.
        producer.setNamesrvAddr("192.168.18.130:9876;192.168.18.131:9876");
        producer.setSendMsgTimeout(10000);
        producer.start();
        for (int i = 0; i < 1; i++) {
            Message msg = new Message("TopicOneWay" /* Topic */,
                    "TagSendOne" /* Tag */,
                    "OrderID198",
                    ("Hello RocketMQ test i " +
                            i).getBytes(RemotingHelper.DEFAULT_CHARSET) /* Message body */
            );
            producer.sendOneway(msg);
        }
        //Shut down once the producer instance is not longer in use.
        producer.shutdown();
    }
}

消费消息

push模式

package com.artisan.rocketmq.simple.consumer;
import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerConcurrently;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.common.message.MessageExt;
import java.util.List;
/**
 * @author 小工匠
 * @version v1.0
 * @create 2019-11-10 12:49
 * @motto show me the code ,change the word
 * @blog https://artisan.blog.csdn.net/
 * @description
 **/
public class Consumer {
    public static void main(String[] args) throws InterruptedException, MQClientException {
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("Artisan_ProducerGroup");
        consumer.setNamesrvAddr("192.168.18.130:9876;192.168.18.131:9876");
        // Subscribe one more more topics to consume.
        consumer.subscribe("TopicAsyn", "*");
        // Register callback to execute on arrival of messages fetched from brokers.
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs,
                                                            ConsumeConcurrentlyContext context) {
                for (MessageExt msg : msgs){
                    System.out.println(new String(msg.getBody()));
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        consumer.start();
        System.out.printf("Consumer Started.%n");
    }
}

pull模式

package com.artisan.rocketmq.simple.consumer;
import org.apache.rocketmq.client.consumer.DefaultMQPullConsumer;
import org.apache.rocketmq.client.consumer.PullResult;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.common.message.MessageQueue;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
 * @author 小工匠
 * @version v1.0
 * @create 2019-11-10 13:51
 * @motto show me the code ,change the word
 * @blog https://artisan.blog.csdn.net/
 * @description
 **/
public class PullConsumer {
    private static final Map<MessageQueue, Long> offsetTable = new HashMap<MessageQueue, Long>();
    public static void main(String[] args) throws MQClientException {
        DefaultMQPullConsumer consumer = new DefaultMQPullConsumer("tl_message_group");
        consumer.setNamesrvAddr("192.168.241.198:9876");
        consumer.start();
        Set<MessageQueue> mqs = consumer.fetchSubscribeMessageQueues("TopicStudent");
        for (MessageQueue mq : mqs) {
            System.err.println("Consume from the queue: " + mq);
            SINGLE_MQ:
            while (true) try {
                PullResult pullResult = consumer.pullBlockIfNotFound(mq, null, getMessageQueueOffset(mq), 32);
                System.out.println(pullResult);
                putMessageQueueOffset(mq, pullResult.getNextBeginOffset());
                switch (pullResult.getPullStatus()) {
                    case FOUND:
                        List<MessageExt> messageExtList = pullResult.getMsgFoundList();
                        for (MessageExt m : messageExtList) {
                            System.out.println(new String(m.getBody()));
                        }
                        break;
                    case NO_MATCHED_MSG:
                        break;
                    case NO_NEW_MSG:
                        break SINGLE_MQ;
                    case OFFSET_ILLEGAL:
                        break;
                    default:
                        break;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        consumer.shutdown();
    }
    private static void putMessageQueueOffset(MessageQueue mq, long offset) {
        offsetTable.put(mq, offset);
    }
    private static long getMessageQueueOffset(MessageQueue mq) {
        Long offset = offsetTable.get(mq);
        if (offset != null)
            return offset;
        return 0;
    }
}

结构变化

自动创建了commitlog目录，其中目录下的文件固定为 1024M

自动创建了 index 索引目录

自动创建consumequeue目录

代码

请移步：https://github.com/yangshangwei/rocketmqMaster

更多示例

RocketMQ Gihub官网example工程 ：戳这里



文章标签：
云消息队列 MQ
云数据库 ClickHouse
日志服务
消息中间件
RocketMQ
存储
API
Java
关键词：
云消息队列 MQ存储
API存储
云消息队列 MQ api
云消息队列 MQ操作
API操作
相关实践学习
消息队列RocketMQ版：基础消息收发功能体验
本实验场景介绍消息队列RocketMQ版的基础消息收发功能，涵盖实例创建、Topic、Group资源创建以及消息收发体验等基础功能模块。
消息队列 MNS 入门课程
1、消息队列MNS简介 本节课介绍消息队列的MNS的基础概念 2、消息队列MNS特性 本节课介绍消息队列的MNS的主要特性 3、MNS的最佳实践及场景应用 本节课介绍消息队列的MNS的最佳实践及场景应用案例 4、手把手系列：消息队列MNS实操讲 本节课介绍消息队列的MNS的实际操作演示 5、动手实验：基于MNS，0基础轻松构建 Web Client 本节课带您一起基于MNS，0基础轻松构建 Web Client
小小工匠
目录
相关文章
三分钟热度的鱼
|
6月前
|
消息中间件 C语言 RocketMQ
消息队列 MQ操作报错合集之出现"Connection reset by peer"的错误，该如何处理
消息队列（MQ）是一种用于异步通信和解耦的应用程序间消息传递的服务，广泛应用于分布式系统中。针对不同的MQ产品，如阿里云的RocketMQ、RabbitMQ等，它们在实现上述场景时可能会有不同的特性和优势，比如RocketMQ强调高吞吐量、低延迟和高可用性，适合大规模分布式系统；而RabbitMQ则以其灵活的路由规则和丰富的协议支持受到青睐。下面是一些常见的消息队列MQ产品的使用场景合集，这些场景涵盖了多种行业和业务需求。
三分钟热度的鱼
305 0
三分钟热度的鱼
|
6月前
|
文字识别 小程序 安全
印刷文字识别操作报错合集之微信小程序调用API时路径总是返回不对，该如何处理
在使用印刷文字识别(OCR)服务时，可能会遇到各种错误。例如：1.Java异常、2.配置文件错误、3.服务未开通、4.HTTP错误码、5.权限问题（403 Forbidden）、6.调用拒绝（Refused）、7.智能纠错问题、8.图片质量或格式问题，以下是一些常见错误及其可能的原因和解决方案的合集。
三分钟热度的鱼
57 1
三分钟热度的鱼
|
6月前
|
文字识别 前端开发 API
印刷文字识别操作报错合集之通过HTTPS连接到OCR服务的API时报错，该如何处理
在使用印刷文字识别(OCR)服务时，可能会遇到各种错误。例如：1.Java异常、2.配置文件错误、3.服务未开通、4.HTTP错误码、5.权限问题（403 Forbidden）、6.调用拒绝（Refused）、7.智能纠错问题、8.图片质量或格式问题，以下是一些常见错误及其可能的原因和解决方案的合集。
三分钟热度的鱼
111 1
三分钟热度的鱼
|
6月前
|
消息中间件 Java 物联网
消息队列 MQ操作报错合集之建立连接时发生了超时错误，该如何解决
消息队列（MQ）是一种用于异步通信和解耦的应用程序间消息传递的服务，广泛应用于分布式系统中。针对不同的MQ产品，如阿里云的RocketMQ、RabbitMQ等，它们在实现上述场景时可能会有不同的特性和优势，比如RocketMQ强调高吞吐量、低延迟和高可用性，适合大规模分布式系统；而RabbitMQ则以其灵活的路由规则和丰富的协议支持受到青睐。下面是一些常见的消息队列MQ产品的使用场景合集，这些场景涵盖了多种行业和业务需求。
三分钟热度的鱼
710 0
消息队列 MQ操作报错合集之建立连接时发生了超时错误，该如何解决
路边两盏灯
|
5月前
|
存储 API 开发工具
【Azure API 管理】讨论APIM是否适合直接存储文件到Azure Storage Account呢？
【Azure API 管理】讨论APIM是否适合直接存储文件到Azure Storage Account呢？
路边两盏灯
40 0
真的很搞笑
|
6月前
|
存储 网络协议 前端开发
云计算存储问题之RESTful API适用场景如何解决
云计算存储问题之RESTful API适用场景如何解决
真的很搞笑
60 2
嘟嘟嘟嘟嘟嘟
|
6月前
|
DataWorks 关系型数据库 MySQL
DataWorks操作报错合集之调用CreateQualityRule API时，BlockType参数为0，会报错："blockType less than minimum"，该怎么办
DataWorks是阿里云提供的一站式大数据开发与治理平台，支持数据集成、数据开发、数据服务、数据质量管理、数据安全管理等全流程数据处理。在使用DataWorks过程中，可能会遇到各种操作报错。以下是一些常见的报错情况及其可能的原因和解决方法。
嘟嘟嘟嘟嘟嘟
57 2
土木林森
|
6月前
|
前端开发 JavaScript API
惊天揭秘！AJAX与Fetch API如何让你的前后端交互秒变‘神级操作’！
【7月更文挑战第15天】在Web开发中，AJAX和Fetch API革新了前后端交互，告别了表单提交带来的页面刷新。AJAX利用XMLHttpRequest实现部分页面更新，开启无刷新时代；Fetch API作为现代替代，以其简洁和Promise支持简化异步操作。从AJAX的先驱地位到Fetch API的进化，两者提升了Web应用的性能和用户体验，成为现代开发的必备技能。
土木林森
67 2
人物我非-32022
|
6月前
|
搜索推荐 API UED
资源部署及场景API调用体验过程的引导与操作流畅性
资源部署及场景API调用体验过程的引导与操作流畅性
人物我非-32022
49 3
三分钟热度的鱼
|
6月前
|
消息中间件 JavaScript Linux
消息队列 MQ操作报错合集之客户端在启动时遇到了连接错误，是什么原因
消息队列（MQ）是一种用于异步通信和解耦的应用程序间消息传递的服务，广泛应用于分布式系统中。针对不同的MQ产品，如阿里云的RocketMQ、RabbitMQ等，它们在实现上述场景时可能会有不同的特性和优势，比如RocketMQ强调高吞吐量、低延迟和高可用性，适合大规模分布式系统；而RabbitMQ则以其灵活的路由规则和丰富的协议支持受到青睐。下面是一些常见的消息队列MQ产品的使用场景合集，这些场景涵盖了多种行业和业务需求。
三分钟热度的鱼
196 0

热门文章

最新文章

  • 1
    大厂都在用的分布式事务方案，Seata+RocketMQ带你打破10万QPS瓶颈
  • 2
    C5GAME 游戏饰品交易平台借助 RocketMQ Serverless 保障千万级玩家流畅体验
  • 3
    朗新科技集团如何用云消息队列 RocketMQ 版“快、准、狠”破解业务难题？
  • 4
    2024最全RabbitMQ集群方案汇总
  • 5
    【实践】快速学会使用云消息队列RabbitMQ版
  • 6
    说说MQ在你项目中的应用(一)
  • 7
    高弹性、低成本的云消息队列RabbitMQ 版
  • 8
    2024最全RocketMQ集群方案汇总
  • 9
    如何将Spring Boot + RabbitMQ应用程序部署到Pivotal Cloud Foundry (PCF)
  • 10
    多协议网关BL110钡铼6路RS485转MQTT协议云网关
  • 1
    Java Stream API详解与使用
    101
  • 2
    Kubernetes学习-集群搭建篇(三) Node配置完善和API概述
    89
  • 3
    HTML5 Canvas 提供丰富的绘图API，支持绘制图形、文本、渐变和图像，助力游戏开发
    81
  • 4
    Java 8新特性之Lambda表达式与Stream API的深度解析
    107
  • 5
    Linux系统编程之文件编程常用API回顾和文件编程一般步骤
    87
  • 6
    阿里云微服务引擎及 API 网关 2024 年 4 月产品动态
    396
  • 7
    阿里云微服务引擎 MSE 及 API 网关 2024 年 04 月产品动态
    279
  • 8
    智能体-Agent能力升级！新增Assistant API & Tools API服务接口
    572
  • 9
    使用Performance API进行性能监控
    121
  • 10
    RESTful API的最佳实践
    68

    • 相关课程

    更多
  • 消息队列 RocketMQ 消息集成
  • 消息队列 MNS 入门课程
  • RocketMQ知识精讲与项目实战（第一阶段）
  • RocketMQ知识精讲与项目实战（第二阶段）
  • RocketMQ知识精讲与项目实战（第三阶段）
  • 微服务实战-RocketMQ Binder

    • 相关电子书

    更多
  • Spring Boot2.0实战Redis分布式缓存
  • CUDA MATH API
  • API PLAYBOOK

    • 相关实验场景

    更多
  • 通过轻量消息队列（原MNS）主题HTTP订阅+ARMS实现自定义数据多渠道告警
  • 快速体验云消息队列RocketMQ版
  • 消息队列RocketMQ版：基础消息收发功能体验
  • 快速入门轻量消息队列（原MNS）
  • 快速学会使用云消息队列RabbitMQ版
  • 基于Assistant Api的旅游助手
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月