rocketmq-client-java 5.x PushConsumer

最新推荐文章于 2024-04-09 20:16:55 发布
最新推荐文章于 2024-04-09 20:16:55 发布
阅读量888 收藏
点赞数
文章标签： 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;
    }
最近减肥
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
rocketmq-client-3.6.2.Final-API文档-中文版.zip
04-09
赠送jar包：rocketmq-client-3.6.2.Final.jar； 赠送原API文档：rocketmq-client-3.6.2.Final-javadoc.jar； 赠送源代码：rocketmq-client-3.6.2.Final-sources.jar； 包含翻译后的API文档：rocketmq-client-...
rocketmq-client-java 5.x 消费者介绍
Confused_Tom_Cat的博客
04-05 1225
rocket-client-java 消费者简介
RocketMQ 5，2024年最新Java开发新手入门教程
2401_83977640的博客
04-09 680
按照上面的过程，4个月的时间刚刚好。当然Java的体系是很庞大的，还有很多更高级的技能需要掌握，但不要着急，这些完全可以放到以后工作中边用别学。学习编程就是一个由混沌到有序的过程，所以你在学习过程中，如果一时碰到理解不了的知识点，大可不必沮丧，更不要气馁，这都是正常的不能再正常的事情了，不过是“人同此心，心同此理”的暂时而已。道路是曲折的，前途是光明的！一个人可以走的很快，但一群人才能走的更远。
【RocketMQ】基本使用：Java操作RocketMQ（rocketmq-client）
09-30 1190
SEND OK ：表示发送成功，发送成功的具体含义，比如消息是否已经被存储到磁盘？需要结合所配置的刷盘策略、主从策略来定。SLAVE_NOT_AVAILABLE ： 这个状态产生的场景和FLUSH_SLAVE_TIMEOUT 类似， 表示在主备方式下，并且Broker 被设置成SYNC_MASTER ，但是没有找到被配置成Slave 的Broker。FLUSH_SLAVE_TIMEOUT ：表示在主备方式下，并且Broker 被设置成SYNC_MASTER 方式，没有在设定时间内完成主从同步。
SpringBoot集成rocketmq-client
Lyhdreamer的博客
03-05 638
SpringBoot集成rocketmq-client的生产者和消费者demo
rocketmq-client-java 5.x SimpleConsumer
Confused_Tom_Cat的博客
04-05 1082
rocketmq-client-java 5.x SimpleConsumer
JAVA使用rocketmq-client整合RocketMQ
程序员劝退师的博客
12-09 6261
前言 理论部分请前往这个专题的其他文章查看，本文接RocketMQ消息类型文章，本文使用rocketmq-client操作RocketMQ发送接受各种消息的案例！ 依赖 <dependency> <groupId>org.apache.rocketmq</groupId> <artifactId>rocketmq-client</artifactId> </dependenc
Rocket MQ 使用Java 发送接收消息
z_D15的博客
12-25 1162
Java 使用 RocketMQ 简单demo
Rocketmq使用手册第二篇(java原生整合rocketmq)
Smile波的博客
03-14 3486
java原生整合rocketmq 一,引入依赖 <dependency> <groupId>org.apache.rocketmq</groupId> <artifactId>rocketmq-client</artifactId> <version>4.8.0</version> </dependency> 二, 使用demo： 1,simple(简单
RocketMQ入坑指南（二）：JAVA接入RocketMQ
u014374743的博客
02-03 1690
RocketMQ入坑指南（二）：JAVA接入RocketMQ
rocketmq-client-cpp-2.0.0.amd64.deb
02-16
rocketmq-client-cpp-2.0.0.amd64.deb
rocketmq-client-cpp-2.1.0.amd64.deb
06-15
rocketmq C client
rocketmq-client-cpp_lib.tar.gz
10-21
rocketmq-client-cpp-release-2.2.0所需的第三方库。 包含： boost_1_58_0.tar.gz jsoncpp-0.10.7.zip libevent-release-2.1.11-stable.zip openssl-1.1.1d.tar.gz googletest-release-1.8.1.tar.gz
rocketmq-client-nodejs:Apache RocketMQ Node.js客户端
05-03
const { Producer , PushConsumer } = require ( "apache-rocketmq" ) ; 制片人 建设者 new Producer ( groupId [ , instanceName ] [ , options ] ) ; Producer的构造函数接收三个参数： groupId ：生产
追求极致性能，RocketMQ 消息通信详解
Q54665642ljf的博客
11-18 940
上面介绍了 RocketMQ 消息通信的主要内容，我们用几句话总结下：整个 RocketMQ 队列系统中，rocketmq-remoting Module 是专门用来负责网络通信职能的。网络通信模块基于 Netty 进行扩展的，所以自定义了 RocketMQ 的消息协议，在传输过程的数据进行结构制定、封装、编解码的过程。
Java随笔 | 消息队列RocketMQ的简介、安装与使用（非Springboot项目）
野生猿林仔的博客
02-06 1293
介绍了消息队列RocketMQ的概念、安装与在普通java项目（非Springboot项目）中的使用，发送消息的三种方式：同步发送、异步发送、单向模式发送（oneway），以及消息过滤。
RocketMQ 操作落地 (rocketmq-client 方式)
gelald的博客
09-07 3363
这一篇是 RocketMQ 的代码落地篇，使用rocketmq-client依赖实现了RocketMQ常见的用法
依赖包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、付费专栏及课程。

余额充值