Chapter3-用适合的方式发送和接收消息

3.1 不同类型的消费者

        消费者可分为两种类型。 一个是DefaultMQPushConsumer ,由系统控制读取操作,收到消息后自动调用传人的处理方法来处理;另 一个是 DefaultMlConsumer ,读取操作中的大部分功能由使用者自主控制 。

3.1.1 DefaultMQPushConsumer 的使用

        使用 DefaultMQPushConsumer 主要是设置好各种参数和传人处理消息的函数。 系统收到消息后自动调用处理函数来处理消息,自动保存 Offset ,而且加入新的 DefaultMQPushConsumer 后会自动做负载均衡。 
Consumer.javahttps://github.com/apache/rocketmq/blob/develop/example/src/main/java/org/apache/rocketmq/example/quickstart/Consumer.java

        DefaultMQPushConsumer 需要设置三个参数 :GroupName 、NameServer、Topic

1 ) Consumer 的 GroupName 用 于把 多个 Consumer 组织到一起 , 提高并发处理能力,GroupName 需要和消息模式 ( MessageModel )配合使用 。

        RocketMQ 支持两种消息模式 :Clustering 和 Broadcasting 。

  • 在 Clustering 模式下,同一个 ConsumerGroup ( GroupName 相同 ) 里的每个 Consumer 只消费所订阅消息的一部分内容, 同一个 ConsumerGroup里所有的 Consumer 消 费的内容合起来才是所订阅 Topic 内容的整体 ,从而达到负载均衡的目的 。
  •  在 Broadcasting 模式下,同一个 ConsumerGroup 里的每个 Consumer 都能消费到所订阅 Topic 的全部消息,也就是一个消息会被多次分发,被多个 Consumer 消费 。

2) NameServer 的地址和端口号,可以填写多个 ,用分号隔开,达到消除单点故障的目的 , 比如 “ ip 1 :port;ip2:port;ip3 :port ” 。 

 3 ) Topic 名称用来标识消息类型 , 需要提前创建。(在启动broker 传入入参数也可以 autoCreateTopicEnable=true) 如果不需要消费某个 Topic 下的所有消息,可以通过指定消息的 Tag 进行消息过滤,比如:Consumer. subscribe ("TopicTest", "tag1 || tag2 || tag3"), 表示这个 Consumer 要消费“ TopicTest ”下带有 tagl 或 tag2 或 tag3 的消息( Tag 是在发送消息时设置 的标签) 。 在填写 Tag 参数的位置,用 null 或者 "*" 表示要消费这个 Topic的所有消息 。

3.1.2 DefaultMQPushConsumer 的处理流程 

 DefaultMQPushConsumer 主要功能实现在 DefaultMQPushConsumerlmpl类中,消息的处理逻辑是在 pullMessage 这个函数里的 PullCallBack 中 。 在PullCallBack 函数里有个 switch 语句,根据从 Broker 返回的消息类型做相应的处理:Chapter3-用适合的方式发送和接收消息_第1张图片

Chapter3-用适合的方式发送和接收消息_第2张图片

Chapter3-用适合的方式发送和接收消息_第3张图片

         DefaultMQPushConsuer 的源码中有很多 PullRequest 语句,比如

Default­MQPushConsumerlmpl.this.executePullRequestlmmediately(pullRequest)。 为什么“PushConsumer ”中使用“ PullRequest ”呢? 这是通过“长轮询”方式达到Push 效果的方法,长轮询方式既有 Pull 的优点,又兼具 Push 方式的实时性。

        Push 方式是 Server 端接收到消息后,主动把消息推送给 Client 端,实时性高。 对于一个提供队列服务的 Server 来说,用 Push 方式主动推送有很多弊端:首先是加大 Server 端的工作量,进而影响 Server 的性能;其次, Client 的处理能力各不相同, Client 的状态不受 Server 控制,如果 Client 不能及时处理Server 推送过来的消息,会造成各种潜在问题

        Pull 方式是 Client 端循环地从 Server 端拉取消息,主动权在 Client 手里,自己拉取到一定量消息后,处理妥当了再接着取。 Pull 方式的问题是循环拉取消息的间隔不好设定,间隔太短就处在一个 “ 忙等”的状态,浪费资源;每个Pull 的时间间隔太长 Server 端有消息到来时 有可能没有被及时处理。

        “长轮询”方式通过 Client 端和 Server 端的配合,达到既拥有 Pull 的优点,又能达到保证实时性的目的 。 

