rocketmq-client-java 5.x PushConsumer

最新推荐文章于 2024-09-02 10:05:07 发布
最新推荐文章于 2024-09-02 10:05:07 发布
阅读量1.1k 收藏
点赞数 1
文章标签： java java-rocketmq rocketmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Confused_Tom_Cat/article/details/129999866
版权

消费者概述及创建过程

使用方式

在消费者初始化时注册一个消费监听器，并在消费监听器内部实现消息处理逻辑。由消息队列RocketMQ版的SDK在后台完成消息获取、触发监听器调用以及进行消息重试处理。

	//消费示例：使用PushConsumer消费普通消息。
	ClientServiceProvider provider = ClientServiceProvider.loadService();
    String topic = "Your Topic";
    FilterExpression filterExpression = new FilterExpression("Your Filter Tag", FilterExpressionType.TAG);
    PushConsumer pushConsumer = provider.newPushConsumerBuilder()
            //设置消费者分组。
            .setConsumerGroup("Your ConsumerGroup")
            //设置接入点。
            .setClientConfiguration(ClientConfiguration.newBuilder().setEndpoints("Your Endpoint").build())
            //设置预绑定的订阅关系。
            .setSubscriptionExpressions(Collections.singletonMap(topic, filterExpression))
            //设置消费监听器。
            .setMessageListener(new MessageListener() {
                @Override
                public ConsumeResult consume(MessageView messageView) {
                    //消费消息并返回处理结果。
                    return ConsumeResult.SUCCESS;
                }
            })
            .build();

PushConsumer的消费监听器执行结果分为以下三种情况：

  • 返回消费成功：以Java SDK为例，返回ConsumeResult.SUCCESS，表示该消息处理成功，服务端按照消费结果更新消费进度。
  • 返回消费失败：以Java SDK为例，返回ConsumeResult.FAILURE，表示该消息处理失败，需要根据消费重试逻辑判断是否进行重试消费。
  • 出现非预期失败：例如抛异常等行为，该结果按照消费失败处理，需要根据消费重试逻辑判断是否进行重试消费。

PushConsumer消费消息时，若消息处理逻辑出现预期之外的阻塞导致消息处理一直无法执行成功，SDK会按照消费超时处理强制提交消费失败结果，并按照消费重试逻辑进行处理。

消费重试

消费重试
在这里插入图片描述
在这里插入图片描述

PushConsumer初始化

startUp(): 实例初始化方法

    protected void startUp() throws Exception {
        try {
            log.info("Begin to start the rocketmq push consumer, clientId={}", clientId);
            GaugeObserver gaugeObserver = new ProcessQueueGaugeObserver(processQueueTable, clientId, consumerGroup);
            this.clientMeterManager.setGaugeObserver(gaugeObserver);
            // 启动客户端的通用方法，生产者和SimpleConsumer也会调用super.startUp方法，如果想了解具体过程可以看最上面的那个链接
            super.startUp();
            final ScheduledExecutorService scheduler = this.getClientManager().getScheduler();
            // 创建ConsumeService对象，持有消费消息MessageListener
            this.consumeService = createConsumeService();
            // 定期拉取消息并消费
            scanAssignmentsFuture = scheduler.scheduleWithFixedDelay(() -> {
                try {
                    scanAssignments();
                } catch (Throwable t) {
                    log.error("Exception raised while scanning the load assignments, clientId={}", clientId, t);
                }
            }, 1, 5, TimeUnit.SECONDS);
            log.info("The rocketmq push consumer starts successfully, clientId={}", clientId);
        } catch (Throwable t) {
            log.error("Exception raised while starting the rocketmq push consumer, clientId={}", clientId, t);
            shutDown();
            throw t;
        }
    }

ConsumeService createConsumeService()

    private ConsumeService createConsumeService() {
        final ScheduledExecutorService scheduler = this.getClientManager().getScheduler();
        if (pushSubscriptionSettings.isFifo()) {
            log.info("Create FIFO consume service, consumerGroup={}, clientId={}", consumerGroup, clientId);
            return new FifoConsumeService(clientId, messageListener, consumptionExecutor, this, scheduler);
        }
        log.info("Create standard consume service, consumerGroup={}, clientId={}", consumerGroup, clientId);
        return new StandardConsumeService(clientId, messageListener, consumptionExecutor, this, scheduler);
    }

