RocketMQ学习(三)：SpringBoot与RocketMQ使用

最新推荐文章于 2023-11-09 14:24:59 发布
最新推荐文章于 2023-11-09 14:24:59 发布
阅读量207 收藏
点赞数
文章标签： java 运维 人工智能
原文链接：https://my.oschina.net/u/2299686/blog/1618682
版权

    基于《RocketMQ学习(二)：基于Docker镜像搭建单机版》构建的镜像，进行SpringBoot与RocketMQ简单测试。

    环境版本：

  • SpringBoot 1.5.9
  • RocketMQ 4.2.0
  • Maven 3.3.9
  • Java 1.8

    目录大纲：

  • (1) 新建project以及添加依赖包
  • (2) 启动类App.java
  • (3) application配置文件
  • (4) logback.xml
  • (5) 生产者
  • (6) 消费者
  • (7) 测试

1、新建project以及添加依赖包

<?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">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.xusg</groupId>
    <artifactId>study-rocketmq</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>study-rocketmq</name>
    <url>http://maven.apache.org</url>
    <description>RocketMQ 学习</description>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <java_source_version>1.8</java_source_version>
        <java_target_version>1.8</java_target_version>
        <file_encoding>UTF-8</file_encoding>

        <springboot.version>1.5.9.RELEASE</springboot.version>
        <rocketmq.version>4.2.0</rocketmq.version>
    </properties>

    <dependencies>
        <!--SpringBoot-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
            <version>${springboot.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <version>${springboot.version}</version>
            <scope>test</scope>
        </dependency>

        <!--Rocketmq-->
        <dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-client</artifactId>
            <version>${rocketmq.version}</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <fork>true</fork>
                    <source>${java_source_version}</source>
                    <target>${java_target_version}</target>
                    <encoding>${file_encoding}</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

2、启动类App.java

package com.xusg.study;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

/**
 * @Author Xusg
 * @Date 18/2/5 16:39
 */
@Configuration
@EnableAutoConfiguration
@ComponentScan(basePackages = {"com.xusg.study"})
public class RocketMQApplicationMain {

    public static void main(String[] args) {
        SpringApplication.run(RocketMQApplicationMain.class, args);
    }

}

3、application配置文件

spring:
  rocketmq:
    namesrvaddr: 192.168.56.101:29876

4、logback.xml文件

<?xml version="1.0" encoding="UTF-8" ?>
<configuration scan="true" scanPeriod="10 seconds">
    <!--STDOUT LOG-->
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>
                <!--日期 线程名 日志级别 类名 程序信息 换行-->
                [%date{MM-dd HH:mm:ss SSS}] %thread %level %logger{0} - %msg%n
            </pattern>
            <charset>UTF-8</charset>
        </encoder>
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>DEBUG</level>
        </filter>
    </appender>

    <!--FILE LOG-->
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <encoder>
            <pattern>
                [%date{MM-dd HH:mm:ss SSS}] %thread %level %logger{0} - %msg%n
            </pattern>
            <charset>UTF-8</charset>
        </encoder>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>./logs/study-rocketmq/detail-rocketmq.%d{yyyy-MM-dd}.log</fileNamePattern>
            <maxHistory>30</maxHistory>
        </rollingPolicy>
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>DEBUG</level>
        </filter>
        <prudent>true</prudent>
    </appender>

    <root level="INFO">
        <appender-ref ref="FILE"/>
        <appender-ref ref="STDOUT"/>
    </root>

</configuration>

5、生产者

package com.xusg.study.producer;

import org.apache.rocketmq.client.exception.MQClientException;
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 org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

/**
 * RocketMQ生产者
 *
 * @Author Xusg
 * @Date 18/2/5 17:46
 */
@Component
public class MQProducer {

    private static final Logger LOGGER = LoggerFactory.getLogger(MQProducer.class);

    @Value("${spring.rocketmq.namesrvAddr}")
    private String namesrvAddr;

    private final DefaultMQProducer producer = new DefaultMQProducer("TestRocketMQProducer");

    /**
     * 初始化
     */
    @PostConstruct
    public void start() {
        try {
            LOGGER.info("MQ：启动生产者");
            producer.setNamesrvAddr(namesrvAddr);
            producer.start();
        } catch (MQClientException e) {
            LOGGER.error("MQ：启动生产者失败：{}-{}", e.getResponseCode(), e.getErrorMessage());
            throw new RuntimeException(e.getMessage(), e);
        }
    }

    /**
     * 发送消息
     *
     * @param data  消息内容
     * @param topic 主题
     * @param tags  标签
     * @param keys  唯一主键
     */
    public void sendMessage(String data, String topic, String tags, String keys) {
        try {
            byte[] messageBody = data.getBytes(RemotingHelper.DEFAULT_CHARSET);

            Message mqMsg = new Message(topic, tags, keys, messageBody);

            producer.send(mqMsg, new SendCallback() {
                @Override
                public void onSuccess(SendResult sendResult) {
                    LOGGER.info("MQ: 生产者发送消息 {}", sendResult);
                }

                @Override
                public void onException(Throwable throwable) {
                    LOGGER.error(throwable.getMessage(), throwable);
                }
            });
        } catch (Exception e) {
            LOGGER.error(e.getMessage(), e);
        }

    }

    @PreDestroy
    public void stop() {
        if (producer != null) {
            producer.shutdown();
            LOGGER.info("MQ：关闭生产者");
        }
    }
}

6、消费者

package com.xusg.study.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.consumer.ConsumeFromWhere;
import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.common.protocol.heartbeat.MessageModel;
import org.apache.rocketmq.remoting.common.RemotingHelper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import java.util.List;

/**
 * RocketMQ消费者
 *
 * @Author Xusg
 * @Date 18/2/5 17:46
 */
@Component
public class MQPushConsumer implements MessageListenerConcurrently {

    private static final Logger LOGGER = LoggerFactory.getLogger(MQPushConsumer.class);

    @Value("${spring.rocketmq.namesrvAddr}")
    private String namesrvAddr;

    private final DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("TestRocketMQPushConsumer");

    /**
     * 初始化
     *
     * @throws MQClientException
     */
    @PostConstruct
    public void start() {
        try {
            LOGGER.info("MQ：启动消费者");

            consumer.setNamesrvAddr(namesrvAddr);
            // 从消息队列头开始消费
            consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
            // 集群消费模式
            consumer.setMessageModel(MessageModel.CLUSTERING);
            // 订阅主题
            consumer.subscribe("TopicTest", "*");
            // 注册消息监听器
            consumer.registerMessageListener(this);
            // 启动消费端
            consumer.start();
        } catch (MQClientException e) {
            LOGGER.error("MQ：启动消费者失败：{}-{}", e.getResponseCode(), e.getErrorMessage());
            throw new RuntimeException(e.getMessage(), e);
        }

    }

    /**
     * 消费消息
     * @param msgs
     * @param context
     * @return
     */
    @Override
    public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
        int index = 0;
        try {
            for (; index < msgs.size(); index++) {
                MessageExt msg = msgs.get(index);

                String messageBody = new String(msg.getBody(), RemotingHelper.DEFAULT_CHARSET);

                LOGGER.info("MQ：消费者接收新信息: {} {} {} {} {}", msg.getMsgId(), msg.getTopic(), msg.getTags(), msg.getKeys(), messageBody);
            }
        } catch (Exception e) {
            LOGGER.error(e.getMessage(), e);
        } finally {
            if (index < msgs.size()) {
                context.setAckIndex(index + 1);
            }
        }
        return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
    }

    @PreDestroy
    public void stop() {
        if (consumer != null) {
            consumer.shutdown();
            LOGGER.error("MQ：关闭消费者");
        }
    }

}