Chapter3-用适合的方式发送和接收消息_第4张图片

Chapter3-用适合的方式发送和接收消息_第5张图片

         源码中有这一行设置语句 requestHeader.setSuspendTimeoutMillis (brokerSus-
pendMaxTimeMillis ),作用是设置 Broker 最长阻塞时间 ,默认设置是 15 秒,注意是 Broker 在没有新消息的时候才阻塞,有消息会立刻返回 。

Chapter3-用适合的方式发送和接收消息_第6张图片

         从 Broker 的源码中可以看 出,服务端接到新消息请求后, 如果队列里没有新消息,并不急于返回,通过一个循环不断查看状态,每次 waitForRunning一段 时间 (默认是 5 秒 ) , 然后后 再 Check 。默认情况下当 Broker 一直没有新消息, 第三次 Check 的时候, 等待时间超过Request 里面的 Broker­SuspendMaxTimeMillis , 就返回空结果。 在等待的过程中, Broker 收到了新的消息后会直接调用 notifyMessageArriving 函数返回请求结果 。 “长轮询”的核心 是, Broker 端 HOLD 住客户端过来的请求一小段时间,在这个时间内有新消息到达,就利用现有的连接立刻返回消息给 Consumer 。 “长 轮询”的 主动权还是掌握在 Consumer 手中, Broker 即使有大量消息积压 ,也不会主动推送给Consumer 。

        长轮询方式的局限性,是在 HOLD 住 Consumer 请求的时候需要占用资源,它适合用在消息队列这种客户端连接数可控的场景中

3.1.3 DefaultMQPushConsumer 的流量控制 

        PushConsumer 的核心还是 Pull方式

Chapter3-用适合的方式发送和接收消息_第7张图片

         上二张图片“PullMessages.pullMessages(request)”是在run方法中运行的(新的线程)

        Pull 获得的消息,如果直接提交到线程池里执行,很难监控和控制 ,比如,如何得知当前消息堆积的数量?如何重复处理某些消息? 如何延迟处理某些消息? RocketMQ 定义了一个快照类 Process Queue 来解决这些问题,在Push Consumer 运行的时候, 每个 Message Queue 都会有个对应的 Proces s Queue 对象,保存了这个 Message Queue 消息处理状态的快照 。

        ProcessQueue 对象里主要的内容是一个 TreeMap 和一个读写锁。 TreeMap里以 Message Queue 的 Offset 作为 Key ,以消息内容的引用为 Value ,保存了所有从 MessageQueue 获取到,但是还未被处理的消息; 读写锁控制着多个线程对 TreeMap 对象的并发访问 。

Chapter3-用适合的方式发送和接收消息_第8张图片

        有了 ProcessQueue 对象,流量控制就方便和灵活多了,客 户 端在每次 Pull请求前会做下面三个判断来控制流量。

Chapter3-用适合的方式发送和接收消息_第9张图片

         从代码中可以看出,PushConsumer 会判断获取但还未处理的消息个数 、消息总大小、Offset 的跨度,任何一个值超过设定的大小就隔一段时间再拉取消息,从而达到流量控制的目的。 此外 ProcessQueue 还可以辅助实现顺序消费的逻辑 。

 3.1.4 DefaultMQPullConsumer

        使用 DefaultMQPullConsumer 像使用 DefaultMQPushConsumer 一样需要设置各种参数,写处理消息的函数,同时还需要做额外的事情 。  

PullConsumer.javahttps://github.com/apache/rocketmq/blob/develop/example/src/main/java/org/apache/rocketmq/example/simple/PullConsumer.java

( 1 )获取 Message Queue 并遍历

        一 个 Topic 包括多个 MessageQueue ,如果这个 Consumer 需要获取 Topic下所有的消息,就要遍历多有的 MessageQueue 。 如果有特殊情况,也可以选择某些特定的 Message Queue 来读取消息 。

Chapter3-用适合的方式发送和接收消息_第10张图片

( 2 )维护 Offsetstore

        从一个 Message Queue 里拉取消息的时候,要传入 Offset 参数( long 类型的值),随着不断读取消息 , Offset 会不断增长 。 这个时候由用户负责把 Offset存储下来,根据具体情况可以存到内存里、写到磁盘或者数据库里等。