void scanAssignments()：拉取消息并消费

 	void scanAssignments() {
        try {
            log.debug("Start to scan assignments periodically, clientId={}", clientId);
            //subscriptionExpressions<topic， 过滤规则>
            for (Map.Entry<String, FilterExpression> entry : subscriptionExpressions.entrySet()) {
                final String topic = entry.getKey();
                final FilterExpression filterExpression = entry.getValue();
                // 获取topic对应的MessageQueue集合，Assignments是对MessageQueue集合的封装
                final Assignments existed = cacheAssignments.get(topic);
                final ListenableFuture<Assignments> future = queryAssignment(topic);
                // 成功后，调用了syncProcessQueue方法
                Futures.addCallback(future, new FutureCallback<Assignments>() {
                    @Override
                    public void onSuccess(Assignments latest) {
                        if (latest.getAssignmentList().isEmpty()) {
                            if (null == existed || existed.getAssignmentList().isEmpty()) {
                                log.info("Acquired empty assignments from remote, would scan later, topic={}, "
                                    + "clientId={}", topic, clientId);
                                return;
                            }
                            log.info("Attention!!! acquired empty assignments from remote, but existed assignments"
                                + " is not empty, topic={}, clientId={}", topic, clientId);
                        }

                        if (!latest.equals(existed)) {
                            log.info("Assignments of topic={} has changed, {} => {}, clientId={}", topic, existed,
                                latest, clientId);
                            syncProcessQueue(topic, latest, filterExpression);
                            cacheAssignments.put(topic, latest);
                            return;
                        }
                        log.debug("Assignments of topic={} remains the same, assignments={}, clientId={}", topic,
                            existed, clientId);
                        // Process queue may be dropped, need to be synchronized anyway.
                        syncProcessQueue(topic, latest, filterExpression);
                    }

                    @Override
                    public void onFailure(Throwable t) {
                        log.error("Exception raised while scanning the assignments, topic={}, clientId={}", topic,
                            clientId, t);
                    }
                }, MoreExecutors.directExecutor());
            }
        } catch (Throwable t) {
            log.error("Exception raised while scanning the assignments for all topics, clientId={}", clientId, t);
        }
    }

ListenableFuture queryAssignment(final String topic)

	ListenableFuture<Assignments> queryAssignment(final String topic) {
		// 获取topic对应的一个endpoints
        final ListenableFuture<Endpoints> future0 = pickEndpointsToQueryAssignments(topic);
        return Futures.transformAsync(future0, endpoints -> {
        	// 封装“查询分配请求”
            final QueryAssignmentRequest request = wrapQueryAssignmentRequest(topic);
            // 请求超时时间
            final Duration requestTimeout = clientConfiguration.getRequestTimeout();
            // 向endpoints发送请求
            final RpcFuture<QueryAssignmentRequest, QueryAssignmentResponse> future1 =
                this.getClientManager().queryAssignment(endpoints, request, requestTimeout);
            return Futures.transformAsync(future1, response -> {
                final Status status = response.getStatus();
                StatusChecker.check(status, future1);
                // Assignment是对MessageQueue的包装
                final List<Assignment> assignmentList = response.getAssignmentsList().stream().map(assignment ->
                    new Assignment(new MessageQueueImpl(assignment.getMessageQueue()))).collect(Collectors.toList());
                final Assignments assignments = new Assignments(assignmentList);
                return Futures.immediateFuture(assignments);
            }, MoreExecutors.directExecutor());
        }, MoreExecutors.directExecutor());
    }

private ListenableFuture pickEndpointsToQueryAssignments(String topic)

