自定义对rocketmq生产者以及消费者的封装

已于 2023-07-26 19:22:52 修改
阅读量2.6k 收藏 3
点赞数 2
文章标签： java 个人开发 rabbitmq 分布式 java-ee
于 2022-05-25 10:04:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51681531/article/details/124960116
版权

一. 生产者抽象类

package com.canxiusi.common.service.customize_mq.producer;

import com.canxiusi.common.service.customize_mq.constant.MqConstant;
import com.canxiusi.common.service.exception.SystemException;
import com.canxiusi.common.service.exception.enums.CommonExceptionEnum;
import com.canxiusi.common.service.log4j2.spi.Logger;
import com.canxiusi.common.service.log4j2.spi.LoggerFactory;
import com.canxiusi.common.service.utils.LogUtils;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.exception.RemotingException;

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

/**
 * @author canxiusi.yan
 * @description AbstractMqProducer 抽象SysLog生产者, 父类定义在common模块
 * @date 2022/5/8 19:46
 */
public abstract class AbstractSysLogProducer {

    /**
     * 日志
     */
    private static final Logger logger = LoggerFactory.getLogger(AbstractSysLogProducer.class);

    private DefaultMQProducer sysLogProducer;

    /**
     * 初始化mq生产者
     */
    @PostConstruct
    public void initProducer() {
        sysLogProducer = new DefaultMQProducer(getProducerGroup());
        sysLogProducer.setNamesrvAddr(getNameServer());
        sysLogProducer.setInstanceName(getInstanceName());
        try {
            sysLogProducer.start();
            logger.info(LogUtils.format("[SysLog生产者初始化完成], producer=<{0}>", sysLogProducer));
        } catch (MQClientException e) {
            logger.error("[SysLog生产者初始化失败]", e);
            System.exit(-1);
        }
    }

    @PreDestroy
    public void closeProducer() {
        sysLogProducer.shutdown();
    }

    /**
     * 发送日志单向消息
     *
     * @param bytes
     */
    public void sendMsgByteOneway(byte[] bytes) {
        if (bytes.length > MqConstant.MAX_MB) {
            logger.error(LogUtils.format("[发送消息过大, 无法发送!], msg=<{0}>", new String(bytes)));
            throw new SystemException(CommonExceptionEnum.PARAM_ERROR, "[sendMsgByteOneway] 发送消息大于4MB!");
        }
        Message message = new Message(getTopic(), getTag(), bytes);
        try {
            sysLogProducer.sendOneway(message);
        } catch (MQClientException | RemotingException | InterruptedException e) {
            logger.error(LogUtils.format("线程<{0}>, 生产者=<{1}>发送单向消息出错",
                    Thread.currentThread().getName(), this.getClass().getSimpleName()), e);
        }
    }

    /**
     * 获取mq地址
     *
     * @return
     */
    protected abstract String getNameServer();

    /**
     * 获取日志生产者
     *
     * @return
     */
    protected abstract String getProducerGroup();

    /**
     * 获取实例名
     *
     * @return
     */
    protected abstract String getInstanceName();

    /**
     * 获取topic
     *
     * @return
     */
    protected abstract String getTopic();

    /**
     * 获取tags
     *
     * @return
     */
    protected abstract String getTag();

}

二. 生产者子类实现

package com.canxiusi.web.online.producer;

import com.canxiusi.common.service.customize_mq.config.SysLogMqConfig;
import com.canxiusi.common.service.customize_mq.producer.AbstractSysLogProducer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * @author canxiusi.yan
 * @description SysLogProducerInstance 日志落入DB消费者
 * @date 2022/5/10 14:52
 */
@Component
public class SysLogProducer extends AbstractSysLogProducer {

    @Autowired
    private SysLogMqConfig sysLogMqConfig;

    @Override
    protected String getNameServer() {
        return sysLogMqConfig.getNameServerAddress();
    }

    @Override
    protected String getProducerGroup() {
        return sysLogMqConfig.getProducerGroup();
    }

    @Override
    protected String getInstanceName() {
        return sysLogMqConfig.getProducerInstance();
    }

    @Override
    protected String getTopic() {
        return sysLogMqConfig.getTopic();
    }

    @Override
    protected String getTag() {
        return sysLogMqConfig.getTag();
    }

}

三. 配置文件bean