Chapter3-用适合的方式发送和接收消息_第11张图片

 ( 3 )根据不同的消息状态做不同的处理

        拉取消息的请求发出后,会返回: FOUND 、 NO_MATCHED_MSG 、 NO_NEW_MSG 、 OFFSET_ILLEGAL 四种状态,需要根据每个状态做不同的处理。比较重要的两个状态是 FOUNT 和 NO_NEW_MSG ,分别表示获取到消息和没有新的消息 。

Chapter3-用适合的方式发送和接收消息_第12张图片

         实际情况中可以把 while (true )放到外层,达到无限循环的目的 。 因为 Pull Consumer 需要用户自己处理遍历 Message Queue 、保存 Offset ,所以Pull Consumer 有更多的自主性和灵活性。

 3.1.5 Consumer 的启动、关闭流程

         Consumer 分为 Push 和 Pull 两种方式,对于 PullConsumer 来说,使用者主动权很高,可以根据实际需要暂停、停止、启动消费过程。 需要注意的是Offset 的保存,要在程序的异常处理部分增加把 Offset 写入磁盘方面的处理,记准了每个 MessageQueue 的 Offset ,才能保证消息消费的准确性 。

        DefaultMQPushConsumer 的退出, 要调用 shutdown() 函数, 以便释放资源、保存 Offset 等 。 这个调用要加到 Consumer 所在应用的退出逻辑中 。PushConsumer 在启动的时候 ,会做各种配置检查,然后连接 NameServer获取 Topic 信息,启动时如果遇到异常,比如无法连接NameServer,程序仍然可以正常启动不报错(日志里有 WARN 信息 ) 。 在单机环境下可以测试这种情况,启动 DefaultMQPushConsumer 时故意 把 NameServer 地址填错,程序仍然可以正常启动,但是不会收到消息

Chapter3-用适合的方式发送和接收消息_第13张图片

         为什么 DefaultMQPushConsumer 在无法连接 NameServer 时不直接报错退出呢? 这和分布式系统的设计有关, RocketMQ 集群可以有多个 NameServer 、Broker ,某个机器出异常后整体服务依然可用 。 所以 DefaultMQPushConsumer被设计成当发现某个连接异常时不立刻退出,而是不断尝试重新连接。 可以进行这样一个测试,在 DefaultMQPushConsumer 正常运行的时候,手动 kill 掉Broker 或 NameServer ,过一会儿再启动 。 会发现 DefaultMQPushConsumer 不会出错退出,在服务恢复后正常运行,在服务不可用的这段时间 ,仅仅会在日志里报异常信息 。

        如果需要在 DefaultMQPushConsumer 启动的时候,及时暴露配置问题,该如何操作呢? 可以 在 Consumer.start()语句后调用: Consumer .fetchSubscribeMessageQueues ("TopicName") ,这时如果配置信息写得不准确,或者当前服务不可用,这个语句会报MQClient-Exception 异常 。

Chapter3-用适合的方式发送和接收消息_第14张图片

 3.2 不同类型的生产者

       生产者向消息队列里写人消息,不 同的业务场景需要生产者采用不同的写入策略 。 比如同步发送、异步发送、 延迟发送、 发送事务消息等

3.2.1 DefaultMQProducer 
Producer.javahttps://github.com/apache/rocketmq/blob/develop/example/src/main/java/org/apache/rocketmq/example/quickstart/Producer.java

         发送消息要经过五个步骤 :

1 )设置 Producer 的 GroupName 。

 2 )设置 lnstanceName ,当一个 Jvm 需要启动多个 Producer 的时候,通过设置不同的 InstanceName 来区分,不设置的话系统使用默认名称“DEFAULT ” 。

3 )设置发送失败重试次数,当网络出现异常的时候,这个次数影响消息的重复投递次数。 想保证不丢消息,可以设置多重试几次。

        producer.setRetryTimesWhenSendFailed(3);

4 )设置 NameServer 地址。