获取topic对应的broker集合中的一个broker的endpoint

    private ListenableFuture<Endpoints> pickEndpointsToQueryAssignments(String topic) {
    	// 获取topic对应的路由信息，如果topicRouteCache存在直接返回，如果不存在则请求Proxy获取路由信息
        final ListenableFuture<TopicRouteData> future = getRouteData(topic);
        return Futures.transformAsync(future, topicRouteData -> {
            Endpoints endpoints = topicRouteData.pickEndpointsToQueryAssignments();
            return Futures.immediateFuture(endpoints);
        }, MoreExecutors.directExecutor());
    }

public Endpoints pickEndpointsToQueryAssignments()

通过轮询的方法获取broker对应的endpoints

    public Endpoints pickEndpointsToQueryAssignments() throws NotFoundException {
        int nextIndex = index.getAndIncrement();
        for (int i = 0; i < messageQueueImpls.size(); i++) {
            final MessageQueueImpl messageQueueImpl = messageQueueImpls.get(IntMath.mod(nextIndex++,
                messageQueueImpls.size()));
            final Broker broker = messageQueueImpl.getBroker();
            if (Utilities.MASTER_BROKER_ID != broker.getId()) {
                continue;
            }
            if (Permission.NONE.equals(messageQueueImpl.getPermission())) {
                continue;
            }
            return broker.getEndpoints();
        }
        throw new NotFoundException("Failed to pick endpoints to query assignment");
    }

RpcFuture<QueryAssignmentRequest, QueryAssignmentResponse> queryAssignment(…)

  • Endpoints endpoints: 请求的broker对应的endpoints
  • QueryAssignmentRequest request：查询分配请求
  • Duration duration：请求超时时间
	public RpcFuture<QueryAssignmentRequest, QueryAssignmentResponse> queryAssignment(Endpoints endpoints,
        QueryAssignmentRequest request, Duration duration) {
        try {
            final Metadata metadata = client.sign();
            final Context context = new Context(endpoints, metadata);
            // 获取endpoints对应的RpcClient，缓存在rpcClientTable，如果缓存中没有，新创建并加入缓存中，长时间不使用时会从缓存中删除
            final RpcClient rpcClient = getRpcClient(endpoints);
            // 通过gRPC请求
            final ListenableFuture<QueryAssignmentResponse> future =
                rpcClient.queryAssignment(metadata, request, asyncWorker, duration);
            return new RpcFuture<>(context, request, future);
        } catch (Throwable t) {
            return new RpcFuture<>(t);
        }
    }

void syncProcessQueue(…)

将从broker获取的MessageQueue（assignments）和本地缓存的做对比，如果本地缓存的在assignments中不存在或者过期了，停止对应的MessageQueue的消费行为。如果assignments有但本地缓存中没有，新增ProcessQueue对MessageQueue进行消费。

  • String topic ：主题
  • Assignments assignments：topic对应的MessageQueue集合
  • FilterExpression filterExpression：过滤规则
void syncProcessQueue(String topic, Assignments assignments, FilterExpression filterExpression) {
        Set<MessageQueueImpl> latest = new HashSet<>();

        final List<Assignment> assignmentList = assignments.getAssignmentList();
        for (Assignment assignment : assignmentList) {
            latest.add(assignment.getMessageQueue());
        }

        Set<MessageQueueImpl> activeMqs = new HashSet<>();

        for (Map.Entry<MessageQueueImpl, ProcessQueue> entry : processQueueTable.entrySet()) {
            final MessageQueueImpl mq = entry.getKey();
            final ProcessQueue pq = entry.getValue();
            if (!topic.equals(mq.getTopic())) {
                continue;
            }

            if (!latest.contains(mq)) {
                log.info("Drop message queue according to the latest assignmentList, mq={}, clientId={}", mq,
                    clientId);
                dropProcessQueue(mq);
                continue;
            }

            if (pq.expired()) {
                log.warn("Drop message queue because it is expired, mq={}, clientId={}", mq, clientId);
                dropProcessQueue(mq);
                continue;
            }
            activeMqs.add(mq);
        }
        // 新增加的MessageQueue，添加对应的ProcessQueue对其消息进行消费
        for (MessageQueueImpl mq : latest) {
            if (activeMqs.contains(mq)) {
                continue;
            }
            final Optional<ProcessQueue> optionalProcessQueue = createProcessQueue(mq, filterExpression);
            if (optionalProcessQueue.isPresent()) {
                log.info("Start to fetch message from remote, mq={}, clientId={}", mq, clientId);
                optionalProcessQueue.get().fetchMessageImmediately();
            }
        }
    }