package com.canxiusi.common.service.customize_mq.config;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

/**
 * @author canxiusi.yan
 * @description SysLogMqConfig 日志mq配置bean
 * @date 2022/5/15 11:08
 */
@Data
@Configuration
@PropertySource("classpath:syslogmq.properties")
@ConfigurationProperties(prefix = "syslog")
public class SysLogMqConfig {

    private String nameServerAddress;

    private String producerGroup;

    private String producerInstance;

    private String consumerGroup;

    private String consumerDbGroup;

    private String consumerMongoGroup;

    private String consumerDbInstance;

    private String consumerMongoInstance;

    private String topic;

    private String tag;

    private String dbTopic;

    private String mongoTag;

}

四. 消费者抽象实现

package com.canxiusi.common.service.customize_mq.consumer;

import com.canxiusi.common.service.entity.logs.SysOperateLog;
import com.canxiusi.common.service.log4j2.spi.Logger;
import com.canxiusi.common.service.log4j2.spi.LoggerFactory;
import com.canxiusi.common.service.utils.JsonUtil;
import com.canxiusi.common.service.utils.LogUtils;
import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
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.springframework.boot.context.event.ApplicationPreparedEvent;
import org.springframework.context.event.EventListener;
import org.springframework.util.CollectionUtils;

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

/**
 * @author canxiusi.yan
 * @description AbstractProducer 抽象SysLog抽象父类
 * @date 2022/5/10 10:03
 */
public abstract class AbstractSysLogConsumer {

    /**
     * 子类通用日志
     */
    protected static final Logger logger = LoggerFactory.getLogger(AbstractSysLogConsumer.class);

    private DefaultMQPushConsumer consumer;

    /**
     * 初始化mq消费者
     */
    @PostConstruct
    public void initConsumer() {
        consumer = new DefaultMQPushConsumer(getConsumerGroup());
        consumer.setNamesrvAddr(getNameServer());
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_LAST_OFFSET);
        consumer.setMessageModel(MessageModel.BROADCASTING);
        consumer.setInstanceName(getInstanceName());
        consumer.setPullInterval(2000);
        consumer.setPullBatchSize(500);
        try {
            consumer.subscribe(getTopic(), getTag());
        } catch (MQClientException e) {
            logger.error("[SysLog消费者初始化异常]", e);
            System.exit(-1);
        }
        consumer.registerMessageListener((MessageListenerConcurrently) (msgs, context) -> {
            if (CollectionUtils.isEmpty(msgs)) {
                logger.info(LogUtils.format("[消息列表为空], msgs=<{0}>", msgs));
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
            for (MessageExt msg : msgs) {
                try {
                    handlerMsg(msg);
                } catch (Exception e) {
                    logger.error("[日志消费处理异常]", e);
                }
            }
            return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
        });
        logger.info(LogUtils.format("[SysLog消费者初始化完成], consumer=<{0}>", consumer));
    }

    /**
     * 启动消费者
     *
     * @param event
     */
    @EventListener(ApplicationPreparedEvent.class)
    public void startSysLogConsumer(ApplicationPreparedEvent event) {
        try {
            consumer.start();
        } catch (MQClientException e) {
            logger.error(LogUtils.format("[SysLog消费者start异常], nameServerAddress={}", getNameServer()), e);
            System.exit(-1);
        }
    }

    @PreDestroy
    public void closeConsumer() {
        consumer.shutdown();
    }

    /**
     * 调用子类去消费消息
     *
     * @param msg
     */
    protected final void handlerMsg(MessageExt msg) {
        SysOperateLog sysOperateLog;
        try {
            sysOperateLog = JsonUtil.readValue(msg.getBody(), SysOperateLog.class);
        } catch (Exception e) {
            logger.error("[字节消息转换出错]", e);
            throw e;
        }
        handlerLogs(sysOperateLog);
    }

    /**
     * 子类处理消息
     *
     * @param sysOperateLog
     */
    protected abstract void handlerLogs(SysOperateLog sysOperateLog);

    /**
     * 获取mq地址
     *
     * @return
     */
    protected abstract String getNameServer();

    /**
     * 获取系统日志消费者组, 消费者也可以在同一分组, 子类重写获取不同的分组
     *
     * @return
     */
    protected abstract String getConsumerGroup();

    /**
     * 获取消费者实例名称
     *
     * @return
     */
    protected abstract String getInstanceName();