5 )组装消息并发送 。

        消息的发送有同步和异步两种方式,上面的代码使用的是异步方式。 在第 2 章的例子中用的是同步方式。 消息发送的返回状态有如下四种 : FLUSHDISK_TIMEOUT 、 FLUSH_SLAVE_ TIMEOUT 、 SLAVE_NOT_AVAILABLE 、SEND_OK ,不同状态在不同的刷盘策略和同步策略的配置下含义是不同的 。

  • FLUSH_DISK_TIMEOUT : 表示没有在规定时间内完成刷盘(需要Broker 的刷盘策设置成 SYNC_FLUSH 才会报这个错误) 。
  • FLUSH_SLAVE_TIMEOUT :表示在主备方式下,并且 Broker 被设置成 SYNC_MASTER 方式,没有在设定时间内完成主从同步。
  • SLAVE_NOT_AVAILABLE : 这个状态产生的场景和 FLUSH_SLAVE _TIMEOUT 类似, 表示在主备方式下,并且 Broker 被设置成 SYNC_MASTER ,但是没有找到被配置成 Slave 的 Broker 。
  • SEND_OK :表示发送成功,发送成功的具体含义,比如消息是否已经被存储到融盘?消息是否被同步到了 Slave 上?消息在 Slave 上是否被写人磁盘?需要结合所配置的刷盘策略、主从策略来定。 这个状态还可以简单理解为,没有发生上面列出的三个问题状态就是 SEND_ OK。

        写一个高质量的生产者程序,重点在于对发送结果的处理,要充分考虑各种异常,写清对应的处理逻辑。

3.2.2 发送延迟消息 

        延迟消息的使用方法是在创建 Message 对象时,调用 setDelayTimeLevel ( int level ) 方法设置延迟时间, 然后再把这个消息发送 出 去 。 目前延迟的时间不支持任意设置,仅支持预设值的时间长度 ( 1s/5s/10s/30s/1m/2m/3m/4m/5m/6m/7m/8m/9m/10m/20m/30m/1h/2h ) 。 比如 setDelayTimeLevel(3 ) 表示延迟 10s 。 

 3.2.3 自定义消息发送规则

        一个 Topic 会有多个 MessageQueue ,如 果使用 Producer 的 默认配置 ,这个 Producer 会轮流向各个 MessageQueue 发送消息 。 Consumer 在消费消息的时候,会根据负载均衡策略,消费被分配到的 MessageQueue ,如果不经过特定的设置,某条消息被发l哪个 MessageQueue ,被哪个 Consumer 消费是未知的 。

        如果业务需 要我们把消息发送到指定的 MessageQueue 里,比如把同一类型的消息都发相同的 MessageQueue , 该怎么办呢?可以用 Message­QueueSelector 

Chapter3-用适合的方式发送和接收消息_第15张图片

        发送消息的时候,把 MessageQueueSelector 的对象作为参数,使用 public SendResult send ( Message msg, MessageQueueSelector selector, Object arg )函数发送消息即可 。 在 MessageQueueSelector 的实现中,根据传入的 Object 参数,或者根据 Message 消息内容确定把消息发往那个 Message Queue ,返回被选中的 MessageQueue 。 

Chapter3-用适合的方式发送和接收消息_第16张图片

 3.2.4 对事务的支持

        RocketMQ 的事务消息,是指发送消息事件和其他事件需要同时成功或同时失败。 比如银行转账, A 银行的某账户要转一万元到 B 银行的某账户 。 A 银行发送“B 银行账户增加一万元” 这个消息,要和“从 A 银行账户扣除一万元”这个操作同时成功或者同时失败 。

        RocketMQ 采用两阶段提交的方式实现事务消息TransactionMQProducer处理上面情况的流程是,先发一个“准备从 B 银行账户增加一万元”的消息,发送成功后做从 A 银行账户扣除一万元的操作 ,根据操作结果是否成功,确定之前的“准备从 B 银行账户增加一万元”的消息是做 commit 还是 rollback ,具体流程如下:

Chapter3-用适合的方式发送和接收消息_第17张图片

Chapter3-用适合的方式发送和接收消息_第18张图片

Chapter3-用适合的方式发送和接收消息_第19张图片

事务消息发送及提交

         1 )发送方向 RocketMQ 发送“待确认”消息 。

        2) RocketMQ 将收到的“待确认” 消息持久化成功后, 向发送方回复消息已经发送成功,此时第一阶段消息发送完成。

        3 )发送方开始执行本地事件逻辑。

        4 )发送方根据本地事件执行结果向 RocketMQ 发送二次确认( Commit 或是 Rollback ) 消息 , RocketMQ 收到 Commit 状态则将第一阶段消息标记为可投递,订阅方将能够收到该消息;收到 Rollback 状态则删除第一阶段的消息,订阅方接收不到该消息 。