Optional createProcessQueue(MessageQueueImpl mq, final FilterExpression filterExpression)

    protected Optional<ProcessQueue> createProcessQueue(MessageQueueImpl mq, final FilterExpression filterExpression) {
        final ProcessQueueImpl processQueue = new ProcessQueueImpl(this, mq, filterExpression);
        final ProcessQueue previous = processQueueTable.putIfAbsent(mq, processQueue);
        if (null != previous) {
            return Optional.empty();
        }
        return Optional.of(processQueue);
    }

ProcessQueue

public void fetchMessageImmediately()

    public void fetchMessageImmediately() {
        receiveMessageImmediately();
    }

private void receiveMessageImmediately()

private void receiveMessageImmediately() {
        final ClientId clientId = consumer.getClientId();
        if (!consumer.isRunning()) {
            log.info("Stop to receive message because consumer is not running, mq={}, clientId={}", mq, clientId);
            return;
        }
        try {
            final Endpoints endpoints = mq.getBroker().getEndpoints();
            final int batchSize = this.getReceptionBatchSize();
            final Duration longPollingTimeout = consumer.getPushConsumerSettings().getLongPollingTimeout();
            final ReceiveMessageRequest request = consumer.wrapReceiveMessageRequest(batchSize, mq, filterExpression,
                longPollingTimeout);
            activityNanoTime = System.nanoTime();

            // Intercept before message reception.
            final MessageInterceptorContextImpl context = new MessageInterceptorContextImpl(MessageHookPoints.RECEIVE);
            consumer.doBefore(context, Collections.emptyList());

            final ListenableFuture<ReceiveMessageResult> future = consumer.receiveMessage(request, mq,
                longPollingTimeout);
            Futures.addCallback(future, new FutureCallback<ReceiveMessageResult>() {
                @Override
                public void onSuccess(ReceiveMessageResult result) {
                    // Intercept after message reception.
                    final List<GeneralMessage> generalMessages = result.getMessageViewImpls().stream()
                        .map((Function<MessageView, GeneralMessage>) GeneralMessageImpl::new)
                        .collect(Collectors.toList());
                    final MessageInterceptorContextImpl context0 =
                        new MessageInterceptorContextImpl(context, MessageHookPointsStatus.OK);
                    consumer.doAfter(context0, generalMessages);

                    try {
                        onReceiveMessageResult(result);
                    } catch (Throwable t) {
                        // Should never reach here.
                        log.error("[Bug] Exception raised while handling receive result, mq={}, endpoints={}, "
                            + "clientId={}", mq, endpoints, clientId, t);
                        onReceiveMessageException(t);
                    }
                }

                @Override
                public void onFailure(Throwable t) {
                    // Intercept after message reception.
                    final MessageInterceptorContextImpl context0 =
                        new MessageInterceptorContextImpl(context, MessageHookPointsStatus.ERROR);
                    consumer.doAfter(context0, Collections.emptyList());

                    log.error("Exception raised during message reception, mq={}, endpoints={}, clientId={}", mq,
                        endpoints, clientId, t);
                    onReceiveMessageException(t);
                }
            }, MoreExecutors.directExecutor());
            receptionTimes.getAndIncrement();
            consumer.getReceptionTimes().getAndIncrement();
        } catch (Throwable t) {
            log.error("Exception raised during message reception, mq={}, clientId={}", mq, clientId, t);
            onReceiveMessageException(t);
        }
    }

void onReceiveMessageResult(ReceiveMessageResult result)

    private void onReceiveMessageResult(ReceiveMessageResult result) {
        final List<MessageViewImpl> messages = result.getMessageViewImpls();
        if (!messages.isEmpty()) {
            cacheMessages(messages);
            receivedMessagesQuantity.getAndAdd(messages.size());
            consumer.getReceivedMessagesQuantity().getAndAdd(messages.size());
            // 根据startUp方法里的createConsumeService可知consumerService对应StandardConsumeService
            consumer.getConsumeService().consume(this, messages);
        }
        receiveMessage();
    }