    /**
     * 获取消费者topic
     *
     * @return
     */
    protected abstract String getTopic();

    /**
     * 获取消费者tag
     *
     * @return
     */
    protected abstract String getTag();

}

五. 消费者子类实现:

5.1 模拟mysql消费者

package com.canxiusi.web.service.consumer;

import com.canxiusi.common.service.customize_mq.config.SysLogMqConfig;
import com.canxiusi.common.service.customize_mq.consumer.AbstractSysLogConsumer;
import com.canxiusi.common.service.entity.logs.SysOperateLog;
import com.canxiusi.common.service.log4j2.spi.Logger;
import com.canxiusi.common.service.log4j2.spi.LoggerFactory;
import com.canxiusi.common.service.utils.LogUtils;
import com.canxiusi.web.service.mapper.operate.SysOperateLogMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * @author canxiusi.yan
 * @description SysLogsConsumer 日志消费者, 监听系统日志
 * @date 2022/5/10 11:07
 */
@Component
public class SysLogDbConsumer extends AbstractSysLogConsumer {

    /**
     * 日志
     */
    private static final Logger logger = LoggerFactory.getLogger(SysLogDbConsumer.class);

    @Autowired
    private SysLogMqConfig sysLogMqConfig;

    @Autowired
    private SysOperateLogMapper operateLogMapper;

    @Override
    protected void handlerLogs(SysOperateLog sysOperateLog) {
        logger.info(LogUtils.format("当前线程<{0}>, <{1}>消费了消息, sysLog=<{2}>",
                Thread.currentThread().getName(), this.getClass().getSimpleName(), sysOperateLog));
        operateLogMapper.insertSelective(sysOperateLog);
    }

    @Override
    protected String getNameServer() {
        return sysLogMqConfig.getNameServerAddress();
    }

    @Override
    protected String getConsumerGroup() {
        return sysLogMqConfig.getConsumerGroup();
    }

    @Override
    protected String getInstanceName() {
        return sysLogMqConfig.getConsumerDbInstance();
    }

    @Override
    protected String getTopic() {
        return sysLogMqConfig.getTopic();
    }

    @Override
    protected String getTag() {
        return sysLogMqConfig.getTag();
    }

}

5.2 模拟mongo消费者

package com.canxiusi.web.service.consumer;

import com.canxiusi.common.service.customize_mq.config.SysLogMqConfig;
import com.canxiusi.common.service.customize_mq.consumer.AbstractSysLogConsumer;
import com.canxiusi.common.service.entity.logs.SysOperateLog;
import com.canxiusi.common.service.log4j2.spi.Logger;
import com.canxiusi.common.service.log4j2.spi.LoggerFactory;
import com.canxiusi.common.service.utils.LogUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * @author canxiusi.yan
 * @description SysLogMongoConsumer
 * @date 2022/5/10 20:47
 */
@Component
public class SysLogMongoConsumer extends AbstractSysLogConsumer {

    private static final Logger logger = LoggerFactory.getLogger(SysLogMongoConsumer.class);

    @Autowired
    private SysLogMqConfig sysLogMqConfig;

    @Override
    protected void handlerLogs(SysOperateLog sysOperateLog) {
        logger.info(LogUtils.format("当前线程<{0}>, <{1}>消费了消息, sysLog=<{2}>",
                Thread.currentThread().getName(), this.getClass().getSimpleName(), sysOperateLog));
    }

    @Override
    protected String getNameServer() {
        return sysLogMqConfig.getNameServerAddress();
    }

    @Override
    protected String getConsumerGroup() {
        return sysLogMqConfig.getConsumerGroup();
    }

    @Override
    protected String getInstanceName() {
        return sysLogMqConfig.getConsumerMongoInstance();
    }

    /**
     * 一个topic, 用tags来区分
     *
     * @return
     */
    @Override
    protected String getTopic() {
        return sysLogMqConfig.getTopic();
    }

    @Override
    protected String getTag() {
        return sysLogMqConfig.getTag();
    }

}

六. 具体发送消息实例

6.1 默认的异步发送

        如果使用 RocketMQ 默认的异步 Producer, 首先我们需要使用 producer 的 send() 方法, 接收一个 sendCallback 回调