事务补偿

         5 )如果出现异常情况,步骤 4 )提交的二次确认最终未到达 RocketMQ,服务器在经过固定时间段后将对“待确认”消息、发起回查请求 。

        6 )发送方收到消息回查请求后(如果发送一阶段消息的 Producer 不能工作,回查请求将被发送到和 Producer 在同一个 Group 里的其他 Producer ),通过检查对应消息的本地事件执行结果返回 Commit 或 Roolback 状态 。

        7) RocketMQ 收到回查请求后,按照步骤 4 ) 的逻辑处理。

事务消息状态

事务消息共有三种状态,提交状态、回滚状态、中间状态:

  • TransactionStatus.CommitTransaction: 提交事务,它允许消费者消费此消息。

  • TransactionStatus.RollbackTransaction: 回滚事务,它代表该消息将被删除,不允许被消费。

  • TransactionStatus.Unknown: 中间状态,它代表需要检查消息队列来确定状态。

        上面的逻辑似乎很好地实现了 事务消息功能 ,它也是 RocketMQ 之前的版本实现事务消息 的逻辑。 但是因为 RocketMQ 依赖将数据顺序写到磁盘这个特征来提高性能,步骤 4 )却需要更改第一阶段消息的状态,这样会造成磁盘Catch 的脏页过多, 降低系统的性能。 所以 RocketMQ 在 4.x 的版本中将这部分功能去除。 系统中的一些上层 Class 都还在,用户可以根据实际需求实现自己的事务功能 。

        客户端支持用户实现事务消息有,LocalTransactionExecuter(过期) 、Transaction-CheckListener(过期)、 TransactionMQProduce与TransactionListenertransactionhttps://github.com/apache/rocketmq/tree/develop/example/src/main/java/org/apache/rocketmq/example/transaction
事务消息发送 | RocketMQ (apache.org)https://rocketmq.apache.org/zh/docs/4.x/producer/06message5

 3.3  如何存储队列位置信息

         RocketMQ 中, 一种类型的消息会放到一个 Topic 里,为了能够并行, 一般一个 Topic 会有多个 Message Queue (也可以设置成一个), Offset 是指某个 Topic 下的一条消息在某个 Message Queue 里的位置,通过 Offset 的值可以定位到这条消息,或者指示 Consumer 从这条消息开始向后继续处理

         Offset 的类结构,主要分为本地文件类型Broker 代存的类型两种 。 对于 DefaultMQPushConsurner 来说,默认是 CLUSTERING 模式,也就是同一个 Consumer group 里的多个消费者每人消费一部分,各自收到的消息内容不一样。 这种情况下,由 Broker 端存储和控制 Offset 的值,使用RemoteBrokerOffsetStore 结构 org.apache.rocketmq.client.consumer.store.RemoteBrokerOffsetStore

Chapter3-用适合的方式发送和接收消息_第20张图片

        Chapter3-用适合的方式发送和接收消息_第21张图片        在 DefaultMQPushConsumer 里的 BROADCASTING 模式下,每个 Consumer都收到这个 Topic 的全部消息,各个 Consumer 间相互没有干扰, RocketMQ 使用 LocalfileOffsetStore ,把 Offset 存到本地。 org.apache.rocketmq.client.consumer.store.LocalFileOffsetStore

 {

        "OffsetTable":[

                {"brokerNarne":"localhost","QueueId":1,"Topic":"broker1"},

                {"brokerNarne":"localhost","QueueId":2,"Topic":"broker1"},

                {"brokerNarne":"localhost","QueueId":0,"Topic":"broker1"}

        ]

}


import org.apache.rocketmq.client.consumer.store.OffsetSerializeWrapper;
import org.apache.rocketmq.client.consumer.store.ReadOffsetType;
import org.apache.rocketmq.common.MixAll;
import org.apache.rocketmq.common.message.MessageQueue;

import java.io.IOException;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.atomic.AtomicLong;

/**
 * 参照 org.apache.rocketmq.client.consumer.store.LocalFileOffsetStore
 * @author Jay
 */
public class LocalFileOffsetStore {
    private final String groupName;
    private final String storePath;
    private ConcurrentHashMap offsetTable = new ConcurrentHashMap();

    public LocalFileOffsetStore(String groupName, String storePath) {
        this.groupName = groupName;
        this.storePath = storePath;
    }