void eraseMessage(MessageViewImpl messageView, ConsumeResult consumeResult)

处理消息的消费结果，如果消费成功，给broker发送ack消息，如果处理失败，按照重试的间隔时间设置消息不可见时间

    public void eraseMessage(MessageViewImpl messageView, ConsumeResult consumeResult) {
        statsConsumptionResult(consumeResult);
        ListenableFuture<Void> future = ConsumeResult.SUCCESS.equals(consumeResult) ? ackMessage(messageView) :
            nackMessage(messageView);
         //删除消息对应的本地缓存 
        future.addListener(() -> evictCache(messageView), MoreExecutors.directExecutor());
    }

StandardConsumeService：并发消息处理

void consume(ProcessQueue pq, List messageViews)

public void consume(ProcessQueue pq, List<MessageViewImpl> messageViews) {
        for (MessageViewImpl messageView : messageViews) {
            // Discard corrupted message.
            if (messageView.isCorrupted()) {
                log.error("Message is corrupted for standard consumption, prepare to discard it, mq={}, "
                    + "messageId={}, clientId={}", pq.getMessageQueue(), messageView.getMessageId(), clientId);
                pq.discardMessage(messageView);
                continue;
            }
            final ListenableFuture<ConsumeResult> future = consume(messageView);
            Futures.addCallback(future, new FutureCallback<ConsumeResult>() {
                @Override
                public void onSuccess(ConsumeResult consumeResult) {
                    pq.eraseMessage(messageView, consumeResult);
                }

                @Override
                public void onFailure(Throwable t) {
                    // Should never reach here.
                    log.error("[Bug] Exception raised in consumption callback, clientId={}", clientId, t);
                }
            }, MoreExecutors.directExecutor());
        }
    }

ListenableFuture consume(MessageViewImpl messageView)

    public ListenableFuture<ConsumeResult> consume(MessageViewImpl messageView) {
        return consume(messageView, Duration.ZERO);
    }

ListenableFuture consume(MessageViewImpl messageView, Duration delay)

将消息封装为ConsumeTask后放到线程池中执行

  • MessageViewImpl messageView：需要消费消费的消息
  • Duration delay：消费延迟时间
public ListenableFuture<ConsumeResult> consume(MessageViewImpl messageView, Duration delay) {
        final ListeningExecutorService executorService = MoreExecutors.listeningDecorator(consumptionExecutor);
        final ConsumeTask task = new ConsumeTask(clientId, messageListener, messageView, messageInterceptor);
        // delay<=0:立即执行消息
        if (Duration.ZERO.compareTo(delay) >= 0) {
            return executorService.submit(task);
        }
        // 延迟delay后消费消息
        final SettableFuture<ConsumeResult> future0 = SettableFuture.create();
        scheduler.schedule(() -> {
            final ListenableFuture<ConsumeResult> future = executorService.submit(task);
            Futures.addCallback(future, new FutureCallback<ConsumeResult>() {
                @Override
                public void onSuccess(ConsumeResult consumeResult) {
                    future0.set(consumeResult);
                }

                @Override
                public void onFailure(Throwable t) {
                    // Should never reach here.
                    log.error("[Bug] Exception raised while submitting scheduled consumption task, clientId={}",
                        clientId, t);
                }
            }, MoreExecutors.directExecutor());
        }, delay.toNanos(), TimeUnit.NANOSECONDS);
        return future0;
    }

FifoConsumeService：顺序消息

在充实中一定的次数前，都是将消息包装成任务放到本地线程池里进行重复执行，直到成功或者失败或者超出次数限制后才给broker响应。

    public void consume(ProcessQueue pq, List<MessageViewImpl> messageViews) {
        consumeIteratively(pq, messageViews.iterator());
    }