sysLogProducer.send(message, new SendCallback() {
                @Override
                public void onSuccess(SendResult sendResult) {

                }

                @Override
                public void onException(Throwable e) {

                }
            });

        查看源码发现, 在发送消息的时候使用了线程池开启了异步, 如果自己没有不定义线程池的话, mq会使用默认的线程池(不适用), 所以需要一定要根据自己业务场景, 定义线程池, 然后通过下面的方法把线程池设置进去

public void setAsyncSenderExecutor(final ExecutorService asyncSenderExecutor) {
        this.defaultMQProducerImpl.setAsyncSenderExecutor(asyncSenderExecutor);
    }
public void send(final Message msg, final SendCallback sendCallback, final long timeout)
        throws MQClientException, RemotingException, InterruptedException {
        final long beginStartTime = System.currentTimeMillis();
        ExecutorService executor = this.getAsyncSenderExecutor();
        try {
            executor.submit(new Runnable() {
                @Override
                public void run() {
                    long costTime = System.currentTimeMillis() - beginStartTime;
                    if (timeout > costTime) {
                        try {
                            sendDefaultImpl(msg, CommunicationMode.ASYNC, sendCallback, timeout - costTime);
                        } catch (Exception e) {
                            sendCallback.onException(e);
                        }
                    } else {
                        sendCallback.onException(
                            new RemotingTooMuchRequestException("DEFAULT ASYNC send call timeout"));
                    }
                }

            });
        } catch (RejectedExecutionException e) {
            throw new MQClientException("executor rejected ", e);
        }

    }

6.2 自定义异步发送

        上面的 send() 方法的效率不高, 因为他需要一个 sendCallback 回调, 对于日志场景, 我们不关心回调, 所以可以使用效率更高的 sendOnway() 方法, 但是查看源码发现, 这个方法没有开启线程实现异步, 针对这一点可以实现自定义异步发送

        我这里是配合spring事件监听机制以及策略模式又做了一层解耦合, 把消息的构建和发送消息的逻辑分离开, 而且使用了异步, 在调用 doSpecificHandler() 方法之前就开启了异步, 这样的话就实现了构建字节消息, 发送消息的异步, 如果使用 6.1 的默认异步方式, 构建字节消息并不是在异步中实现的

        首先是使用线程池开启异步

    @Override
    public void asyncExecuteIgnoreResult(String routingKey, FlowContext context) {
        Strategy strategy = FlowExecutor.getStrategy(routingKey);
        try {
            threadPoolExecutor.execute(() -> strategy.doSpecificHandler(null, context));
        } catch (Throwable e) {
            logger.error(LogUtils.format("[asyncExecuteIgnoreResult 线程调度任务出现错误或异常], routingKey={0}, obj={1}",
                    routingKey, e.toString()), e);
        }
    }

        然后使用策略模式, 找到具体的策略实现类, 构建字节消息, 装配 sysLogProducer 对象, 调用 sendMsgByteOneway () 方法发送单向消息

/**
 * @author canxiusi.yan
 * @description SysLogsEventSender 日志消息发送器
 * @date 2022/5/3 10:03
 */
@Component
@StrategyAnno(routingKey = EventConstant.SYS_LOG_SENDER, weight = "10010")
public class SysLogEventSender implements Strategy {

    /**
     * 日志
     */
    private static final Logger logger = LoggerFactory.getLogger(SysLogEventSender.class);

    @Autowired
    private SysLogProducer sysLogProducer;

    @Override
    public void doSpecificHandler(Flow flow, FlowContext flowContext) {
        long now = System.currentTimeMillis();
        // 获取不为null的sysLog
        SysOperateLog operateLog = Optional.ofNullable(
                        ExecuteDataHelper.getParam(flowContext.getGlobalMap(), CommonMapParam.SYS_LOG_LOG))
                .orElse(new SysOperateLog());
        // 构建字节消息
        byte[] bytes = JsonUtil.toJsonAsBytes(operateLog);
        // 发送mq消息
        sysLogProducer.sendMsgByteOneway(bytes);
        long end = System.currentTimeMillis();
        logger.info(LogUtils.format("当前线程<{0}>, <{1}>发送消息, flowContext=<{2}>, 耗时=<{3}>毫秒",
                Thread.currentThread().getName(),
                this.getClass().getSimpleName(),
                flowContext.getGlobalMap(),
                end - now));
    }
    
}