    /**
     * Load
     */
    void load() {
        OffsetSerializeWrapper offsetSerializeWrapper = this.readLocalOffset();
        if (offsetSerializeWrapper == null || offsetSerializeWrapper.getOffsetTable() == null)
            return;
        ConcurrentMap currentOffsetTable = offsetSerializeWrapper.getOffsetTable();
        this.offsetTable.putAll(currentOffsetTable);
        for (MessageQueue mq : currentOffsetTable.keySet()) {
            long l = currentOffsetTable.get(mq).get();
            System.out.printf("load Consumer's Offset, %s %s %d \n", this.groupName, mq, l);
        }
    }

    /**
     * 更新偏移量,将其存储在内存中
     *
     * @param mq           MessageQueue
     * @param offset       偏移量
     * @param increaseOnly
     */
    void updateOffset(final MessageQueue mq, final long offset, final boolean increaseOnly) {
        if (mq == null)
            return;
        AtomicLong offsetOld = this.offsetTable.get(mq);
        if (offsetOld == null) {
            this.offsetTable.putIfAbsent(mq, new AtomicLong(offset));
        } else {
            offsetOld.set(offset);
        }
    }

    /**
     * 从本地存储获取偏移量
     *
     * @param mq   MessageQueue集合
     * @param type
     * @return 获取的偏移量
     */
    long readOffset(final MessageQueue mq, final ReadOffsetType type) {
        if (mq == null || this.offsetTable.get(mq) == null)
            return 0;
        return this.offsetTable.get(mq).get();
    }

    /**
     * 在本地存储保留所有偏移量
     *
     * @param mqs MessageQueue集合
     */
    void persistAll(final Set mqs) {
        if (mqs == null || mqs.isEmpty())
            return;
        OffsetSerializeWrapper offsetSerializeWrapper = new OffsetSerializeWrapper();
        for (Map.Entry entry : this.offsetTable.entrySet()) {
            if (mqs.contains(entry.getKey())) {
                AtomicLong offset = entry.getValue();
                offsetSerializeWrapper.getOffsetTable().put(entry.getKey(), offset);
            }
        }
        String jsonString = offsetSerializeWrapper.toJson(true);
        if (jsonString == null)
            return;
        try {
            MixAll.string2File(jsonString, this.storePath);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 从文件中加载 offsetTable 信息
     *
     * @return offsetTable
     */
    private OffsetSerializeWrapper readLocalOffset() {
        String content = null;
        try {
            content = MixAll.file2String(this.storePath);
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (content == null || content.length() == 0)
            return null;

        OffsetSerializeWrapper offsetSerializeWrapper = null;
        try {
            offsetSerializeWrapper =
                    OffsetSerializeWrapper.fromJson(content, OffsetSerializeWrapper.class);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return offsetSerializeWrapper;
    }

}

        DefaultMQPushConsumer 类里有个函数用来设置从哪儿开始消费消息:

         注意设置读取位置不是每次都有效,它的优先级默认在 Offset Store 后面 ,比如 在 DefaultMQPushConsumer 的 BROADCASTING 方式下 ,默认是 从Broker 里读取某个 Topic 对应 ConsumerGroup 的 Offset , 当读取不到 Offset 的时候, ConsumeFromWhere 的设置才生效 。 大部分情况下这个设置在 ConsumerGroup 初次启动时有效。 如果 Consumer 正常运行后被停止, 然后再启动, 会接着上次的 Offset 开始消费, ConsumeFromWhere 的设置无效 。

Chapter3-用适合的方式发送和接收消息_第22张图片

 3.4 自定义日志输出

          RocketMQ 的 默认 Log 存储位置是:$ {user.home }/Logs/rocketmqLogs, Lo g 配置文件的设置可以通过 JVM启动参数、 环境变量、 代码中的设置语句这三种方式来配置 。

        可以在程序,中使用 System . setProperty(”rocketmq.Client.Log.loadconfig ”,” false ”) 语 句, 或者在 JVM 启动时使用 - D 参数来设置。然后把 Logback.xml 放到 maven 项目的
resources 文件夹下 。 在 Logback .xml 示例配置里,在原有 RocketMQ 日志的基础上,增加了 STDOUT 输出,这样可以把 RocketMQ 的日志输出到应用系统console 中,便于调试时发现问题

第 3 章:配置 (qos.ch)https://logback.qos.ch/manual/configuration.html

你可能感兴趣的:(Java,mq,java,mq)