void consumeIteratively(ProcessQueue pq, Iterator iterator)

   public void consumeIteratively(ProcessQueue pq, Iterator<MessageViewImpl> iterator) {
        if (!iterator.hasNext()) {
            return;
        }
        final MessageViewImpl messageView = iterator.next();
        // 消息消费异常，将消息加入死信队列
        if (messageView.isCorrupted()) {
            // Discard corrupted message.
            log.error("Message is corrupted for FIFO consumption, prepare to discard it, mq={}, messageId={}, "
                + "clientId={}", pq.getMessageQueue(), messageView.getMessageId(), clientId);
            pq.discardFifoMessage(messageView);
            consumeIteratively(pq, iterator);
            return;
        }
        // 消息消费，调用父类的消息消费逻辑，同并发消费保持一致
        final ListenableFuture<ConsumeResult> future0 = consume(messageView);
        ListenableFuture<Void> future = Futures.transformAsync(future0, result -> pq.eraseFifoMessage(messageView,
            result), MoreExecutors.directExecutor());
        future.addListener(() -> consumeIteratively(pq, iterator), MoreExecutors.directExecutor());
    }

ListenableFuture eraseFifoMessage(MessageViewImpl messageView, ConsumeResult consumeResult)

消息消费后的处理逻辑；

  • 消费失败后，如果没有超过设置的重试次数，获取间隔时间并重新消费；
  • 消费失败且重试次数大于设置的重试次数，调用forwardToDeadLetterQueue将消息加入死信队列
  • 消费成功，给消息发送ack确认
public ListenableFuture<Void> eraseFifoMessage(MessageViewImpl messageView, ConsumeResult consumeResult) {
        statsConsumptionResult(consumeResult);
        final RetryPolicy retryPolicy = consumer.getRetryPolicy();
        final int maxAttempts = retryPolicy.getMaxAttempts();
        int attempt = messageView.getDeliveryAttempt();
        final MessageId messageId = messageView.getMessageId();
        final ConsumeService service = consumer.getConsumeService();
        final ClientId clientId = consumer.getClientId();
        if (ConsumeResult.FAILURE.equals(consumeResult) && attempt < maxAttempts) {
            final Duration nextAttemptDelay = retryPolicy.getNextAttemptDelay(attempt);
            attempt = messageView.incrementAndGetDeliveryAttempt();
            log.debug("Prepare to redeliver the fifo message because of the consumption failure, maxAttempt={}," +
                    " attempt={}, mq={}, messageId={}, nextAttemptDelay={}, clientId={}", maxAttempts, attempt, mq,
                messageId, nextAttemptDelay, clientId);
            final ListenableFuture<ConsumeResult> future = service.consume(messageView, nextAttemptDelay);
            return Futures.transformAsync(future, result -> eraseFifoMessage(messageView, result),
                MoreExecutors.directExecutor());
        }
        boolean ok = ConsumeResult.SUCCESS.equals(consumeResult);
        if (!ok) {
            log.info("Failed to consume fifo message finally, run out of attempt times, maxAttempts={}, "
                + "attempt={}, mq={}, messageId={}, clientId={}", maxAttempts, attempt, mq, messageId, clientId);
        }
        // Ack message or forward it to DLQ depends on consumption result.
        ListenableFuture<Void> future = ok ? ackMessage(messageView) : forwardToDeadLetterQueue(messageView);
        future.addListener(() -> evictCache(messageView), consumer.getConsumptionExecutor());
        return future;
    }

ConsumeTask

调用了自定义的消息处理逻辑，消息处理有两种结果，默认消费失败

  • SUCCESS：消费成功
  • FAILURE：消费失败
    public ConsumeResult call() {
        ConsumeResult consumeResult;
        final List<GeneralMessage> generalMessages = Collections.singletonList(new GeneralMessageImpl(messageView));
        MessageInterceptorContextImpl context = new MessageInterceptorContextImpl(MessageHookPoints.CONSUME);
        messageInterceptor.doBefore(context, generalMessages);
        try {
        	// messageListener是自己实现的消息处理类
            consumeResult = messageListener.consume(messageView);
        } catch (Throwable t) {
            log.error("Message listener raised an exception while consuming messages, clientId={}", clientId, t);
            // If exception was thrown during the period of message consumption, mark it as failure.
            consumeResult = ConsumeResult.FAILURE;
        }
        MessageHookPointsStatus status = ConsumeResult.SUCCESS.equals(consumeResult) ? MessageHookPointsStatus.OK :
            MessageHookPointsStatus.ERROR;
        context = new MessageInterceptorContextImpl(context, status);
        messageInterceptor.doAfter(context, generalMessages);
        // Make sure that the return value is the subset of messageViews.
        return consumeResult;
    }