七. 运行测试

7.1 生产者发送消息测试

        首先是生产者发送消息(消息内容可以忽略, 模拟的), 这里我自定了线程工厂和线程名称, 可以看到线程已经不再是 tomcat 默认分配的 http-nio-端口号, 而是我使用线程池开启的新线程

7.2 消费者消费消息测试 

        消费者消费消息情况, 可以看到两个消费者都消费了消息, 并且是异步消费, 但是这个线程是由 rocketmq 内部产生的

八. 登录控制台查看

        这里模拟的场景是发送一条消息被2个消费者消费        

canxiusi
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
rocketmq-spring-boot-starter:RocketMQ客户端封装类，基于最新版本4.5.2
05-26
spring boot starter for RocketMQ 项目介绍 是由阿里巴巴团队开发并捐赠给apache团队的优秀消息中间件，目前已经是apache的顶级项目之一，承受过历年双十一大促的考验。 你可以通过本项目轻松的集成Rocketmq到你的SpringBoot项目中。 本项目主要包含以下特性 同步发送消息 异步发送消息 广播发送消息 有序发送和消费消息 发送延时消息 消息tag和key支持 自动序列化和反序列化消息体 发送事务消息(NEW) ... 简单入门实例 模块介绍： rocketmq-spring-boot-starter：组件的依赖入口 rocketmq-spring-boot-autoconfigure： 自动配置模块 rocketmq-spring-boot-app：Demo示例，里面包含了最基本功能的用法 1. 添加maven依赖： <de
操作系统生产者——消费者模拟程序
12-17
关键在于如何确保生产者不会在缓冲区满时继续生产，以及消费者不会在缓冲区空时尝试消费，以避免死锁或数据丢失的情况。 在描述中提到的"两个线程里创建独立的定时器"，这是解决生产者-消费者问题的一种策略。独立...
RocketMQ 生产者与消费者的封装
Somhu的博客
06-01 5606
一、抽象消费类封装： public abstract class Consumer { protected final Logger logger = LoggerFactory.getLogger(getClass()); protected DefaultMQPushConsumer defaultMQPushConsumer; @Value("${rocket...
模仿 ONS 封装 RocketMQ SDK
最新发布
BASK2311的博客
05-06 449
我并不认为我们写得多么的好，只是想让同学们理解：1、成长的第一步就是模仿；2、把开发者当用户，以用户的体验为先。我经常去阅读阿里云产品的 SDK , 去思考他们为什么这么设计， 为什么和开源的有所不同，有的时候开始没想明白，但模仿得多了，好像也慢慢懂了。要紧的是果敢地迈出第一步，对与错先都不管，自古就没有把一切都设计好再开步的事。别想把一切都弄清楚，再去走路。鲁莽者要学会思考，善思者要克服的是犹豫。——史铁生。
RocketMQ5.0.0消息消费＜一＞ _ PUSH模式的消息拉取
爱我所爱0505
03-05 1346
本章节介绍消费者订阅主题及消费者启动后，PUSH模式下的消息拉取机制。PUSH模式是基于拉模式的，消费者周期执行拉取消息任务。同时介绍了消息拉取长轮询机制，Broker的两种处理方式。
RocketMQ与SpringBoot整合进行生产级二次封装
TianXinCoord的博客
06-19 3363
零、文章前言说明 主要使用参考第二节 核心使用参考第一篇文章 一、为什么要二次封装 首先明确一点：不进行二次封装完全不影响RocketMQ的使用，可以选择二次封装和不选择二次封装 二次封装可以提供更多...
真香，聊聊 RocketMQ 5.0 的 POP 消费模式！
zjj2006的专栏
05-21 1279
POP 客户端有很多的优势，总结如下：无状态，更好地拥抱云原生；计算相关的功能下移到 Proxy，更加轻量级；消费能力扩展不受 MessageQueue 数量的限制；消费者 hang 住，并不会导致消息积压。
JAVA核心知识-实战 RocketMQ 流量削峰
BAOZEBING的博客
05-04 1401
作者：WilsonHe juejin.im/post/5ea159e4f265da47f0794da5 前言 MQ的主要特点为解耦、异步、削峰，该文章主要记录与分享个人在实际项目中的RocketMQ削峰用法，用于减少数据库压力的业务场景，其中RocketMQ的核心组件概念如下： Producer：生产发送消息 Broker：存储Producer发送过来的消息 Consumer：从Broker拉...
C#自定义缓存封装类实例
12-26
本文实例讲述了C#自定义缓存封装类。分享给大家供大家参考。具体如下： 这个自定义的C#类封装了部分常用的缓存操作，包括写入缓存，读取缓存，设置缓存过期时间等等，简化了C#的缓存操作，代码非常简单，易于阅读。 ...
Android自定义封装banner组件
01-20
自定义封装 banner 组件，供大家参考，具体内容如下 1. 效果图预览  2.基本功能 一个简单方便的轮播图组件，基于viewpager 基础上进行的封装。 可设置 项目中图片，网络图片， View； 支持循环自动播放，手势滑动...
rocketmq-console已封装ACL
02-28
1支持开启控制台登录验证 2支持ACL 3支持docker部署
Python-rocketmqpython是一个基于rocketmqclientcpp封装的RocketMQPython客户端
08-10
rocketmq-python 是一个基于 rocketmq-client-cpp 封装的 RocketMQ Python 客户端
golang版本的RabbitMQ消息订阅的封装,多生产者多消费者。
04-14
golang版本的RabbitMQ消息订阅的封装，可以多个生产者，多个消息订阅者，每个队列可以创建多个协程处理; 可能有些消费者需求需要分布式部署，那需要指定队列名，并且需要设置队列持久化，以及排他性QueueDeclare....
RocketMQ源码解析：消息拉取和消费流程
小识的博客
11-13 2239
消息消费总览 RocketMQ消息消费有两种模式，顺序消费和并发消费。顺序消费在工作中几乎没遇到过，所以就不分析这方面的源码了，单纯分析并发消费。 并发消费实现MessageListenerConcurrently接口即可，顺序消费实现MessageListenerOrderly接口 public class Consumer { public static void main(String[] args) throws InterruptedException, MQClientExcept.
RocketMQ5.0.0消息消费＜三＞ _ 消息消费
爱我所爱0505
03-14 493
本章节介绍PUSH模式下的消息拉取及负载均衡后的消息消费。消费线程池消费消息失败后，进行消息ACK确认，进入重新消息队列。消息成功后，根据广播/集群模式更新消费进度。
【Spring Boot 集成应用】RocketMQ的集成用法（上）
热门推荐
Mirson - 多一些分享, 多一些进步
07-31 2万+
在金融互联网领域广泛应用，在阿里双11活动经历过多次考验， 经过严苛的生产验证，有比较高的可靠性，在数据处理上有比较高的稳定性， 能从最大程度上保证消息不易丢失，如果业务上有一定的规模， 且对数据的一致性，稳定性要求严苛， 那么可以采用RocketMQ， 比如金融互联网领域， 支付场景、交易场景等。如果有借助消息队列实现分布式事务， RocketMQ可以作为首选。...
RocketMQ5.0
远赴星河
02-09 1579
RocketMQ学习案例分享
RocketMq案例，生产者，消费者，消息订阅
涂作权的博客
10-24 1万+
1、RocketMq集群配置参考：http://blog.csdn.net/tototuzuoquan/article/details/78314572使用的rocketmq的ip等是上面博文提及的ip等内容2、创建RocketMq工程工程目录结构如下： 3、编写pom.xml文件<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http
生产者消费者java
09-20
生产者消费者模式是一种常见的并发编程模型，用于解决生产者和消费者之间的数据交互问题。在Java中，可以使用多种方式实现生产者消费者模式，例如使用wait()和notify()方法、使用阻塞队列（如ArrayBlockingQueue、LinkedBlockingQueue）等。 在使用wait()和notify()方法的方式中，生产者通过synchronized关键字来获取锁，当生产者生产数据后，调用notify()方法通知消费者消费数据，并释放锁。而消费者在获取锁后，如果发现没有数据可供消费，则调用wait()方法等待，直到被生产者唤醒。这种方式需要手动管理线程的等待和唤醒，需要注意避免死锁和虚假唤醒的问题。 使用阻塞队列的方式可以简化生产者消费者模式的实现。生产者将数据放入阻塞队列中，而消费者从阻塞队列中取出数据进行消费。阻塞队列内部已经封装了线程安全和等待唤醒的逻辑，可以有效地避免死锁和虚假唤醒的问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值