7、测试

package com.xusg.study;

import com.xusg.study.producer.MQProducer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;

/**
 * @Author Xusg
 * @Date 18/2/6 14:45
 */
@RunWith(SpringRunner.class)
@SpringBootTest(classes = {RocketMQApplicationMain.class})
public class TestRocketMQ {

    @Resource
    private MQProducer mqProducer;

    @Test
    public void testProducer() {
        for (int i = 0; i < 10; i++) {
            mqProducer.sendMessage("Hello RocketMQ " + i, "TopicTest",
                    "TagTest", "Key" + i);
        }

        try {
            Thread.sleep(10 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}


#控制台日志信息
[02-06 15:08:52 500] main INFO MQPushConsumer - MQ：启动消费者
[02-06 15:08:53 622] main INFO MQProducer - MQ：启动生产者
[02-06 15:08:53 988] NettyClientPublicExecutor_1 INFO MQProducer - MQ: 生产者发送消息 SendResult [sendStatus=SEND_OK, msgId=C0A81E55346018B4AAC21CFFEB400001, offsetMsgId=C0A8386500002A9F00000000000814BA, messageQueue=MessageQueue [topic=TopicTest, brokerName=broker-a, queueId=2], queueOffset=681]
[02-06 15:08:53 989] NettyClientPublicExecutor_1 INFO MQProducer - MQ: 生产者发送消息 SendResult [sendStatus=SEND_OK, msgId=C0A81E55346018B4AAC21CFFEB400003, offsetMsgId=C0A8386500002A9F0000000000081638, messageQueue=MessageQueue [topic=TopicTest, brokerName=broker-a, queueId=0], queueOffset=678]
[02-06 15:08:53 989] ConsumeMessageThread_4 INFO MQPushConsumer - MQ：消费者接收新信息: C0A81E55346018B4AAC21CFFEB3A0000 TopicTest TagTest Key0 Hello RocketMQ 0
[02-06 15:08:53 989] NettyClientPublicExecutor_1 INFO MQProducer - MQ: 生产者发送消息 SendResult [sendStatus=SEND_OK, msgId=C0A81E55346018B4AAC21CFFEB430004, offsetMsgId=C0A8386500002A9F00000000000816F7, messageQueue=MessageQueue [topic=TopicTest, brokerName=broker-a, queueId=1], queueOffset=680]
[02-06 15:08:53 990] NettyClientPublicExecutor_1 INFO MQProducer - MQ: 生产者发送消息 SendResult [sendStatus=SEND_OK, msgId=C0A81E55346018B4AAC21CFFEB430005, offsetMsgId=C0A8386500002A9F00000000000817B6, messageQueue=MessageQueue [topic=TopicTest, brokerName=broker-a, queueId=2], queueOffset=682]
[02-06 15:08:53 990] NettyClientPublicExecutor_1 INFO MQProducer - MQ: 生产者发送消息 SendResult [sendStatus=SEND_OK, msgId=C0A81E55346018B4AAC21CFFEB430006, offsetMsgId=C0A8386500002A9F0000000000081875, messageQueue=MessageQueue [topic=TopicTest, brokerName=broker-a, queueId=3], queueOffset=682]
[02-06 15:08:53 990] NettyClientPublicExecutor_1 INFO MQProducer - MQ: 生产者发送消息 SendResult [sendStatus=SEND_OK, msgId=C0A81E55346018B4AAC21CFFEB430007, offsetMsgId=C0A8386500002A9F0000000000081934, messageQueue=MessageQueue [topic=TopicTest, brokerName=broker-a, queueId=0], queueOffset=679]
[02-06 15:08:53 990] NettyClientPublicExecutor_1 INFO MQProducer - MQ: 生产者发送消息 SendResult [sendStatus=SEND_OK, msgId=C0A81E55346018B4AAC21CFFEB430008, offsetMsgId=C0A8386500002A9F00000000000819F3, messageQueue=MessageQueue [topic=TopicTest, brokerName=broker-a, queueId=1], queueOffset=681]
[02-06 15:08:53 990] NettyClientPublicExecutor_1 INFO MQProducer - MQ: 生产者发送消息 SendResult [sendStatus=SEND_OK, msgId=C0A81E55346018B4AAC21CFFEB430009, offsetMsgId=C0A8386500002A9F0000000000081AB2, messageQueue=MessageQueue [topic=TopicTest, brokerName=broker-a, queueId=2], queueOffset=683]
[02-06 15:08:53 990] NettyClientPublicExecutor_3 INFO MQProducer - MQ: 生产者发送消息 SendResult [sendStatus=SEND_OK, msgId=C0A81E55346018B4AAC21CFFEB400002, offsetMsgId=C0A8386500002A9F0000000000081579, messageQueue=MessageQueue [topic=TopicTest, brokerName=broker-a, queueId=3], queueOffset=681]
[02-06 15:08:53 990] NettyClientPublicExecutor_2 INFO MQProducer - MQ: 生产者发送消息 SendResult [sendStatus=SEND_OK, msgId=C0A81E55346018B4AAC21CFFEB3A0000, offsetMsgId=C0A8386500002A9F00000000000813FB, messageQueue=MessageQueue [topic=TopicTest, brokerName=broker-a, queueId=1], queueOffset=679]
[02-06 15:08:53 991] ConsumeMessageThread_1 INFO MQPushConsumer - MQ：消费者接收新信息: C0A81E55346018B4AAC21CFFEB400001 TopicTest TagTest Key1 Hello RocketMQ 1
[02-06 15:08:53 990] ConsumeMessageThread_3 INFO MQPushConsumer - MQ：消费者接收新信息: C0A81E55346018B4AAC21CFFEB400002 TopicTest TagTest Key2 Hello RocketMQ 2
[02-06 15:08:53 998] ConsumeMessageThread_2 INFO MQPushConsumer - MQ：消费者接收新信息: C0A81E55346018B4AAC21CFFEB400003 TopicTest TagTest Key3 Hello RocketMQ 3
[02-06 15:08:54 007] ConsumeMessageThread_9 INFO MQPushConsumer - MQ：消费者接收新信息: C0A81E55346018B4AAC21CFFEB430008 TopicTest TagTest Key8 Hello RocketMQ 8
[02-06 15:08:54 010] ConsumeMessageThread_5 INFO MQPushConsumer - MQ：消费者接收新信息: C0A81E55346018B4AAC21CFFEB430005 TopicTest TagTest Key5 Hello RocketMQ 5
[02-06 15:08:54 010] ConsumeMessageThread_6 INFO MQPushConsumer - MQ：消费者接收新信息: C0A81E55346018B4AAC21CFFEB430009 TopicTest TagTest Key9 Hello RocketMQ 9
[02-06 15:08:54 010] ConsumeMessageThread_7 INFO MQPushConsumer - MQ：消费者接收新信息: C0A81E55346018B4AAC21CFFEB430006 TopicTest TagTest Key6 Hello RocketMQ 6
[02-06 15:08:54 011] ConsumeMessageThread_8 INFO MQPushConsumer - MQ：消费者接收新信息: C0A81E55346018B4AAC21CFFEB430004 TopicTest TagTest Key4 Hello RocketMQ 4
[02-06 15:08:54 011] ConsumeMessageThread_10 INFO MQPushConsumer - MQ：消费者接收新信息: C0A81E55346018B4AAC21CFFEB430007 TopicTest TagTest Key7 Hello RocketMQ 7
[02-06 15:09:03 965] Thread-3 INFO MQProducer - MQ：关闭生产者
Disconnected from the target VM, address: '127.0.0.1:52407', transport: 'socket'
[02-06 15:09:03 986] Thread-3 ERROR MQPushConsumer - MQ：关闭消费者

 

转载于:https://my.oschina.net/u/2299686/blog/1618682

chubishi4192
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
springboot集成rocketmq
猴子哥哥的博客
02-17 1314
  本文是springboot集成rocketmq的入门篇，主要介绍单机环境下安装rocketmq，并集成到springboot框架中，实现字符串类型消息的生产和消费。   1）高可用集群部署方案请参考 待更新。。。   2）更多使用方式请参考 待更新。。。 一、下载、安装、启动 1、下载 http://rocketmq.apache.org/dowloading/releases/ 2、安装 ...
RocketMQ2环境搭建（Linux）+springboot+netty+rocketmq测试
zhuhaoyu6666的博客
06-16 702
简介 阿里出品，性能高但可视化页面太low，商用的的话，要求真正的懂她（阿里有商用版，在阿里云可以购买） 集群支持 　　RocketMQ天生对集群的支持非常友好 单Master： 优点：除了配置简单没什么优点 缺点：不可靠，该机器重启或宕机，将导致整个服务不可用 多Master： 优点：配置简单，性能最高 缺点：可能会有少量消息丢失（配置相关），单台机器重启或宕机期间，该机器下未被消费的消息在机器恢复前不可订阅，影响消息实时性 多Master多Slave异步模式： 　　每个Maste...
springboot+netty+rocketMq
qq_34461127的博客
11-09 308
springboot集成netty集成mq，处理大数据量消息
SpringBoot - 快速入门（SpringBoot 1.5.9.RELEASE为例）
OneFine的技术博客
05-24 4669
SpringBoot 1.5.9.RELEASE为例
SpringBoot整合Rocketmq
fengchengwu2012的博客
06-16 496
1、linux安装rocketmq，官网下载安装包
rocketMQ系列(三): springboot整合rocketMQ
御前两把刀的专栏
03-07 620
在第二篇我们已经部署好了一个服务mqbroker.cmd -n localhost:9876 ，在此基础上，我们来做一个springboot的demo示例 网上很多有整合rocketmq的,但是部分没有使用官方rocketmq-spring-boot-starter,因为官方start是近几年出的,使用起来很简单,但是要注意版本之间的对应关系，好了，下面直接介绍整合步骤吧。 一、建立maven工程 不多说了，看看作者的工程目录 二、在pom文件里面添加依赖 <project xml..
RocketMQ快速入门整合SpringBoot
xxxxu5811的博客
04-21 2167
最近接触到的一个项目有用到RocketMQ需要整合SpringBoot，因为之前没有用过（只是用RabbitMQ），所有特地学习记录一下。本文主要是对RocketMQ做简单介绍（一些基本概念），以及对SpringBoot的整合还有整合过程中遇到的一些问题做一个记录。 一、RocketMQ介绍及基本概念 1.1介绍 RocketMQ 是阿里巴巴开源的队列模型的消息中间件，具有高性能、高可靠、高实时、分布式特点。我们需要先对他的一些基本概念有所了解，即Producer、Consumer、Broker、NameS
shop:SpringBoot Dubbo RocketMQ订单支付系统
03-11
应用技术: SpringBoot Mybatis Dubbo RocketMQ Zookeeper MySQL 应用工具: Twitter-Snowflake RestTemplate 注意事项： 1. mybatis 逆向工程数据表名字不能太通用,容易引起于系统表名冲突 正例: shop_user ...
springboot系列教程（二十）：springboot整合RocketMQ，实现请求异步处理
最新发布
07-23
springboot整合RocketMQ，实现请求异步处理
商城秒杀项目，基于springboot开发，使用redis和rocketmq技术增加高并发能力
02-16
在这个项目中，我们选择了SpringBoot作为主要的开发框架，利用Redis和RocketMQ来提升系统的并发性能，下面将详细阐述这三个核心组件在系统中的作用和实现方式。 1. SpringBoot简介 SpringBoot是Spring框架的简化版...
RocketMQ（一）—— 基本使用
weixin_56697114的博客
12-01 2350
1、RocketMQ基本使用 1、启动 1.启动NameServer # 1.启动NameServer nohup sh bin/mqnamesrv & # 2.查看启动日志 tail -f ~/logs/rocketmqlogs/namesrv.log 2.启动Broker # 1.启动Broker nohup sh bin/mqbroker -n localhost:9876 & # 2.查看启动日志 tail -f ~/logs/rocketmqlogs/broker
RocketMQ笔记-springboot整合
zhanglisheng2122的博客
09-02 147
Springboot整合RocketMQ 导入pom依赖 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-dependencies</artifactId> <version>2.2.0.RELEASE</version> </parent>
Spring boot实战项目整合阿里云RocketMQ （非开源版）消息队列实现发送普通消息，延时消息 --附代码...
08-17 1504
一.为什么选择RocketMQ消息队列？ 首先RocketMQ是阿里巴巴自研出来的，也已开源。其性能和稳定性从双11就能看出来，借用阿里的一句官方介绍：历年双 11 购物狂欢节零点千万级 TPS、万亿级数据洪峰，创造了全球最大的业务消息并发以及流转纪录（日志类消息除外）； 在始终保证高性能前提下，支持亿级消息堆积，不影响集群的正常服务，在削峰填谷（蓄洪）、微服务解耦的场景下尤为...
springboot整合使用rocketMq
热门推荐
congge
09-11 3万+
前文，我们讲述了rocketMq的基本使用，接下来聊聊如何使用springboot整合使用rocketMq; 1)新建maven工程，工程结构目录如图： constants包下存放着常量信息，这里保存的是自定义的错误码，为将被异常类调用， consumer包下存放的是消费者相关的配置，一个文件是消费者的配置，用于APP启动的时候全局注册，一个文件为消费者端的监听器，用于监听生产者发送过来...
springboot整合RocketMQ
Cui6023056的博客
03-27 5065
springboot整合RocketMQ RocketMQ是由阿里巴巴研发，后捐献给Apache软件基金会，正式成为孵化项目。 为什么要使用RocketMQ RocketMQ介绍 参考文档： https://www.jianshu.com/p/2ae8e81718d3 https://www.jianshu.com/nb/23512122 RocketMQ本地部署 1：官方下载:http://...
springboot+RocketMQ实现（生产者和消费者）
zhoupan2008的专栏
03-15 7002
1）pom配置 <dependency> <groupId>org.apache.rocketmq</groupId> <artifactId>rocketmq-client</artifactId> <version>4.3.0</version> </dependenc...
SpringBoot与RocketMQ客户端集成原理解读与示例
weixin_33800463的博客
11-13 296
本文将对rocktmq-spring-boot的设计实现做一个简单的介绍，读者可以通过本文了解将RocketMQ Client端集成为spring-boot-starter框架的开发细节，然后通过一个简单的示例来一步一步的讲解如何使用这个spring-boot-starter工具包来配置，发送和消费RocketMQ消息。该项目git地址：https://...
【SpringBoot框架篇】22.集成RocketMQ实现消息发布和订阅
皓亮君的博客
08-09 5033
集成RocketMQ实现消息的发布和订阅
RocketMQ4.0源码分析之-消息消费管理
binzhaomobile的博客
07-12 3319
RocketMQ4.0源码分析之-消息消费管理 一 前言 如果横向比较RocketMQ中的各功能模块哪个最复杂，消息消费管理模块无疑是胜者。 导致消息消费管理模块复杂度高的原因主要有以下几点： 1)    RocketMQ支持在线扩容和缩容，Broker或Consumer的数量变化后需要进行动态负载均衡。 2)    RocketMQ支持三个不同维度上进行分类的消费模式：广播消费/集群消
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值