最近减肥
关注
使用rocketmq，rocketmq-client-python的api开发rocketmq生产者和消费者
202xxx的博客
08-17 4753
rocketmq-python 是一个基于 rocketmq-client-cpp 封装的 RocketMQ Python 客户端。 rocketmq-client-python安装 目前rocketmq库只支持linux和mac。 rocketmq-client-python 的安装： pip install rocketmq 安装太慢？国内源安装： pip install rocketmq -i https://pypi.tuna.tsinghua.edu.cn/simple 示例代码
springboot系类代码：spring-boot-rocketmq-rocketmq-client
BLOG域名:programb.blog.csdn.net
05-21 650
Apache RocketMQ是一个分布式消息和流媒体平台，具有低延迟、高性能和可靠性、万亿级容量和灵活的可伸缩性。 它提供了多种功能： 消息模式包括发布/订阅、请求/回复和流 金融级交易信息 基于DLedger的内置容错和高可用性配置选项 各种跨语言客户端，如java、C/C++、Python、Go 可插拔传输协议，如TCP、SSL、AIO 内置消息跟踪功能，还支持opentracing 多功能大数据流生态系统集成 按时间或偏移量追溯邮件 在同一队列中提供可靠的FIFO和严格有序的消息传递 有效拉推消费模
SpringBoot集成rocketmq-client
Lyhdreamer的博客
03-05 891
SpringBoot集成rocketmq-client的生产者和消费者demo
Apache RocketMQ 客户端使用教程
最新发布
gitblog_00480的博客
09-02 455
Apache RocketMQ 客户端使用教程 项目地址:https://gitcode.com/gh_mirrors/roc/rocketmq-clients 1、项目介绍 Apache RocketMQ 是一个开源的分布式消息传递和流处理平台，广泛应用于大规模数据处理和实时消息传递。RocketMQ 客户端（RocketMQ Clients）是 RocketMQ 的客户端绑定库，支持多种编程语...
【RocketMQ】基本使用：Java操作RocketMQ（rocketmq-client）
09-30 1366
SEND OK ：表示发送成功，发送成功的具体含义，比如消息是否已经被存储到磁盘？需要结合所配置的刷盘策略、主从策略来定。SLAVE_NOT_AVAILABLE ： 这个状态产生的场景和FLUSH_SLAVE_TIMEOUT 类似， 表示在主备方式下，并且Broker 被设置成SYNC_MASTER ，但是没有找到被配置成Slave 的Broker。FLUSH_SLAVE_TIMEOUT ：表示在主备方式下，并且Broker 被设置成SYNC_MASTER 方式，没有在设定时间内完成主从同步。
rocketmq-client
12-05
rocketmq-client-3.5.9.jar,rocketmq-client-3.5.9.jar
rocketmq-client-java 5.x SimpleConsumer
Confused_Tom_Cat的博客
04-05 1280
rocketmq-client-java 5.x SimpleConsumer
rocketmq-client-java 5.x 消费者介绍
Confused_Tom_Cat的博客
04-05 1432
rocket-client-java 消费者简介
JAVA使用rocketmq-client整合RocketMQ
程序员劝退师的博客
12-09 7124
前言 理论部分请前往这个专题的其他文章查看，本文接RocketMQ消息类型文章，本文使用rocketmq-client操作RocketMQ发送接受各种消息的案例！ 依赖 <dependency> <groupId>org.apache.rocketmq</groupId> <artifactId>rocketmq-client</artifactId> </dependenc
rocketmq-all-4.9.3-bin-release
03-14
RocketMQ还支持多种模式，如Push模式（消息主动推送到消费者）、Pull模式（消费者主动拉取消息）。 3. **高可用性**：RocketMQ通过主备切换和分布式部署实现高可用。每个Broker都可以有多个备份，当主Broker故障时...
rocketmq-all-4.7.0-source-release.zip
04-09
7. **Client API**：Java和多语言客户端API，方便开发者在不同语言环境中使用RocketMQ。 8. **Tools**：一些实用工具，如Admin工具，用于监控和管理RocketMQ集群；以及NameServer和Broker的启动脚本。 9. **Tests*...
rocketmq-client 4.3.0 在springboot中的使用
Myueye的博客
01-21 641
rocketmq-client 4.3.0 在springboot中的使用1 、导入依赖2、配置文件属性3、编写配置类4、使用测试5、结果5.1 RocketMQ后台显示5.2 前端页面5.3 后端后台 1 、导入依赖 <dependency> <groupId>org.apache.rocketmq</groupId> <artifactId>rocketmq-client</artifactId> <version>4.3.0&lt
rocketmq java客户端_RocketMq 之 java rocket client
weixin_39631932的博客
02-13 373
maven依赖:org.apache.rocketmqrocketmq-client4.4.0先用命令建一个topic:sh mqadmin updateTopic -b 192.168.71.170:10911 -n 192.168.71.170:9876 -t TopicTest查看:sh mqadmin topicList -n 192.168.71.170:9876输出：[root@loc...
RocketMQ原理解析－Consumer
aikuangchou2298的博客
11-11 361
consumer 1.启动 有别于其他消息中间件由broker做负载均衡并主动向consumer投递消息，RocketMq是基于拉模式拉取消息，consumer做负载均衡并通过长轮询向broker拉消息。 Consumer消费拉取的消息的方式有两种 1. Push方式：rocketmq已经提供了很全面的实现，consumer通过长轮询拉取消息后回调MessageL...
RocketMQ入坑指南（二）：JAVA接入RocketMQ
u014374743的博客
02-03 2869
RocketMQ入坑指南（二）：JAVA接入RocketMQ
rocketmq java客户端_RocketMQ整合Java与springboot
weixin_35867815的博客
02-22 649
1 导入依赖org.apache.rocketmqrocketmq-client4.7.02 消息生产者步骤创建消息生产者producer，并指定生产者组名指定Nameserver地址启动producer创建消息对象，指定主题Topic、Tag和消息体发送消息关闭生产者producer3 消息消费者步骤创建消费者Consumer，制定消费者组名指定Nameserver地址订阅主题Topic和Tag...
java调用rocketmq_Java操作RocketMQ
weixin_36254379的博客
02-26 812
第一步：导入依赖com.alibaba.rocketmqrocketmq-client3.0.10com.alibaba.rocketmqrocketmq-all3.0.10pomch.qos.logbacklogback-classic1.1.1ch.qos.logbacklogback-core1.1.1junitjunit4.10test第二步：创建生产者package com.wish;i...
依赖包org.apache.rocketmq:rocketmq-openmessaging和org.apache.rocketmq:rocketmq-client的区别
05-18
org.apache.rocketmq:rocketmq-openmessaging和org.apache.rocketmq:rocketmq-client都是Apache RocketMQ的Java客户端，但是它们的使用场景有所不同。 org.apache.rocketmq:rocketmq-client是RocketMQ的Java原生客户端，提供了完整的API，适用于在Java应用程序中直接使用RocketMQ的情况。 而org.apache.rocketmq:rocketmq-openmessaging是RocketMQ对OpenMessaging规范的实现，支持多种消息协议和消息队列服务，包括RocketMQ、Kafka、ActiveMQ等。使用RocketMQ作为消息中间件时，可以选择使用rocketmq-openmessaging作为客户端，以便更好地与其他消息系统进行集成。 简而言之，如果您使用RocketMQ作为消息中间件，并且希望与其他消息系统进行集成，则可以选择使用org.apache.rocketmq:rocketmq-openmessaging。如果您只是在Java应用程序中使用RocketMQ，则应该选择org.apache.rocketmq:rocketmq-client。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值