rocketmq-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ifplu...@apache.org
Subject [rocketmq-client-cpp] 13/29: style: rename accessors and mutators
Date Tue, 29 Dec 2020 03:36:30 GMT
This is an automated email from the ASF dual-hosted git repository.

ifplusor pushed a commit to branch re_dev
in repository https://gitbox.apache.org/repos/asf/rocketmq-client-cpp.git

commit 793d13ae2b9266e2c413edd0540637f89dee8ba2
Author: James Yin <ywhjames@hotmail.com>
AuthorDate: Wed Jul 29 19:46:12 2020 +0800

    style: rename accessors and mutators
---
 example/AsyncProducer.cpp                          |  16 +--
 example/BatchProducer.cpp                          |  19 ++-
 example/OrderlyProducer.cpp                        |  19 ++-
 example/OrderlyPushConsumer.cpp                    |  16 +--
 example/PullConsumer.cpp                           |   4 +-
 example/PushConsumer.cpp                           |  16 +--
 example/RequestReply.cpp                           |  26 ++--
 example/SendDelayMsg.cpp                           |  12 +-
 example/SyncProducer.cpp                           |  19 ++-
 example/TransactionProducer.cpp                    |  21 ++--
 example/common.h                                   |   2 +-
 include/DefaultMQProducer.h                        |   4 +-
 include/DefaultMQProducerConfig.h                  |  32 ++---
 include/DefaultMQProducerConfigProxy.h             |  64 +++++-----
 include/DefaultMQPushConsumerConfig.h              |  40 +++---
 include/DefaultMQPushConsumerConfigProxy.h         |  80 ++++++------
 include/MQClientConfig.h                           |  31 ++---
 include/MQClientConfigProxy.h                      |  53 +++-----
 include/MQMessage.h                                |  44 +++----
 include/MQMessageExt.h                             |  56 ++++-----
 include/Message.h                                  |  55 ++++-----
 include/MessageExt.h                               |  56 ++++-----
 include/QueryResult.h                              |  12 +-
 include/SendResult.h                               |  19 +--
 include/SessionCredentials.h                       |  22 ++--
 include/TransactionSendResult.h                    |   4 +-
 src/ClientRemotingProcessor.cpp                    |  24 ++--
 src/MQClientAPIImpl.cpp                            |  18 +--
 src/MQClientConfigImpl.hpp                         |  47 +++----
 src/MQClientInstance.cpp                           |   2 +-
 src/common/ClientRPCHook.cpp                       |  10 +-
 src/common/SendCallbackWrap.cpp                    |   2 +-
 src/common/Validators.cpp                          |   4 +-
 src/consumer/ConsumeMessageConcurrentlyService.cpp |   8 +-
 src/consumer/ConsumeMessageOrderlyService.cpp      |   4 +-
 src/consumer/DefaultMQPullConsumer.cpp             |   4 +-
 src/consumer/DefaultMQPushConsumer.cpp             |   4 +-
 src/consumer/DefaultMQPushConsumerConfigImpl.hpp   |  46 +++----
 src/consumer/DefaultMQPushConsumerImpl.cpp         | 112 ++++++++---------
 src/consumer/ProcessQueue.cpp                      |  10 +-
 src/consumer/PullAPIWrapper.cpp                    |   4 +-
 src/consumer/RebalancePushImpl.cpp                 |   4 +-
 src/extern/CMessage.cpp                            |  24 ++--
 src/extern/CMessageExt.cpp                         |  28 ++---
 src/extern/CProducer.cpp                           |  56 ++++-----
 src/extern/CPullConsumer.cpp                       |   6 +-
 src/extern/CPushConsumer.cpp                       |  18 +--
 src/message/MQMessage.cpp                          |  88 +++++++-------
 src/message/MQMessageExt.cpp                       | 112 ++++++++---------
 src/message/MessageAccessor.hpp                    |   2 +-
 src/message/MessageBatch.cpp                       |  14 +--
 src/message/MessageDecoder.cpp                     |  44 +++----
 src/message/MessageExtImpl.cpp                     |  74 +++++------
 src/message/MessageExtImpl.h                       |  70 +++++------
 src/message/MessageImpl.cpp                        |  88 +++++++-------
 src/message/MessageImpl.h                          |  44 +++----
 src/producer/DefaultMQProducer.cpp                 |  10 +-
 src/producer/DefaultMQProducerConfigImpl.hpp       |  28 ++---
 src/producer/DefaultMQProducerImpl.cpp             | 135 +++++++++++----------
 test/src/common/ClientRPCHookTest.cpp              |   6 +-
 test/src/extern/CMessageExtTest.cpp                |  56 ++++-----
 test/src/extern/CMessageTest.cpp                   |  16 +--
 test/src/extern/CProducerTest.cpp                  |  14 +--
 test/src/extern/CPullConsumerTest.cpp              |   8 +-
 test/src/extern/CPushConsumerTest.cpp              |  10 +-
 test/src/message/MQMessageExtTest.cpp              | 108 ++++++++---------
 test/src/message/MQMessageTest.cpp                 | 124 +++++++++----------
 test/src/message/MessageDecoderTest.cpp            |  46 +++----
 68 files changed, 1133 insertions(+), 1141 deletions(-)

diff --git a/example/AsyncProducer.cpp b/example/AsyncProducer.cpp
index 9a5ea45..cee48ed 100644
--- a/example/AsyncProducer.cpp
+++ b/example/AsyncProducer.cpp
@@ -71,14 +71,14 @@ int main(int argc, char* argv[]) {
   PrintRocketmqSendAndConsumerArgs(info);
 
   auto* producer = new DefaultMQProducer(info.groupname);
-  producer->setNamesrvAddr(info.namesrv);
-  producer->setGroupName(info.groupname);
-  producer->setSendMsgTimeout(3000);
-  producer->setRetryTimes(info.retrytimes);
-  producer->setRetryTimesForAsync(info.retrytimes);
-  producer->setSendLatencyFaultEnable(!info.selectUnactiveBroker);
-  producer->setTcpTransportTryLockTimeout(1000);
-  producer->setTcpTransportConnectTimeout(400);
+  producer->set_namesrv_addr(info.namesrv);
+  producer->set_group_name(info.groupname);
+  producer->set_send_msg_timeout(3000);
+  producer->set_retry_times(info.retrytimes);
+  producer->set_retry_times_for_async(info.retrytimes);
+  producer->set_send_latency_fault_enable(!info.selectUnactiveBroker);
+  producer->set_tcp_transport_try_lock_timeout(1000);
+  producer->set_tcp_transport_connect_timeout(400);
   producer->start();
 
   std::vector<std::shared_ptr<std::thread>> work_pool;
diff --git a/example/BatchProducer.cpp b/example/BatchProducer.cpp
index 68883e3..c417ded 100644
--- a/example/BatchProducer.cpp
+++ b/example/BatchProducer.cpp
@@ -46,8 +46,7 @@ void SyncProducerWorker(RocketmqSendAndConsumerArgs* info, DefaultMQProducer* pr
 
       auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
       if (duration.count() >= 500) {
-        std::cout << "send RT more than: " << duration.count() << "ms with msgid: " << sendResult.getMsgId()
-                  << std::endl;
+        std::cout << "send RT more than: " << duration.count() << "ms with msgid: " << sendResult.msg_id() << std::endl;
       }
     } catch (const MQException& e) {
       std::cout << "send failed: " << e.what() << std::endl;
@@ -63,14 +62,14 @@ int main(int argc, char* argv[]) {
   PrintRocketmqSendAndConsumerArgs(info);
 
   auto* producer = new DefaultMQProducer(info.groupname);
-  producer->setNamesrvAddr(info.namesrv);
-  producer->setGroupName(info.groupname);
-  producer->setSendMsgTimeout(3000);
-  producer->setRetryTimes(info.retrytimes);
-  producer->setRetryTimesForAsync(info.retrytimes);
-  producer->setSendLatencyFaultEnable(!info.selectUnactiveBroker);
-  producer->setTcpTransportTryLockTimeout(1000);
-  producer->setTcpTransportConnectTimeout(400);
+  producer->set_namesrv_addr(info.namesrv);
+  producer->set_group_name(info.groupname);
+  producer->set_send_msg_timeout(3000);
+  producer->set_retry_times(info.retrytimes);
+  producer->set_retry_times_for_async(info.retrytimes);
+  producer->set_send_latency_fault_enable(!info.selectUnactiveBroker);
+  producer->set_tcp_transport_try_lock_timeout(1000);
+  producer->set_tcp_transport_connect_timeout(400);
   producer->start();
 
   std::vector<std::shared_ptr<std::thread>> work_pool;
diff --git a/example/OrderlyProducer.cpp b/example/OrderlyProducer.cpp
index 45538ba..5c555ee 100644
--- a/example/OrderlyProducer.cpp
+++ b/example/OrderlyProducer.cpp
@@ -47,8 +47,7 @@ void ProducerWorker(RocketmqSendAndConsumerArgs* info, DefaultMQProducer* produc
 
       auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
       if (duration.count() >= 500) {
-        std::cout << "send RT more than: " << duration.count() << "ms with msgid: " << sendResult.getMsgId()
-                  << std::endl;
+        std::cout << "send RT more than: " << duration.count() << "ms with msgid: " << sendResult.msg_id() << std::endl;
       }
     } catch (const MQException& e) {
       std::cout << "send failed: " << e.what() << std::endl;
@@ -64,14 +63,14 @@ int main(int argc, char* argv[]) {
   PrintRocketmqSendAndConsumerArgs(info);
 
   auto* producer = new DefaultMQProducer(info.groupname);
-  producer->setNamesrvAddr(info.namesrv);
-  producer->setGroupName(info.groupname);
-  producer->setSendMsgTimeout(3000);
-  producer->setRetryTimes(info.retrytimes);
-  producer->setRetryTimesForAsync(info.retrytimes);
-  producer->setSendLatencyFaultEnable(!info.selectUnactiveBroker);
-  producer->setTcpTransportTryLockTimeout(1000);
-  producer->setTcpTransportConnectTimeout(400);
+  producer->set_namesrv_addr(info.namesrv);
+  producer->set_group_name(info.groupname);
+  producer->set_send_msg_timeout(3000);
+  producer->set_retry_times(info.retrytimes);
+  producer->set_retry_times_for_async(info.retrytimes);
+  producer->set_send_latency_fault_enable(!info.selectUnactiveBroker);
+  producer->set_tcp_transport_try_lock_timeout(1000);
+  producer->set_tcp_transport_connect_timeout(400);
   producer->start();
 
   std::vector<std::shared_ptr<std::thread>> work_pool;
diff --git a/example/OrderlyPushConsumer.cpp b/example/OrderlyPushConsumer.cpp
index 02887c6..5f2454f 100644
--- a/example/OrderlyPushConsumer.cpp
+++ b/example/OrderlyPushConsumer.cpp
@@ -33,7 +33,7 @@ class MyMsgListener : public MessageListenerOrderly {
     if (old > 0) {
       for (size_t i = 0; i < msgs.size(); ++i) {
         g_tps.Increment();
-        std::cout << msgs[i].getMsgId() << ", body: " << msgs[i].getBody() << std::endl;
+        std::cout << msgs[i].msg_id() << ", body: " << msgs[i].body() << std::endl;
       }
       if (old <= msgs.size()) {
         g_finished.count_down();
@@ -53,13 +53,13 @@ int main(int argc, char* argv[]) {
   PrintRocketmqSendAndConsumerArgs(info);
 
   auto* consumer = new DefaultMQPushConsumer(info.groupname);
-  consumer->setNamesrvAddr(info.namesrv);
-  consumer->setGroupName(info.groupname);
-  consumer->setTcpTransportTryLockTimeout(1000);
-  consumer->setTcpTransportConnectTimeout(400);
-  consumer->setConsumeThreadNum(info.thread_count);
-  consumer->setConsumeMessageBatchMaxSize(31);
-  consumer->setConsumeFromWhere(CONSUME_FROM_LAST_OFFSET);
+  consumer->set_namesrv_addr(info.namesrv);
+  consumer->set_group_name(info.groupname);
+  consumer->set_tcp_transport_try_lock_timeout(1000);
+  consumer->set_tcp_transport_connect_timeout(400);
+  consumer->set_consume_thread_nums(info.thread_count);
+  consumer->set_consume_message_batch_max_size(31);
+  consumer->set_consume_from_where(CONSUME_FROM_LAST_OFFSET);
   consumer->subscribe(info.topic, "*");
 
   MyMsgListener msglistener;
diff --git a/example/PullConsumer.cpp b/example/PullConsumer.cpp
index f376201..a05b383 100644
--- a/example/PullConsumer.cpp
+++ b/example/PullConsumer.cpp
@@ -49,8 +49,8 @@ int main(int argc, char* argv[]) {
   }
   PrintRocketmqSendAndConsumerArgs(info);
   DefaultMQPullConsumer consumer("please_rename_unique_group_name");
-  consumer.setNamesrvAddr(info.namesrv);
-  consumer.setGroupName(info.groupname);
+  consumer.set_namesrv_addr(info.namesrv);
+  consumer.set_group_name(info.groupname);
   consumer.registerMessageQueueListener(info.topic, NULL);
   consumer.start();
   std::vector<MQMessageQueue> mqs;
diff --git a/example/PushConsumer.cpp b/example/PushConsumer.cpp
index ff9c055..f44ac95 100644
--- a/example/PushConsumer.cpp
+++ b/example/PushConsumer.cpp
@@ -36,7 +36,7 @@ class MyMsgListener : public MessageListenerConcurrently {
         if (msgs[i] == nullptr) {
           std::cout << "error!!!" << std::endl;
         } else {
-          std::cout << msgs[i].getMsgId() << ", body: " << msgs[i].getBody() << std::endl;
+          std::cout << msgs[i].msg_id() << ", body: " << msgs[i].body() << std::endl;
         }
       }
       if (old <= msgs.size()) {
@@ -57,15 +57,15 @@ int main(int argc, char* argv[]) {
   PrintRocketmqSendAndConsumerArgs(info);
 
   auto* consumer = new DefaultMQPushConsumer(info.groupname);
-  consumer->setNamesrvAddr(info.namesrv);
-  consumer->setGroupName(info.groupname);
-  consumer->setTcpTransportTryLockTimeout(1000);
-  consumer->setTcpTransportConnectTimeout(400);
-  consumer->setConsumeThreadNum(info.thread_count);
-  consumer->setConsumeFromWhere(CONSUME_FROM_LAST_OFFSET);
+  consumer->set_namesrv_addr(info.namesrv);
+  consumer->set_group_name(info.groupname);
+  consumer->set_tcp_transport_try_lock_timeout(1000);
+  consumer->set_tcp_transport_connect_timeout(400);
+  consumer->set_consume_thread_nums(info.thread_count);
+  consumer->set_consume_from_where(CONSUME_FROM_LAST_OFFSET);
 
   if (info.broadcasting) {
-    consumer->setMessageModel(BROADCASTING);
+    consumer->set_message_model(BROADCASTING);
   }
 
   consumer->subscribe(info.topic, "*");
diff --git a/example/RequestReply.cpp b/example/RequestReply.cpp
index 6564183..79b4212 100644
--- a/example/RequestReply.cpp
+++ b/example/RequestReply.cpp
@@ -60,24 +60,24 @@ int main(int argc, char* argv[]) {
   PrintRocketmqSendAndConsumerArgs(info);
 
   DefaultMQProducer producer("");
-  producer.setNamesrvAddr(info.namesrv);
-  producer.setSendMsgTimeout(3000);
-  producer.setRetryTimes(info.retrytimes);
-  producer.setRetryTimesForAsync(info.retrytimes);
-  producer.setSendLatencyFaultEnable(!info.selectUnactiveBroker);
-  producer.setTcpTransportTryLockTimeout(1000);
-  producer.setTcpTransportConnectTimeout(400);
+  producer.set_namesrv_addr(info.namesrv);
+  producer.set_send_msg_timeout(3000);
+  producer.set_retry_times(info.retrytimes);
+  producer.set_retry_times_for_async(info.retrytimes);
+  producer.set_send_latency_fault_enable(!info.selectUnactiveBroker);
+  producer.set_tcp_transport_try_lock_timeout(1000);
+  producer.set_tcp_transport_connect_timeout(400);
   producer.start();
 
   DefaultMQPushConsumer consumer(info.groupname);
-  consumer.setNamesrvAddr(info.namesrv);
-  consumer.setTcpTransportTryLockTimeout(1000);
-  consumer.setTcpTransportConnectTimeout(400);
-  consumer.setConsumeThreadNum(info.thread_count);
-  consumer.setConsumeFromWhere(CONSUME_FROM_LAST_OFFSET);
+  consumer.set_namesrv_addr(info.namesrv);
+  consumer.set_tcp_transport_try_lock_timeout(1000);
+  consumer.set_tcp_transport_connect_timeout(400);
+  consumer.set_consume_thread_nums(info.thread_count);
+  consumer.set_consume_from_where(CONSUME_FROM_LAST_OFFSET);
 
   // recommend client configs
-  consumer.setPullTimeDelayMillsWhenException(0L);
+  consumer.set_pull_time_delay_mills_when_exception(0L);
 
   consumer.subscribe(info.topic, "*");
 
diff --git a/example/SendDelayMsg.cpp b/example/SendDelayMsg.cpp
index dd0ba72..34742b4 100644
--- a/example/SendDelayMsg.cpp
+++ b/example/SendDelayMsg.cpp
@@ -27,11 +27,11 @@ int main(int argc, char* argv[]) {
   PrintRocketmqSendAndConsumerArgs(info);
 
   auto* producer = new DefaultMQProducer(info.groupname);
-  producer->setNamesrvAddr(info.namesrv);
-  producer->setGroupName(info.groupname);
-  producer->setSendMsgTimeout(3000);
-  producer->setTcpTransportTryLockTimeout(1000);
-  producer->setTcpTransportConnectTimeout(400);
+  producer->set_namesrv_addr(info.namesrv);
+  producer->set_group_name(info.groupname);
+  producer->set_send_msg_timeout(3000);
+  producer->set_tcp_transport_try_lock_timeout(1000);
+  producer->set_tcp_transport_connect_timeout(400);
   producer->start();
 
   MQMessage msg(info.topic,  // topic
@@ -39,7 +39,7 @@ int main(int argc, char* argv[]) {
                 info.body);  // body
 
   // messageDelayLevel=1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h
-  msg.setDelayTimeLevel(5);  // 1m
+  msg.set_delay_time_level(5);  // 1m
   try {
     SendResult sendResult = producer->send(msg);
   } catch (const MQException& e) {
diff --git a/example/SyncProducer.cpp b/example/SyncProducer.cpp
index 69461ee..1668ea5 100644
--- a/example/SyncProducer.cpp
+++ b/example/SyncProducer.cpp
@@ -35,8 +35,7 @@ void SyncProducerWorker(RocketmqSendAndConsumerArgs* info, DefaultMQProducer* pr
 
       auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
       if (duration.count() >= 500) {
-        std::cout << "send RT more than: " << duration.count() << "ms with msgid: " << sendResult.getMsgId()
-                  << std::endl;
+        std::cout << "send RT more than: " << duration.count() << "ms with msgid: " << sendResult.msg_id() << std::endl;
       }
     } catch (const MQException& e) {
       std::cout << "send failed: " << e.what() << std::endl;
@@ -52,14 +51,14 @@ int main(int argc, char* argv[]) {
   PrintRocketmqSendAndConsumerArgs(info);
 
   auto* producer = new DefaultMQProducer(info.groupname);
-  producer->setNamesrvAddr(info.namesrv);
-  producer->setGroupName(info.groupname);
-  producer->setSendMsgTimeout(3000);
-  producer->setRetryTimes(info.retrytimes);
-  producer->setRetryTimesForAsync(info.retrytimes);
-  producer->setSendLatencyFaultEnable(!info.selectUnactiveBroker);
-  producer->setTcpTransportTryLockTimeout(1000);
-  producer->setTcpTransportConnectTimeout(400);
+  producer->set_namesrv_addr(info.namesrv);
+  producer->set_group_name(info.groupname);
+  producer->set_send_msg_timeout(3000);
+  producer->set_retry_times(info.retrytimes);
+  producer->set_retry_times_for_async(info.retrytimes);
+  producer->set_send_latency_fault_enable(!info.selectUnactiveBroker);
+  producer->set_tcp_transport_try_lock_timeout(1000);
+  producer->set_tcp_transport_connect_timeout(400);
   producer->start();
 
   std::vector<std::shared_ptr<std::thread>> work_pool;
diff --git a/example/TransactionProducer.cpp b/example/TransactionProducer.cpp
index ac2e286..30b9482 100644
--- a/example/TransactionProducer.cpp
+++ b/example/TransactionProducer.cpp
@@ -24,7 +24,7 @@ TpsReportService g_tps;
 class MyTransactionListener : public TransactionListener {
   virtual LocalTransactionState executeLocalTransaction(const MQMessage& msg, void* arg) {
     LocalTransactionState state = (LocalTransactionState)(((intptr_t)arg) % 3);
-    std::cout << "executeLocalTransaction transactionId:" << msg.getTransactionId() << ", return state: " << state
+    std::cout << "executeLocalTransaction transactionId:" << msg.transaction_id() << ", return state: " << state
               << std::endl;
     return state;
   }
@@ -51,8 +51,7 @@ void SyncProducerWorker(RocketmqSendAndConsumerArgs* info, TransactionMQProducer
 
       auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
       if (duration.count() >= 500) {
-        std::cout << "send RT more than: " << duration.count() << "ms with msgid: " << sendResult.getMsgId()
-                  << std::endl;
+        std::cout << "send RT more than: " << duration.count() << "ms with msgid: " << sendResult.msg_id() << std::endl;
       }
     } catch (const MQException& e) {
       std::cout << "send failed: " << e.what() << std::endl;
@@ -69,14 +68,14 @@ int main(int argc, char* argv[]) {
   PrintRocketmqSendAndConsumerArgs(info);
 
   auto* producer = new TransactionMQProducer(info.groupname);
-  producer->setNamesrvAddr(info.namesrv);
-  producer->setGroupName(info.groupname);
-  producer->setSendMsgTimeout(3000);
-  producer->setRetryTimes(info.retrytimes);
-  producer->setRetryTimesForAsync(info.retrytimes);
-  producer->setSendLatencyFaultEnable(!info.selectUnactiveBroker);
-  producer->setTcpTransportTryLockTimeout(1000);
-  producer->setTcpTransportConnectTimeout(400);
+  producer->set_namesrv_addr(info.namesrv);
+  producer->set_group_name(info.groupname);
+  producer->set_send_msg_timeout(3000);
+  producer->set_retry_times(info.retrytimes);
+  producer->set_retry_times_for_async(info.retrytimes);
+  producer->set_send_latency_fault_enable(!info.selectUnactiveBroker);
+  producer->set_tcp_transport_try_lock_timeout(1000);
+  producer->set_tcp_transport_connect_timeout(400);
 
   MyTransactionListener myListener;
   producer->setTransactionListener(&myListener);
diff --git a/example/common.h b/example/common.h
index e3435ad..4834987 100644
--- a/example/common.h
+++ b/example/common.h
@@ -103,7 +103,7 @@ class TpsReportService {
 
 /*
 static void PrintResult(rocketmq::SendResult* result) {
-  std::cout << "sendresult = " << result->getSendStatus()
+  std::cout << "sendresult = " << result->send_status()
             << ", msgid = " << result->getMsgId()
             << ", queueOffset = " << result->getQueueOffset() << ","
             << result->getMessageQueue().toString() << endl;
diff --git a/include/DefaultMQProducer.h b/include/DefaultMQProducer.h
index 6405d64..ec5e5df 100644
--- a/include/DefaultMQProducer.h
+++ b/include/DefaultMQProducer.h
@@ -88,8 +88,8 @@ class ROCKETMQCLIENT_API DefaultMQProducer : public DefaultMQProducerConfigProxy
                long timeout) override;
 
  public:  // DefaultMQProducerConfig
-  bool isSendLatencyFaultEnable() const override;
-  void setSendLatencyFaultEnable(bool sendLatencyFaultEnable) override;
+  bool send_latency_fault_enable() const override;
+  void set_send_latency_fault_enable(bool sendLatencyFaultEnable) override;
 
  public:
   void setRPCHook(RPCHookPtr rpcHook);
diff --git a/include/DefaultMQProducerConfig.h b/include/DefaultMQProducerConfig.h
index dcee17a..46f9c2f 100644
--- a/include/DefaultMQProducerConfig.h
+++ b/include/DefaultMQProducerConfig.h
@@ -33,35 +33,35 @@ class ROCKETMQCLIENT_API DefaultMQProducerConfig : virtual public MQClientConfig
   virtual ~DefaultMQProducerConfig() = default;
 
   // if msgbody size larger than maxMsgBodySize, exception will be throwed
-  virtual int getMaxMessageSize() const = 0;
-  virtual void setMaxMessageSize(int maxMessageSize) = 0;
+  virtual int max_message_size() const = 0;
+  virtual void set_max_message_size(int maxMessageSize) = 0;
 
   /*
    * if msgBody size is large than m_compressMsgBodyOverHowmuch
    *  rocketmq cpp will compress msgBody according to compressLevel
    */
-  virtual int getCompressMsgBodyOverHowmuch() const = 0;
-  virtual void setCompressMsgBodyOverHowmuch(int compressMsgBodyOverHowmuch) = 0;
+  virtual int compress_msg_body_over_howmuch() const = 0;
+  virtual void set_compress_msg_body_over_howmuch(int compressMsgBodyOverHowmuch) = 0;
 
-  virtual int getCompressLevel() const = 0;
-  virtual void setCompressLevel(int compressLevel) = 0;
+  virtual int compress_level() const = 0;
+  virtual void set_compress_level(int compressLevel) = 0;
 
   // set and get timeout of per msg
-  virtual int getSendMsgTimeout() const = 0;
-  virtual void setSendMsgTimeout(int sendMsgTimeout) = 0;
+  virtual int send_msg_timeout() const = 0;
+  virtual void set_send_msg_timeout(int sendMsgTimeout) = 0;
 
   // set msg max retry times, default retry times is 5
-  virtual int getRetryTimes() const = 0;
-  virtual void setRetryTimes(int times) = 0;
+  virtual int retry_times() const = 0;
+  virtual void set_retry_times(int times) = 0;
 
-  virtual int getRetryTimesForAsync() const = 0;
-  virtual void setRetryTimesForAsync(int times) = 0;
+  virtual int retry_times_for_async() const = 0;
+  virtual void set_retry_times_for_async(int times) = 0;
 
-  virtual bool isRetryAnotherBrokerWhenNotStoreOK() const = 0;
-  virtual void setRetryAnotherBrokerWhenNotStoreOK(bool retryAnotherBrokerWhenNotStoreOK) = 0;
+  virtual bool retry_another_broker_when_not_store_ok() const = 0;
+  virtual void set_retry_another_broker_when_not_store_ok(bool retryAnotherBrokerWhenNotStoreOK) = 0;
 
-  virtual bool isSendLatencyFaultEnable() const { return false; };
-  virtual void setSendLatencyFaultEnable(bool sendLatencyFaultEnable){};
+  virtual bool send_latency_fault_enable() const { return false; };
+  virtual void set_send_latency_fault_enable(bool sendLatencyFaultEnable){};
 };
 
 }  // namespace rocketmq
diff --git a/include/DefaultMQProducerConfigProxy.h b/include/DefaultMQProducerConfigProxy.h
index deeb879..b879b43 100644
--- a/include/DefaultMQProducerConfigProxy.h
+++ b/include/DefaultMQProducerConfigProxy.h
@@ -32,70 +32,70 @@ class ROCKETMQCLIENT_API DefaultMQProducerConfigProxy : public MQClientConfigPro
   DefaultMQProducerConfigProxy(DefaultMQProducerConfigPtr producerConfig) : MQClientConfigProxy(producerConfig) {}
   virtual ~DefaultMQProducerConfigProxy() = default;
 
-  inline int getMaxMessageSize() const override {
-    return dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->getMaxMessageSize();
+  int max_message_size() const override {
+    return dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->max_message_size();
   }
 
-  inline void setMaxMessageSize(int maxMessageSize) override {
-    dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->setMaxMessageSize(maxMessageSize);
+  void set_max_message_size(int maxMessageSize) override {
+    dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->set_max_message_size(maxMessageSize);
   }
 
-  inline int getCompressMsgBodyOverHowmuch() const override {
-    return dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->getCompressMsgBodyOverHowmuch();
+  int compress_msg_body_over_howmuch() const override {
+    return dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->compress_msg_body_over_howmuch();
   }
 
-  inline void setCompressMsgBodyOverHowmuch(int compressMsgBodyOverHowmuch) override {
+  void set_compress_msg_body_over_howmuch(int compressMsgBodyOverHowmuch) override {
     dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())
-        ->setCompressMsgBodyOverHowmuch(compressMsgBodyOverHowmuch);
+        ->set_compress_msg_body_over_howmuch(compressMsgBodyOverHowmuch);
   }
 
-  inline int getCompressLevel() const override {
-    return dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->getCompressLevel();
+  int compress_level() const override {
+    return dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->compress_level();
   }
 
-  inline void setCompressLevel(int compressLevel) override {
-    dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->setCompressLevel(compressLevel);
+  void set_compress_level(int compressLevel) override {
+    dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->set_compress_level(compressLevel);
   }
 
-  inline int getSendMsgTimeout() const override {
-    return dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->getSendMsgTimeout();
+  int send_msg_timeout() const override {
+    return dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->send_msg_timeout();
   }
 
-  inline void setSendMsgTimeout(int sendMsgTimeout) override {
-    dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->setSendMsgTimeout(sendMsgTimeout);
+  void set_send_msg_timeout(int sendMsgTimeout) override {
+    dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->set_send_msg_timeout(sendMsgTimeout);
   }
 
-  inline int getRetryTimes() const override {
-    return dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->getRetryTimes();
+  int retry_times() const override {
+    return dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->retry_times();
   }
 
-  inline void setRetryTimes(int times) override {
-    dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->setRetryTimes(times);
+  void set_retry_times(int times) override {
+    dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->set_retry_times(times);
   }
 
-  inline int getRetryTimesForAsync() const override {
-    return dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->getRetryTimesForAsync();
+  int retry_times_for_async() const override {
+    return dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->retry_times_for_async();
   }
 
-  inline void setRetryTimesForAsync(int times) override {
-    dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->setRetryTimesForAsync(times);
+  void set_retry_times_for_async(int times) override {
+    dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->set_retry_times_for_async(times);
   }
 
-  inline bool isRetryAnotherBrokerWhenNotStoreOK() const override {
-    return dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->isRetryAnotherBrokerWhenNotStoreOK();
+  bool retry_another_broker_when_not_store_ok() const override {
+    return dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->retry_another_broker_when_not_store_ok();
   }
 
-  inline void setRetryAnotherBrokerWhenNotStoreOK(bool retryAnotherBrokerWhenNotStoreOK) override {
+  void set_retry_another_broker_when_not_store_ok(bool retryAnotherBrokerWhenNotStoreOK) override {
     dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())
-        ->setRetryAnotherBrokerWhenNotStoreOK(retryAnotherBrokerWhenNotStoreOK);
+        ->set_retry_another_broker_when_not_store_ok(retryAnotherBrokerWhenNotStoreOK);
   }
 
-  inline bool isSendLatencyFaultEnable() const override {
-    return dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->isSendLatencyFaultEnable();
+  bool send_latency_fault_enable() const override {
+    return dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->send_latency_fault_enable();
   }
 
-  inline void setSendLatencyFaultEnable(bool sendLatencyFaultEnable) override {
-    dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->setSendLatencyFaultEnable(sendLatencyFaultEnable);
+  void set_send_latency_fault_enable(bool sendLatencyFaultEnable) override {
+    dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->set_send_latency_fault_enable(sendLatencyFaultEnable);
   }
 
   inline DefaultMQProducerConfigPtr real_config() const {
diff --git a/include/DefaultMQPushConsumerConfig.h b/include/DefaultMQPushConsumerConfig.h
index c154007..ee3988e 100644
--- a/include/DefaultMQPushConsumerConfig.h
+++ b/include/DefaultMQPushConsumerConfig.h
@@ -34,45 +34,45 @@ class ROCKETMQCLIENT_API DefaultMQPushConsumerConfig : virtual public MQClientCo
  public:
   virtual ~DefaultMQPushConsumerConfig() = default;
 
-  virtual MessageModel getMessageModel() const = 0;
-  virtual void setMessageModel(MessageModel messageModel) = 0;
+  virtual MessageModel message_model() const = 0;
+  virtual void set_message_model(MessageModel messageModel) = 0;
 
-  virtual ConsumeFromWhere getConsumeFromWhere() const = 0;
-  virtual void setConsumeFromWhere(ConsumeFromWhere consumeFromWhere) = 0;
+  virtual ConsumeFromWhere consume_from_where() const = 0;
+  virtual void set_consume_from_where(ConsumeFromWhere consumeFromWhere) = 0;
 
-  virtual const std::string& getConsumeTimestamp() const = 0;
-  virtual void setConsumeTimestamp(const std::string& consumeTimestamp) = 0;
+  virtual const std::string& consume_timestamp() const = 0;
+  virtual void set_consume_timestamp(const std::string& consumeTimestamp) = 0;
 
   /**
    * consuming thread count, default value is cpu cores
    */
-  virtual int getConsumeThreadNum() const = 0;
-  virtual void setConsumeThreadNum(int threadNum) = 0;
+  virtual int consume_thread_nums() const = 0;
+  virtual void set_consume_thread_nums(int threadNum) = 0;
 
   /**
    * the pull number of message size by each pullMsg for orderly consume, default value is 1
    */
-  virtual int getConsumeMessageBatchMaxSize() const = 0;
-  virtual void setConsumeMessageBatchMaxSize(int consumeMessageBatchMaxSize) = 0;
+  virtual int consume_message_batch_max_size() const = 0;
+  virtual void set_consume_message_batch_max_size(int consumeMessageBatchMaxSize) = 0;
 
   /**
    * max cache msg size per Queue in memory if consumer could not consume msgs immediately,
    * default maxCacheMsgSize per Queue is 1000, set range is:1~65535
    */
-  virtual int getMaxCacheMsgSizePerQueue() const = 0;
-  virtual void setMaxCacheMsgSizePerQueue(int maxCacheSize) = 0;
+  virtual int max_cache_msg_size_per_queue() const = 0;
+  virtual void set_max_cache_msg_size_per_queue(int maxCacheSize) = 0;
 
-  virtual int getAsyncPullTimeout() const = 0;
-  virtual void setAsyncPullTimeout(int asyncPullTimeout) = 0;
+  virtual int async_pull_timeout() const = 0;
+  virtual void set_async_pull_timeout(int asyncPullTimeout) = 0;
 
-  virtual int getMaxReconsumeTimes() const = 0;
-  virtual void setMaxReconsumeTimes(int maxReconsumeTimes) = 0;
+  virtual int max_reconsume_times() const = 0;
+  virtual void set_max_reconsume_times(int maxReconsumeTimes) = 0;
 
-  virtual long getPullTimeDelayMillsWhenException() const = 0;
-  virtual void setPullTimeDelayMillsWhenException(long pullTimeDelayMillsWhenException) = 0;
+  virtual long pull_time_delay_mills_when_exception() const = 0;
+  virtual void set_pull_time_delay_mills_when_exception(long pullTimeDelayMillsWhenException) = 0;
 
-  virtual AllocateMQStrategy* getAllocateMQStrategy() const = 0;
-  virtual void setAllocateMQStrategy(AllocateMQStrategy* strategy) = 0;
+  virtual AllocateMQStrategy* allocate_mq_strategy() const = 0;
+  virtual void set_allocate_mq_strategy(AllocateMQStrategy* strategy) = 0;
 };
 
 }  // namespace rocketmq
diff --git a/include/DefaultMQPushConsumerConfigProxy.h b/include/DefaultMQPushConsumerConfigProxy.h
index 3ff22b3..4a0c22f 100644
--- a/include/DefaultMQPushConsumerConfigProxy.h
+++ b/include/DefaultMQPushConsumerConfigProxy.h
@@ -30,86 +30,86 @@ class ROCKETMQCLIENT_API DefaultMQPushConsumerConfigProxy : public MQClientConfi
       : MQClientConfigProxy(consumerConfig) {}
   virtual ~DefaultMQPushConsumerConfigProxy() = default;
 
-  inline MessageModel getMessageModel() const override {
-    return dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->getMessageModel();
+  MessageModel message_model() const override {
+    return dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->message_model();
   }
 
-  inline void setMessageModel(MessageModel messageModel) override {
-    dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->setMessageModel(messageModel);
+  void set_message_model(MessageModel messageModel) override {
+    dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->set_message_model(messageModel);
   }
 
-  inline ConsumeFromWhere getConsumeFromWhere() const override {
-    return dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->getConsumeFromWhere();
+  ConsumeFromWhere consume_from_where() const override {
+    return dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->consume_from_where();
   }
 
-  inline void setConsumeFromWhere(ConsumeFromWhere consumeFromWhere) override {
-    dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->setConsumeFromWhere(consumeFromWhere);
+  void set_consume_from_where(ConsumeFromWhere consumeFromWhere) override {
+    dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->set_consume_from_where(consumeFromWhere);
   }
 
-  inline const std::string& getConsumeTimestamp() const override {
-    return dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->getConsumeTimestamp();
+  const std::string& consume_timestamp() const override {
+    return dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->consume_timestamp();
   }
 
-  inline void setConsumeTimestamp(const std::string& consumeTimestamp) override {
-    dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->setConsumeTimestamp(consumeTimestamp);
+  void set_consume_timestamp(const std::string& consumeTimestamp) override {
+    dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->set_consume_timestamp(consumeTimestamp);
   }
 
-  inline int getConsumeThreadNum() const override {
-    return dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->getConsumeThreadNum();
+  int consume_thread_nums() const override {
+    return dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->consume_thread_nums();
   }
 
-  inline void setConsumeThreadNum(int threadNum) override {
-    dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->setConsumeThreadNum(threadNum);
+  void set_consume_thread_nums(int threadNum) override {
+    dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->set_consume_thread_nums(threadNum);
   }
 
-  inline int getConsumeMessageBatchMaxSize() const override {
-    return dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->getConsumeMessageBatchMaxSize();
+  int consume_message_batch_max_size() const override {
+    return dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->consume_message_batch_max_size();
   }
 
-  inline void setConsumeMessageBatchMaxSize(int consumeMessageBatchMaxSize) override {
+  void set_consume_message_batch_max_size(int consumeMessageBatchMaxSize) override {
     dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())
-        ->setConsumeMessageBatchMaxSize(consumeMessageBatchMaxSize);
+        ->set_consume_message_batch_max_size(consumeMessageBatchMaxSize);
   }
 
-  inline int getMaxCacheMsgSizePerQueue() const override {
-    return dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->getMaxCacheMsgSizePerQueue();
+  int max_cache_msg_size_per_queue() const override {
+    return dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->max_cache_msg_size_per_queue();
   }
 
-  inline void setMaxCacheMsgSizePerQueue(int maxCacheSize) override {
-    dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->setMaxCacheMsgSizePerQueue(maxCacheSize);
+  void set_max_cache_msg_size_per_queue(int maxCacheSize) override {
+    dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->set_max_cache_msg_size_per_queue(maxCacheSize);
   }
 
-  inline int getAsyncPullTimeout() const override {
-    return dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->getAsyncPullTimeout();
+  int async_pull_timeout() const override {
+    return dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->async_pull_timeout();
   }
 
-  inline void setAsyncPullTimeout(int asyncPullTimeout) override {
-    dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->setAsyncPullTimeout(asyncPullTimeout);
+  void set_async_pull_timeout(int asyncPullTimeout) override {
+    dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->set_async_pull_timeout(asyncPullTimeout);
   }
 
-  inline int getMaxReconsumeTimes() const override {
-    return dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->getMaxReconsumeTimes();
+  int max_reconsume_times() const override {
+    return dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->max_reconsume_times();
   }
 
-  inline void setMaxReconsumeTimes(int maxReconsumeTimes) override {
-    dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->setMaxReconsumeTimes(maxReconsumeTimes);
+  void set_max_reconsume_times(int maxReconsumeTimes) override {
+    dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->set_max_reconsume_times(maxReconsumeTimes);
   }
 
-  inline long getPullTimeDelayMillsWhenException() const override {
-    return dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->getPullTimeDelayMillsWhenException();
+  long pull_time_delay_mills_when_exception() const override {
+    return dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->pull_time_delay_mills_when_exception();
   }
 
-  inline void setPullTimeDelayMillsWhenException(long pullTimeDelayMillsWhenException) override {
+  void set_pull_time_delay_mills_when_exception(long pullTimeDelayMillsWhenException) override {
     dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())
-        ->setPullTimeDelayMillsWhenException(pullTimeDelayMillsWhenException);
+        ->set_pull_time_delay_mills_when_exception(pullTimeDelayMillsWhenException);
   }
 
-  inline AllocateMQStrategy* getAllocateMQStrategy() const override {
-    return dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->getAllocateMQStrategy();
+  AllocateMQStrategy* allocate_mq_strategy() const override {
+    return dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->allocate_mq_strategy();
   }
 
-  inline void setAllocateMQStrategy(AllocateMQStrategy* strategy) override {
-    dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->setAllocateMQStrategy(strategy);
+  void set_allocate_mq_strategy(AllocateMQStrategy* strategy) override {
+    dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->set_allocate_mq_strategy(strategy);
   }
 
   inline DefaultMQPushConsumerConfigPtr real_config() const {
diff --git a/include/MQClientConfig.h b/include/MQClientConfig.h
index c93dd2b..ade13f0 100644
--- a/include/MQClientConfig.h
+++ b/include/MQClientConfig.h
@@ -37,37 +37,38 @@ class ROCKETMQCLIENT_API MQClientConfig {
   // clientId = clientIP @ processId [ @ unitName ]
   virtual std::string buildMQClientId() const = 0;
 
-  virtual const std::string& getGroupName() const = 0;
-  virtual void setGroupName(const std::string& groupname) = 0;
+  virtual void changeInstanceNameToPID() = 0;
 
-  virtual const std::string& getNamesrvAddr() const = 0;
-  virtual void setNamesrvAddr(const std::string& namesrvAddr) = 0;
+ public:
+  virtual const std::string& group_name() const = 0;
+  virtual void set_group_name(const std::string& groupname) = 0;
 
-  virtual const std::string& getInstanceName() const = 0;
-  virtual void setInstanceName(const std::string& instanceName) = 0;
+  virtual const std::string& namesrv_addr() const = 0;
+  virtual void set_namesrv_addr(const std::string& namesrvAddr) = 0;
 
-  virtual void changeInstanceNameToPID() = 0;
+  virtual const std::string& instance_name() const = 0;
+  virtual void set_instance_name(const std::string& instanceName) = 0;
 
-  virtual const std::string& getUnitName() const = 0;
-  virtual void setUnitName(std::string unitName) = 0;
+  virtual const std::string& unit_name() const = 0;
+  virtual void set_unit_name(std::string unitName) = 0;
 
   /**
    * the num of threads to distribute network data
    **/
-  virtual int getTcpTransportWorkerThreadNum() const = 0;
-  virtual void setTcpTransportWorkerThreadNum(int num) = 0;
+  virtual int tcp_transport_worker_thread_nums() const = 0;
+  virtual void set_tcp_transport_worker_thread_nums(int num) = 0;
 
   /**
    * timeout of tcp connect
    **/
-  virtual uint64_t getTcpTransportConnectTimeout() const = 0;
-  virtual void setTcpTransportConnectTimeout(uint64_t timeout) = 0;  // ms
+  virtual uint64_t tcp_transport_connect_timeout() const = 0;
+  virtual void set_tcp_transport_connect_timeout(uint64_t timeout) = 0;  // ms
 
   /**
    * timeout of tryLock tcpTransport, the minimun value is 1000ms
    **/
-  virtual uint64_t getTcpTransportTryLockTimeout() const = 0;
-  virtual void setTcpTransportTryLockTimeout(uint64_t timeout) = 0;  // ms
+  virtual uint64_t tcp_transport_try_lock_timeout() const = 0;
+  virtual void set_tcp_transport_try_lock_timeout(uint64_t timeout) = 0;  // ms
 };
 
 }  // namespace rocketmq
diff --git a/include/MQClientConfigProxy.h b/include/MQClientConfigProxy.h
index 2e3b332..8cea1bb 100644
--- a/include/MQClientConfigProxy.h
+++ b/include/MQClientConfigProxy.h
@@ -30,48 +30,35 @@ class ROCKETMQCLIENT_API MQClientConfigProxy : virtual public MQClientConfig  //
   MQClientConfigProxy(MQClientConfigPtr clientConfig) : client_config_(clientConfig) {}
   virtual ~MQClientConfigProxy() = default;
 
-  inline std::string buildMQClientId() const override { return client_config_->buildMQClientId(); }
+  std::string buildMQClientId() const override { return client_config_->buildMQClientId(); }
+  void changeInstanceNameToPID() override { client_config_->changeInstanceNameToPID(); }
 
-  inline const std::string& getGroupName() const override { return client_config_->getGroupName(); }
-
-  inline void setGroupName(const std::string& groupname) override { client_config_->setGroupName(groupname); }
-
-  inline const std::string& getNamesrvAddr() const override { return client_config_->getNamesrvAddr(); }
-
-  inline void setNamesrvAddr(const std::string& namesrvAddr) override { client_config_->setNamesrvAddr(namesrvAddr); }
-
-  inline const std::string& getInstanceName() const override { return client_config_->getInstanceName(); }
-
-  inline void setInstanceName(const std::string& instanceName) override {
-    client_config_->setInstanceName(instanceName);
-  }
-
-  inline void changeInstanceNameToPID() override { client_config_->changeInstanceNameToPID(); }
-
-  inline const std::string& getUnitName() const override { return client_config_->getUnitName(); }
-
-  inline void setUnitName(std::string unitName) override { client_config_->setUnitName(unitName); }
+ public:
+  const std::string& group_name() const override { return client_config_->group_name(); }
+  void set_group_name(const std::string& groupname) override { client_config_->set_group_name(groupname); }
 
-  inline int getTcpTransportWorkerThreadNum() const override {
-    return client_config_->getTcpTransportWorkerThreadNum();
-  }
+  const std::string& namesrv_addr() const override { return client_config_->namesrv_addr(); }
+  void set_namesrv_addr(const std::string& namesrvAddr) override { client_config_->set_namesrv_addr(namesrvAddr); }
 
-  inline void setTcpTransportWorkerThreadNum(int num) override { client_config_->setTcpTransportWorkerThreadNum(num); }
+  const std::string& instance_name() const override { return client_config_->instance_name(); }
+  void set_instance_name(const std::string& instanceName) override { client_config_->set_instance_name(instanceName); }
 
-  inline uint64_t getTcpTransportConnectTimeout() const override {
-    return client_config_->getTcpTransportConnectTimeout();
-  }
+  const std::string& unit_name() const override { return client_config_->unit_name(); }
+  void set_unit_name(std::string unitName) override { client_config_->set_unit_name(unitName); }
 
-  inline void setTcpTransportConnectTimeout(uint64_t timeout) override {
-    client_config_->setTcpTransportConnectTimeout(timeout);
+  int tcp_transport_worker_thread_nums() const override { return client_config_->tcp_transport_worker_thread_nums(); }
+  void set_tcp_transport_worker_thread_nums(int num) override {
+    client_config_->set_tcp_transport_worker_thread_nums(num);
   }
 
-  inline uint64_t getTcpTransportTryLockTimeout() const override {
-    return client_config_->getTcpTransportTryLockTimeout();
+  uint64_t tcp_transport_connect_timeout() const override { return client_config_->tcp_transport_connect_timeout(); }
+  void set_tcp_transport_connect_timeout(uint64_t timeout) override {
+    client_config_->set_tcp_transport_connect_timeout(timeout);
   }
 
-  inline void setTcpTransportTryLockTimeout(uint64_t timeout) override {
-    client_config_->setTcpTransportTryLockTimeout(timeout);
+  uint64_t tcp_transport_try_lock_timeout() const override { return client_config_->tcp_transport_try_lock_timeout(); }
+  void set_tcp_transport_try_lock_timeout(uint64_t timeout) override {
+    client_config_->set_tcp_transport_try_lock_timeout(timeout);
   }
 
   inline MQClientConfigPtr real_config() const { return client_config_; }
diff --git a/include/MQMessage.h b/include/MQMessage.h
index c0786a7..84c4cbd 100644
--- a/include/MQMessage.h
+++ b/include/MQMessage.h
@@ -71,36 +71,36 @@ class ROCKETMQCLIENT_API MQMessage : virtual public Message  // interface
   void putProperty(const std::string& name, const std::string& value) override;
   void clearProperty(const std::string& name) override;
 
-  const std::string& getTopic() const override;
-  void setTopic(const std::string& topic) override;
-  void setTopic(const char* body, int len) override;
+  const std::string& topic() const override;
+  void set_topic(const std::string& topic) override;
+  void set_topic(const char* body, int len) override;
 
-  const std::string& getTags() const override;
-  void setTags(const std::string& tags) override;
+  const std::string& tags() const override;
+  void set_tags(const std::string& tags) override;
 
-  const std::string& getKeys() const override;
-  void setKeys(const std::string& keys) override;
-  void setKeys(const std::vector<std::string>& keys) override;
+  const std::string& keys() const override;
+  void set_keys(const std::string& keys) override;
+  void set_keys(const std::vector<std::string>& keys) override;
 
-  int getDelayTimeLevel() const override;
-  void setDelayTimeLevel(int level) override;
+  int delay_time_level() const override;
+  void set_delay_time_level(int level) override;
 
-  bool isWaitStoreMsgOK() const override;
-  void setWaitStoreMsgOK(bool waitStoreMsgOK) override;
+  bool wait_store_msg_ok() const override;
+  void set_wait_store_msg_ok(bool waitStoreMsgOK) override;
 
-  int32_t getFlag() const override;
-  void setFlag(int32_t flag) override;
+  int32_t flag() const override;
+  void set_flag(int32_t flag) override;
 
-  const std::string& getBody() const override;
-  void setBody(const std::string& body) override;
-  void setBody(std::string&& body) override;
+  const std::string& body() const override;
+  void set_body(const std::string& body) override;
+  void set_body(std::string&& body) override;
 
-  const std::string& getTransactionId() const override;
-  void setTransactionId(const std::string& transactionId) override;
+  const std::string& transaction_id() const override;
+  void set_transaction_id(const std::string& transactionId) override;
 
-  const std::map<std::string, std::string>& getProperties() const override;
-  void setProperties(const std::map<std::string, std::string>& properties) override;
-  void setProperties(std::map<std::string, std::string>&& properties) override;
+  const std::map<std::string, std::string>& properties() const override;
+  void set_properties(const std::map<std::string, std::string>& properties) override;
+  void set_properties(std::map<std::string, std::string>&& properties) override;
 
   bool isBatch() const override;
 
diff --git a/include/MQMessageExt.h b/include/MQMessageExt.h
index 8d49917..d00ea94 100644
--- a/include/MQMessageExt.h
+++ b/include/MQMessageExt.h
@@ -57,46 +57,46 @@ class ROCKETMQCLIENT_API MQMessageExt : public MQMessage,          // base
   virtual ~MQMessageExt();
 
  public:  // MessageExt
-  int32_t getStoreSize() const override;
-  void setStoreSize(int32_t storeSize) override;
+  int32_t store_size() const override;
+  void set_store_size(int32_t storeSize) override;
 
-  int32_t getBodyCRC() const override;
-  void setBodyCRC(int32_t bodyCRC) override;
+  int32_t body_crc() const override;
+  void set_body_crc(int32_t bodyCRC) override;
 
-  int32_t getQueueId() const override;
-  void setQueueId(int32_t queueId) override;
+  int32_t queue_id() const override;
+  void set_queue_id(int32_t queueId) override;
 
-  int64_t getQueueOffset() const override;
-  void setQueueOffset(int64_t queueOffset) override;
+  int64_t queue_offset() const override;
+  void set_queue_offset(int64_t queueOffset) override;
 
-  int64_t getCommitLogOffset() const override;
-  void setCommitLogOffset(int64_t physicOffset) override;
+  int64_t commit_log_offset() const override;
+  void set_commit_log_offset(int64_t physicOffset) override;
 
-  int32_t getSysFlag() const override;
-  void setSysFlag(int32_t sysFlag) override;
+  int32_t sys_flag() const override;
+  void set_sys_flag(int32_t sysFlag) override;
 
-  int64_t getBornTimestamp() const override;
-  void setBornTimestamp(int64_t bornTimestamp) override;
+  int64_t born_timestamp() const override;
+  void set_born_timestamp(int64_t bornTimestamp) override;
 
-  std::string getBornHostString() const override;
-  const struct sockaddr* getBornHost() const override;
-  void setBornHost(const struct sockaddr* bornHost) override;
+  std::string born_host_string() const override;
+  const struct sockaddr* born_host() const override;
+  void set_born_host(const struct sockaddr* bornHost) override;
 
-  int64_t getStoreTimestamp() const override;
-  void setStoreTimestamp(int64_t storeTimestamp) override;
+  int64_t store_timestamp() const override;
+  void set_store_timestamp(int64_t storeTimestamp) override;
 
-  std::string getStoreHostString() const override;
-  const struct sockaddr* getStoreHost() const override;
-  void setStoreHost(const struct sockaddr* storeHost) override;
+  std::string store_host_string() const override;
+  const struct sockaddr* store_host() const override;
+  void set_store_host(const struct sockaddr* storeHost) override;
 
-  int32_t getReconsumeTimes() const override;
-  void setReconsumeTimes(int32_t reconsumeTimes) override;
+  int32_t reconsume_times() const override;
+  void set_reconsume_times(int32_t reconsumeTimes) override;
 
-  int64_t getPreparedTransactionOffset() const override;
-  void setPreparedTransactionOffset(int64_t preparedTransactionOffset) override;
+  int64_t prepared_transaction_offset() const override;
+  void set_prepared_transaction_offset(int64_t preparedTransactionOffset) override;
 
-  const std::string& getMsgId() const override;
-  void setMsgId(const std::string& msgId) override;
+  const std::string& msg_id() const override;
+  void set_msg_id(const std::string& msgId) override;
 };
 
 }  // namespace rocketmq
diff --git a/include/Message.h b/include/Message.h
index fe6bd3c..9a778ac 100644
--- a/include/Message.h
+++ b/include/Message.h
@@ -37,50 +37,51 @@ class ROCKETMQCLIENT_API Message {
   virtual ~Message() = default;
 
  public:
-  // property
-  virtual const std::string& getProperty(const std::string& name) const = 0;
-  virtual void putProperty(const std::string& name, const std::string& value) = 0;
-  virtual void clearProperty(const std::string& name) = 0;
-
   // topic
-  virtual const std::string& getTopic() const = 0;
-  virtual void setTopic(const std::string& topic) = 0;
-  virtual void setTopic(const char* body, int len) = 0;
+  virtual const std::string& topic() const = 0;
+  virtual void set_topic(const std::string& topic) = 0;
+  virtual void set_topic(const char* topic, int len) = 0;
 
   // tags
-  virtual const std::string& getTags() const = 0;
-  virtual void setTags(const std::string& tags) = 0;
+  virtual const std::string& tags() const = 0;
+  virtual void set_tags(const std::string& tags) = 0;
 
   // keys
-  virtual const std::string& getKeys() const = 0;
-  virtual void setKeys(const std::string& keys) = 0;
-  virtual void setKeys(const std::vector<std::string>& keys) = 0;
+  virtual const std::string& keys() const = 0;
+  virtual void set_keys(const std::string& keys) = 0;
+  virtual void set_keys(const std::vector<std::string>& keys) = 0;
 
   // delay time level
-  virtual int getDelayTimeLevel() const = 0;
-  virtual void setDelayTimeLevel(int level) = 0;
+  virtual int delay_time_level() const = 0;
+  virtual void set_delay_time_level(int level) = 0;
 
   // wait store message ok
-  virtual bool isWaitStoreMsgOK() const = 0;
-  virtual void setWaitStoreMsgOK(bool waitStoreMsgOK) = 0;
+  virtual bool wait_store_msg_ok() const = 0;
+  virtual void set_wait_store_msg_ok(bool waitStoreMsgOK) = 0;
 
   // flag
-  virtual int32_t getFlag() const = 0;
-  virtual void setFlag(int32_t flag) = 0;
+  virtual int32_t flag() const = 0;
+  virtual void set_flag(int32_t flag) = 0;
 
   // body
-  virtual const std::string& getBody() const = 0;
-  virtual void setBody(const std::string& body) = 0;
-  virtual void setBody(std::string&& body) = 0;
+  virtual const std::string& body() const = 0;
+  virtual void set_body(const std::string& body) = 0;
+  virtual void set_body(std::string&& body) = 0;
 
   // transaction id
-  virtual const std::string& getTransactionId() const = 0;
-  virtual void setTransactionId(const std::string& transactionId) = 0;
+  virtual const std::string& transaction_id() const = 0;
+  virtual void set_transaction_id(const std::string& transactionId) = 0;
 
   // properties
-  virtual const std::map<std::string, std::string>& getProperties() const = 0;
-  virtual void setProperties(const std::map<std::string, std::string>& properties) = 0;
-  virtual void setProperties(std::map<std::string, std::string>&& properties) = 0;
+  virtual const std::map<std::string, std::string>& properties() const = 0;
+  virtual void set_properties(const std::map<std::string, std::string>& properties) = 0;
+  virtual void set_properties(std::map<std::string, std::string>&& properties) = 0;
+
+ public:
+  // property
+  virtual const std::string& getProperty(const std::string& name) const = 0;
+  virtual void putProperty(const std::string& name, const std::string& value) = 0;
+  virtual void clearProperty(const std::string& name) = 0;
 
   // batch flag
   virtual bool isBatch() const { return false; }
diff --git a/include/MessageExt.h b/include/MessageExt.h
index 44b37a8..61ae147 100644
--- a/include/MessageExt.h
+++ b/include/MessageExt.h
@@ -41,46 +41,46 @@ class ROCKETMQCLIENT_API MessageExt : virtual public Message  // base interface
  public:
   virtual ~MessageExt() = default;
 
-  virtual int32_t getStoreSize() const = 0;
-  virtual void setStoreSize(int32_t storeSize) = 0;
+  virtual int32_t store_size() const = 0;
+  virtual void set_store_size(int32_t storeSize) = 0;
 
-  virtual int32_t getBodyCRC() const = 0;
-  virtual void setBodyCRC(int32_t bodyCRC) = 0;
+  virtual int32_t body_crc() const = 0;
+  virtual void set_body_crc(int32_t bodyCRC) = 0;
 
-  virtual int32_t getQueueId() const = 0;
-  virtual void setQueueId(int32_t queueId) = 0;
+  virtual int32_t queue_id() const = 0;
+  virtual void set_queue_id(int32_t queueId) = 0;
 
-  virtual int64_t getQueueOffset() const = 0;
-  virtual void setQueueOffset(int64_t queueOffset) = 0;
+  virtual int64_t queue_offset() const = 0;
+  virtual void set_queue_offset(int64_t queueOffset) = 0;
 
-  virtual int64_t getCommitLogOffset() const = 0;
-  virtual void setCommitLogOffset(int64_t physicOffset) = 0;
+  virtual int64_t commit_log_offset() const = 0;
+  virtual void set_commit_log_offset(int64_t physicOffset) = 0;
 
-  virtual int32_t getSysFlag() const = 0;
-  virtual void setSysFlag(int32_t sysFlag) = 0;
+  virtual int32_t sys_flag() const = 0;
+  virtual void set_sys_flag(int32_t sysFlag) = 0;
 
-  virtual int64_t getBornTimestamp() const = 0;
-  virtual void setBornTimestamp(int64_t bornTimestamp) = 0;
+  virtual int64_t born_timestamp() const = 0;
+  virtual void set_born_timestamp(int64_t bornTimestamp) = 0;
 
-  virtual std::string getBornHostString() const = 0;
-  virtual const struct sockaddr* getBornHost() const = 0;
-  virtual void setBornHost(const struct sockaddr* bornHost) = 0;
+  virtual std::string born_host_string() const = 0;
+  virtual const struct sockaddr* born_host() const = 0;
+  virtual void set_born_host(const struct sockaddr* bornHost) = 0;
 
-  virtual int64_t getStoreTimestamp() const = 0;
-  virtual void setStoreTimestamp(int64_t storeTimestamp) = 0;
+  virtual int64_t store_timestamp() const = 0;
+  virtual void set_store_timestamp(int64_t storeTimestamp) = 0;
 
-  virtual std::string getStoreHostString() const = 0;
-  virtual const struct sockaddr* getStoreHost() const = 0;
-  virtual void setStoreHost(const struct sockaddr* storeHost) = 0;
+  virtual std::string store_host_string() const = 0;
+  virtual const struct sockaddr* store_host() const = 0;
+  virtual void set_store_host(const struct sockaddr* storeHost) = 0;
 
-  virtual int32_t getReconsumeTimes() const = 0;
-  virtual void setReconsumeTimes(int32_t reconsumeTimes) = 0;
+  virtual int32_t reconsume_times() const = 0;
+  virtual void set_reconsume_times(int32_t reconsumeTimes) = 0;
 
-  virtual int64_t getPreparedTransactionOffset() const = 0;
-  virtual void setPreparedTransactionOffset(int64_t preparedTransactionOffset) = 0;
+  virtual int64_t prepared_transaction_offset() const = 0;
+  virtual void set_prepared_transaction_offset(int64_t preparedTransactionOffset) = 0;
 
-  virtual const std::string& getMsgId() const = 0;
-  virtual void setMsgId(const std::string& msgId) = 0;
+  virtual const std::string& msg_id() const = 0;
+  virtual void set_msg_id(const std::string& msgId) = 0;
 };
 
 }  // namespace rocketmq
diff --git a/include/QueryResult.h b/include/QueryResult.h
index b24d9e0..0482f3e 100644
--- a/include/QueryResult.h
+++ b/include/QueryResult.h
@@ -24,17 +24,17 @@ namespace rocketmq {
 class ROCKETMQCLIENT_API QueryResult {
  public:
   QueryResult(uint64_t indexLastUpdateTimestamp, const std::vector<MQMessageExt>& messageList) {
-    m_indexLastUpdateTimestamp = indexLastUpdateTimestamp;
-    m_messageList = messageList;
+    index_last_update_timestamp_ = indexLastUpdateTimestamp;
+    message_list_ = messageList;
   }
 
-  uint64_t getIndexLastUpdateTimestamp() { return m_indexLastUpdateTimestamp; }
+  uint64_t index_last_update_timestamp() { return index_last_update_timestamp_; }
 
-  std::vector<MQMessageExt>& getMessageList() { return m_messageList; }
+  std::vector<MQMessageExt>& message_list() { return message_list_; }
 
  private:
-  uint64_t m_indexLastUpdateTimestamp;
-  std::vector<MQMessageExt> m_messageList;
+  uint64_t index_last_update_timestamp_;
+  std::vector<MQMessageExt> message_list_;
 };
 
 }  // namespace rocketmq
diff --git a/include/SendResult.h b/include/SendResult.h
index 9188222..f7ec171 100644
--- a/include/SendResult.h
+++ b/include/SendResult.h
@@ -60,18 +60,23 @@ class ROCKETMQCLIENT_API SendResult {
 
   virtual ~SendResult() = default;
 
-  inline SendStatus getSendStatus() const { return send_status_; }
+  inline SendStatus send_status() const { return send_status_; }
+  inline void send_status(SendStatus send_status) { send_status_ = send_status; }
 
-  inline const std::string& getMsgId() const { return msg_id_; }
+  inline const std::string& msg_id() const { return msg_id_; }
+  inline void msg_id(const std::string& msg_id) { msg_id_ = msg_id; }
 
-  inline const std::string& getOffsetMsgId() const { return offset_msg_id_; }
+  inline const std::string& offset_msg_id() const { return offset_msg_id_; }
+  inline void offset_msg_id(std::string& offset_msg_id) { offset_msg_id_ = offset_msg_id; }
 
-  inline const MQMessageQueue& getMessageQueue() const { return message_queue_; }
+  inline const MQMessageQueue& message_queue() const { return message_queue_; }
+  inline void message_queue(const MQMessageQueue& message_queue) { message_queue_ = message_queue; }
 
-  inline int64_t getQueueOffset() const { return queue_offset_; }
+  inline int64_t queue_offset() const { return queue_offset_; }
+  inline void set_queue_offset(int64_t queue_offset) { queue_offset_ = queue_offset; }
 
-  inline const std::string& getTransactionId() const { return transaction_id_; }
-  inline void setTransactionId(const std::string& id) { transaction_id_ = id; }
+  inline const std::string& transaction_id() const { return transaction_id_; }
+  inline void set_transaction_id(const std::string& id) { transaction_id_ = id; }
 
   std::string toString() const;
 
diff --git a/include/SessionCredentials.h b/include/SessionCredentials.h
index 2d03f2a..3146bf0 100644
--- a/include/SessionCredentials.h
+++ b/include/SessionCredentials.h
@@ -37,22 +37,22 @@ class ROCKETMQCLIENT_API SessionCredentials {
 
   ~SessionCredentials() = default;
 
-  inline const std::string& getAccessKey() const { return access_key_; }
-  inline void setAccessKey(const std::string& accessKey) { access_key_ = accessKey; }
+  bool isValid() const { return !access_key_.empty() && !secret_key_.empty() && !auth_channel_.empty(); }
 
-  inline const std::string& getSecretKey() const { return secret_key_; }
-  inline void setSecretKey(const std::string& secretKey) { secret_key_ = secretKey; }
+  inline const std::string& access_key() const { return access_key_; }
+  inline void set_access_key(const std::string& accessKey) { access_key_ = accessKey; }
 
-  inline const std::string& getSignature() const { return signature_; }
-  inline void setSignature(const std::string& signature) { signature_ = signature; }
+  inline const std::string& secret_key() const { return secret_key_; }
+  inline void set_secret_key(const std::string& secretKey) { secret_key_ = secretKey; }
 
-  inline const std::string& getSignatureMethod() const { return signature_method_; }
-  inline void setSignatureMethod(const std::string& signatureMethod) { signature_method_ = signatureMethod; }
+  inline const std::string& signature() const { return signature_; }
+  inline void set_signature(const std::string& signature) { signature_ = signature; }
 
-  inline const std::string& getAuthChannel() const { return auth_channel_; }
-  inline void setAuthChannel(const std::string& channel) { auth_channel_ = channel; }
+  inline const std::string& signature_method() const { return signature_method_; }
+  inline void set_signature_method(const std::string& signatureMethod) { signature_method_ = signatureMethod; }
 
-  bool isValid() const { return !access_key_.empty() && !secret_key_.empty() && !auth_channel_.empty(); }
+  inline const std::string& auth_channel() const { return auth_channel_; }
+  inline void set_auth_channel(const std::string& channel) { auth_channel_ = channel; }
 
  private:
   std::string access_key_;
diff --git a/include/TransactionSendResult.h b/include/TransactionSendResult.h
index 7219d16..b036cf3 100644
--- a/include/TransactionSendResult.h
+++ b/include/TransactionSendResult.h
@@ -27,9 +27,9 @@ class ROCKETMQCLIENT_API TransactionSendResult : public SendResult {
  public:
   TransactionSendResult(const SendResult& sendResult) : SendResult(sendResult), local_transaction_state_(UNKNOWN) {}
 
-  inline LocalTransactionState getLocalTransactionState() const { return local_transaction_state_; }
+  inline LocalTransactionState local_transaction_state() const { return local_transaction_state_; }
 
-  inline void setLocalTransactionState(LocalTransactionState localTransactionState) {
+  inline void set_local_transaction_state(LocalTransactionState localTransactionState) {
     local_transaction_state_ = localTransactionState;
   }
 
diff --git a/src/ClientRemotingProcessor.cpp b/src/ClientRemotingProcessor.cpp
index aa742ba..518e464 100644
--- a/src/ClientRemotingProcessor.cpp
+++ b/src/ClientRemotingProcessor.cpp
@@ -70,7 +70,7 @@ RemotingCommand* ClientRemotingProcessor::checkTransactionState(const std::strin
     if (messageExt != nullptr) {
       const auto& transactionId = messageExt->getProperty(MQMessageConst::PROPERTY_UNIQ_CLIENT_MESSAGE_ID_KEYIDX);
       if (!transactionId.empty()) {
-        messageExt->setTransactionId(transactionId);
+        messageExt->set_transaction_id(transactionId);
       }
       const auto& group = messageExt->getProperty(MQMessageConst::PROPERTY_PRODUCER_GROUP);
       if (!group.empty()) {
@@ -148,36 +148,36 @@ RemotingCommand* ClientRemotingProcessor::receiveReplyMessage(RemotingCommand* r
   try {
     std::unique_ptr<MQMessageExt> msg(new MQMessageExt);
 
-    msg->setTopic(requestHeader->getTopic());
-    msg->setQueueId(requestHeader->getQueueId());
-    msg->setStoreTimestamp(requestHeader->getStoreTimestamp());
+    msg->set_topic(requestHeader->getTopic());
+    msg->set_queue_id(requestHeader->getQueueId());
+    msg->set_store_timestamp(requestHeader->getStoreTimestamp());
 
     if (!requestHeader->getBornHost().empty()) {
-      msg->setBornHost(string2SocketAddress(requestHeader->getBornHost()));
+      msg->set_born_host(string2SocketAddress(requestHeader->getBornHost()));
     }
 
     if (!requestHeader->getStoreHost().empty()) {
-      msg->setStoreHost(string2SocketAddress(requestHeader->getStoreHost()));
+      msg->set_store_host(string2SocketAddress(requestHeader->getStoreHost()));
     }
 
     auto body = request->body();
     if ((requestHeader->getSysFlag() & MessageSysFlag::COMPRESSED_FLAG) == MessageSysFlag::COMPRESSED_FLAG) {
       std::string origin_body;
       if (UtilAll::inflate(*body, origin_body)) {
-        msg->setBody(std::move(origin_body));
+        msg->set_body(std::move(origin_body));
       } else {
         LOG_WARN_NEW("err when uncompress constant");
       }
     } else {
-      msg->setBody(std::string(body->array(), body->size()));
+      msg->set_body(std::string(body->array(), body->size()));
     }
 
-    msg->setFlag(requestHeader->getFlag());
+    msg->set_flag(requestHeader->getFlag());
     MessageAccessor::setProperties(*msg, MessageDecoder::string2messageProperties(requestHeader->getProperties()));
     MessageAccessor::putProperty(*msg, MQMessageConst::PROPERTY_REPLY_MESSAGE_ARRIVE_TIME,
                                  UtilAll::to_string(receiveTime));
-    msg->setBornTimestamp(requestHeader->getBornTimestamp());
-    msg->setReconsumeTimes(requestHeader->getReconsumeTimes());
+    msg->set_born_timestamp(requestHeader->getBornTimestamp());
+    msg->set_reconsume_times(requestHeader->getReconsumeTimes());
     LOG_DEBUG_NEW("receive reply message:{}", msg->toString());
 
     processReplyMessage(std::move(msg));
@@ -200,7 +200,7 @@ void ClientRemotingProcessor::processReplyMessage(std::unique_ptr<MQMessageExt>
     requestResponseFuture->putResponseMessage(std::move(replyMsg));
     requestResponseFuture->executeRequestCallback();
   } else {
-    auto bornHost = replyMsg->getBornHostString();
+    auto bornHost = replyMsg->born_host_string();
     LOG_WARN_NEW("receive reply message, but not matched any request, CorrelationId: {} , reply from host: {}",
                  correlationId, bornHost);
   }
diff --git a/src/MQClientAPIImpl.cpp b/src/MQClientAPIImpl.cpp
index 429ff17..cb17dfd 100644
--- a/src/MQClientAPIImpl.cpp
+++ b/src/MQClientAPIImpl.cpp
@@ -34,9 +34,9 @@ namespace rocketmq {
 MQClientAPIImpl::MQClientAPIImpl(ClientRemotingProcessor* clientRemotingProcessor,
                                  RPCHookPtr rpcHook,
                                  const MQClientConfig& clientConfig)
-    : remoting_client_(new TcpRemotingClient(clientConfig.getTcpTransportWorkerThreadNum(),
-                                             clientConfig.getTcpTransportConnectTimeout(),
-                                             clientConfig.getTcpTransportTryLockTimeout())) {
+    : remoting_client_(new TcpRemotingClient(clientConfig.tcp_transport_worker_thread_nums(),
+                                             clientConfig.tcp_transport_connect_timeout(),
+                                             clientConfig.tcp_transport_try_lock_timeout())) {
   remoting_client_->registerRPCHook(rpcHook);
   remoting_client_->registerProcessor(CHECK_TRANSACTION_STATE, clientRemotingProcessor);
   remoting_client_->registerProcessor(NOTIFY_CONSUMER_IDS_CHANGED, clientRemotingProcessor);
@@ -128,7 +128,7 @@ SendResult* MQClientAPIImpl::sendMessage(const std::string& addr,
   }
 
   RemotingCommand request(code, header.release());
-  request.set_body(msg->getBody());
+  request.set_body(msg->body());
 
   switch (communicationMode) {
     case CommunicationMode::ONEWAY:
@@ -212,7 +212,7 @@ SendResult* MQClientAPIImpl::processSendResponse(const std::string& brokerName,
   auto* responseHeader = response->decodeCommandCustomHeader<SendMessageResponseHeader>();
   assert(responseHeader != nullptr);
 
-  MQMessageQueue messageQueue(msg->getTopic(), brokerName, responseHeader->queueId);
+  MQMessageQueue messageQueue(msg->topic(), brokerName, responseHeader->queueId);
 
   std::string uniqMsgId = MessageClientIDSetter::getUniqID(*msg);
 
@@ -232,7 +232,7 @@ SendResult* MQClientAPIImpl::processSendResponse(const std::string& brokerName,
 
   SendResult* sendResult =
       new SendResult(sendStatus, uniqMsgId, responseHeader->msgId, messageQueue, responseHeader->queueOffset);
-  sendResult->setTransactionId(responseHeader->transactionId);
+  sendResult->set_transaction_id(responseHeader->transactionId);
 
   return sendResult;
 }
@@ -560,10 +560,10 @@ void MQClientAPIImpl::consumerSendMessageBack(const std::string& addr,
                                               int maxConsumeRetryTimes) {
   auto* requestHeader = new ConsumerSendMsgBackRequestHeader();
   requestHeader->group = consumerGroup;
-  requestHeader->originTopic = msg->getTopic();
-  requestHeader->offset = msg->getCommitLogOffset();
+  requestHeader->originTopic = msg->topic();
+  requestHeader->offset = msg->commit_log_offset();
   requestHeader->delayLevel = delayLevel;
-  requestHeader->originMsgId = msg->getMsgId();
+  requestHeader->originMsgId = msg->msg_id();
   requestHeader->maxReconsumeTimes = maxConsumeRetryTimes;
 
   RemotingCommand request(CONSUMER_SEND_MSG_BACK, requestHeader);
diff --git a/src/MQClientConfigImpl.hpp b/src/MQClientConfigImpl.hpp
index 9eec239..c0aa341 100644
--- a/src/MQClientConfigImpl.hpp
+++ b/src/MQClientConfigImpl.hpp
@@ -33,7 +33,7 @@ class MQClientConfigImpl : virtual public MQClientConfig {
  public:
   MQClientConfigImpl()
       : instance_name_("DEFAULT"),
-        tcp_worker_thread_num_(std::min(4, (int)std::thread::hardware_concurrency())),
+        tcp_worker_thread_nums_(std::min(4, (int)std::thread::hardware_concurrency())),
         tcp_connect_timeout(3000),
         tcp_transport_try_lock_timeout_(3) {
     const char* addr = std::getenv(ROCKETMQ_NAMESRV_ADDR_ENV.c_str());
@@ -55,38 +55,39 @@ class MQClientConfigImpl : virtual public MQClientConfig {
     return clientId;
   }
 
-  const std::string& getGroupName() const override { return group_name_; }
-  void setGroupName(const std::string& groupname) override { group_name_ = groupname; }
-
-  const std::string& getNamesrvAddr() const override { return namesrv_addr_; }
-  void setNamesrvAddr(const std::string& namesrvAddr) override {
-    namesrv_addr_ = NameSpaceUtil::formatNameServerURL(namesrvAddr);
-  }
-
-  const std::string& getInstanceName() const override { return instance_name_; }
-  void setInstanceName(const std::string& instanceName) override { instance_name_ = instanceName; }
-
   void changeInstanceNameToPID() override {
     if (instance_name_ == "DEFAULT") {
       instance_name_ = UtilAll::to_string(UtilAll::getProcessId());
     }
   }
 
-  const std::string& getUnitName() const override { return unit_name_; }
-  void setUnitName(std::string unitName) override { unit_name_ = unitName; }
+ public:
+  const std::string& group_name() const override { return group_name_; }
+  void set_group_name(const std::string& groupname) override { group_name_ = groupname; }
+
+  const std::string& namesrv_addr() const override { return namesrv_addr_; }
+  void set_namesrv_addr(const std::string& namesrvAddr) override {
+    namesrv_addr_ = NameSpaceUtil::formatNameServerURL(namesrvAddr);
+  }
+
+  const std::string& instance_name() const override { return instance_name_; }
+  void set_instance_name(const std::string& instanceName) override { instance_name_ = instanceName; }
+
+  const std::string& unit_name() const override { return unit_name_; }
+  void set_unit_name(std::string unitName) override { unit_name_ = unitName; }
 
-  int getTcpTransportWorkerThreadNum() const override { return tcp_worker_thread_num_; }
-  void setTcpTransportWorkerThreadNum(int num) override {
-    if (num > tcp_worker_thread_num_) {
-      tcp_worker_thread_num_ = num;
+  int tcp_transport_worker_thread_nums() const override { return tcp_worker_thread_nums_; }
+  void set_tcp_transport_worker_thread_nums(int num) override {
+    if (num > tcp_worker_thread_nums_) {
+      tcp_worker_thread_nums_ = num;
     }
   }
 
-  uint64_t getTcpTransportConnectTimeout() const override { return tcp_connect_timeout; }
-  void setTcpTransportConnectTimeout(uint64_t millisec) override { tcp_connect_timeout = millisec; }
+  uint64_t tcp_transport_connect_timeout() const override { return tcp_connect_timeout; }
+  void set_tcp_transport_connect_timeout(uint64_t millisec) override { tcp_connect_timeout = millisec; }
 
-  uint64_t getTcpTransportTryLockTimeout() const override { return tcp_transport_try_lock_timeout_; }
-  void setTcpTransportTryLockTimeout(uint64_t millisec) override {
+  uint64_t tcp_transport_try_lock_timeout() const override { return tcp_transport_try_lock_timeout_; }
+  void set_tcp_transport_try_lock_timeout(uint64_t millisec) override {
     tcp_transport_try_lock_timeout_ = std::max<uint64_t>(1000, millisec) / 1000;
   }
 
@@ -96,7 +97,7 @@ class MQClientConfigImpl : virtual public MQClientConfig {
   std::string group_name_;
   std::string unit_name_;
 
-  int tcp_worker_thread_num_;
+  int tcp_worker_thread_nums_;
   uint64_t tcp_connect_timeout;              // ms
   uint64_t tcp_transport_try_lock_timeout_;  // s
 };
diff --git a/src/MQClientInstance.cpp b/src/MQClientInstance.cpp
index fa58bde..f10f188 100644
--- a/src/MQClientInstance.cpp
+++ b/src/MQClientInstance.cpp
@@ -53,7 +53,7 @@ MQClientInstance::MQClientInstance(const MQClientConfig& clientConfig, const std
   client_remoting_processor_.reset(new ClientRemotingProcessor(this));
   mq_client_api_impl_.reset(new MQClientAPIImpl(client_remoting_processor_.get(), rpcHook, clientConfig));
 
-  std::string namesrvAddr = clientConfig.getNamesrvAddr();
+  std::string namesrvAddr = clientConfig.namesrv_addr();
   if (!namesrvAddr.empty()) {
     mq_client_api_impl_->updateNameServerAddressList(namesrvAddr);
     LOG_INFO_NEW("user specified name server address: {}", namesrvAddr);
diff --git a/src/common/ClientRPCHook.cpp b/src/common/ClientRPCHook.cpp
index 5fcb47b..26f56bd 100644
--- a/src/common/ClientRPCHook.cpp
+++ b/src/common/ClientRPCHook.cpp
@@ -48,8 +48,8 @@ void ClientRPCHook::doAfterResponse(const std::string& remoteAddr,
 
 void ClientRPCHook::signCommand(RemotingCommand& command) {
   std::map<std::string, std::string> headerMap;
-  headerMap.insert(std::make_pair(ACCESS_KEY, session_credentials_.getAccessKey()));
-  headerMap.insert(std::make_pair(ONS_CHANNEL_KEY, session_credentials_.getAuthChannel()));
+  headerMap.insert(std::make_pair(ACCESS_KEY, session_credentials_.access_key()));
+  headerMap.insert(std::make_pair(ONS_CHANNEL_KEY, session_credentials_.auth_channel()));
 
   LOG_DEBUG_NEW("before insert declared filed, MAP SIZE is:{}", headerMap.size());
   auto* header = command.readCustomHeader();
@@ -70,12 +70,12 @@ void ClientRPCHook::signCommand(RemotingCommand& command) {
   LOG_DEBUG_NEW("total msg info are:{}, size is:{}", totalMsg, totalMsg.size());
 
   char* sign =
-      rocketmqSignature::spas_sign(totalMsg.c_str(), totalMsg.size(), session_credentials_.getSecretKey().c_str());
+      rocketmqSignature::spas_sign(totalMsg.c_str(), totalMsg.size(), session_credentials_.secret_key().c_str());
   if (sign != nullptr) {
     std::string signature(static_cast<const char*>(sign));
     command.set_ext_field(SIGNATURE_KEY, signature);
-    command.set_ext_field(ACCESS_KEY, session_credentials_.getAccessKey());
-    command.set_ext_field(ONS_CHANNEL_KEY, session_credentials_.getAuthChannel());
+    command.set_ext_field(ACCESS_KEY, session_credentials_.access_key());
+    command.set_ext_field(ONS_CHANNEL_KEY, session_credentials_.auth_channel());
     rocketmqSignature::spas_mem_free(sign);
   } else {
     LOG_ERROR_NEW("signature for request failed");
diff --git a/src/common/SendCallbackWrap.cpp b/src/common/SendCallbackWrap.cpp
index d7514c0..8763be1 100755
--- a/src/common/SendCallbackWrap.cpp
+++ b/src/common/SendCallbackWrap.cpp
@@ -162,7 +162,7 @@ void SendCallbackWrap::onExceptionImpl(ResponseFuture* responseFuture,
       }
     }
     std::string addr = instance_->findBrokerAddressInPublish(retryBrokerName);
-    LOG_INFO_NEW("async send msg by retry {} times. topic={}, brokerAddr={}, brokerName={}", times_, msg_->getTopic(),
+    LOG_INFO_NEW("async send msg by retry {} times. topic={}, brokerAddr={}, brokerName={}", times_, msg_->topic(),
                  addr, retryBrokerName);
     try {
       // new request
diff --git a/src/common/Validators.cpp b/src/common/Validators.cpp
index 22084ee..d014f0e 100644
--- a/src/common/Validators.cpp
+++ b/src/common/Validators.cpp
@@ -97,9 +97,9 @@ void Validators::checkGroup(const std::string& group) {
 }
 
 void Validators::checkMessage(const Message& msg, int maxMessageSize) {
-  checkTopic(msg.getTopic());
+  checkTopic(msg.topic());
 
-  const auto& body = msg.getBody();
+  const auto& body = msg.body();
   if (body.empty()) {
     THROW_MQEXCEPTION(MQClientException, "the message body is empty", MESSAGE_ILLEGAL);
   }
diff --git a/src/consumer/ConsumeMessageConcurrentlyService.cpp b/src/consumer/ConsumeMessageConcurrentlyService.cpp
index 5c3c2f9..16d725b 100755
--- a/src/consumer/ConsumeMessageConcurrentlyService.cpp
+++ b/src/consumer/ConsumeMessageConcurrentlyService.cpp
@@ -65,7 +65,7 @@ void ConsumeMessageConcurrentlyService::ConsumeRequest(std::vector<MessageExtPtr
                                                        const MQMessageQueue& messageQueue) {
   if (processQueue->dropped()) {
     LOG_WARN_NEW("the message queue not be able to consume, because it's dropped. group={} {}",
-                 consumer_->getDefaultMQPushConsumerConfig()->getGroupName(), messageQueue.toString());
+                 consumer_->getDefaultMQPushConsumerConfig()->group_name(), messageQueue.toString());
     return;
   }
 
@@ -76,7 +76,7 @@ void ConsumeMessageConcurrentlyService::ConsumeRequest(std::vector<MessageExtPtr
   }
 
   consumer_->resetRetryTopic(
-      msgs, consumer_->getDefaultMQPushConsumerConfig()->getGroupName());  // set where to sendMessageBack
+      msgs, consumer_->getDefaultMQPushConsumerConfig()->group_name());  // set where to sendMessageBack
 
   ConsumeStatus status = RECONSUME_LATER;
   try {
@@ -132,11 +132,11 @@ void ConsumeMessageConcurrentlyService::ConsumeRequest(std::vector<MessageExtPtr
       int idx = ackIndex + 1;
       for (auto iter = msgs.begin() + idx; iter != msgs.end(); idx++) {
         LOG_WARN_NEW("consume fail, MQ is:{}, its msgId is:{}, index is:{}, reconsume times is:{}",
-                     messageQueue.toString(), (*iter)->getMsgId(), idx, (*iter)->getReconsumeTimes());
+                     messageQueue.toString(), (*iter)->msg_id(), idx, (*iter)->reconsume_times());
         auto& msg = (*iter);
         bool result = consumer_->sendMessageBack(msg, 0, messageQueue.broker_name());
         if (!result) {
-          msg->setReconsumeTimes(msg->getReconsumeTimes() + 1);
+          msg->set_reconsume_times(msg->reconsume_times() + 1);
           msgBackFailed.push_back(msg);
           iter = msgs.erase(iter);
         } else {
diff --git a/src/consumer/ConsumeMessageOrderlyService.cpp b/src/consumer/ConsumeMessageOrderlyService.cpp
index 1a3698c..0dd2c16 100755
--- a/src/consumer/ConsumeMessageOrderlyService.cpp
+++ b/src/consumer/ConsumeMessageOrderlyService.cpp
@@ -144,11 +144,11 @@ void ConsumeMessageOrderlyService::ConsumeRequest(ProcessQueuePtr processQueue,
         break;
       }
 
-      const int consumeBatchSize = consumer_->getDefaultMQPushConsumerConfig()->getConsumeMessageBatchMaxSize();
+      const int consumeBatchSize = consumer_->getDefaultMQPushConsumerConfig()->consume_message_batch_max_size();
 
       std::vector<MessageExtPtr> msgs;
       processQueue->takeMessages(msgs, consumeBatchSize);
-      consumer_->resetRetryTopic(msgs, consumer_->getDefaultMQPushConsumerConfig()->getGroupName());
+      consumer_->resetRetryTopic(msgs, consumer_->getDefaultMQPushConsumerConfig()->group_name());
       if (!msgs.empty()) {
         ConsumeStatus status = RECONSUME_LATER;
         try {
diff --git a/src/consumer/DefaultMQPullConsumer.cpp b/src/consumer/DefaultMQPullConsumer.cpp
index 66d324e..166ed69 100644
--- a/src/consumer/DefaultMQPullConsumer.cpp
+++ b/src/consumer/DefaultMQPullConsumer.cpp
@@ -27,9 +27,9 @@ DefaultMQPullConsumer::DefaultMQPullConsumer(const std::string& groupname, RPCHo
     : DefaultMQPullConsumerConfigProxy(nullptr), m_pullConsumerDelegate(nullptr) {
   // set default group name
   if (groupname.empty()) {
-    setGroupName(DEFAULT_CONSUMER_GROUP);
+    set_group_name(DEFAULT_CONSUMER_GROUP);
   } else {
-    setGroupName(groupname);
+    set_group_name(groupname);
   }
 
   // TODO: DefaultMQPullConsumerImpl
diff --git a/src/consumer/DefaultMQPushConsumer.cpp b/src/consumer/DefaultMQPushConsumer.cpp
index f5a80d9..894e965 100644
--- a/src/consumer/DefaultMQPushConsumer.cpp
+++ b/src/consumer/DefaultMQPushConsumer.cpp
@@ -30,9 +30,9 @@ DefaultMQPushConsumer::DefaultMQPushConsumer(const std::string& groupname, RPCHo
       push_consumer_impl_(nullptr) {
   // set default group name
   if (groupname.empty()) {
-    setGroupName(DEFAULT_CONSUMER_GROUP);
+    set_group_name(DEFAULT_CONSUMER_GROUP);
   } else {
-    setGroupName(groupname);
+    set_group_name(groupname);
   }
 
   // create DefaultMQPushConsumerImpl
diff --git a/src/consumer/DefaultMQPushConsumerConfigImpl.hpp b/src/consumer/DefaultMQPushConsumerConfigImpl.hpp
index 1b1f1eb..e2ba06d 100644
--- a/src/consumer/DefaultMQPushConsumerConfigImpl.hpp
+++ b/src/consumer/DefaultMQPushConsumerConfigImpl.hpp
@@ -36,7 +36,7 @@ class DefaultMQPushConsumerConfigImpl : virtual public DefaultMQPushConsumerConf
       : message_model_(MessageModel::CLUSTERING),
         consume_from_where_(ConsumeFromWhere::CONSUME_FROM_LAST_OFFSET),
         consume_timestamp_("0"),
-        consume_thread_num_(std::min(8, (int)std::thread::hardware_concurrency())),
+        consume_thread_nums_(std::min(8, (int)std::thread::hardware_concurrency())),
         consume_message_batch_max_size_(1),
         max_msg_cache_size_(1000),
         async_pull_timeout_(30 * 1000),
@@ -45,49 +45,49 @@ class DefaultMQPushConsumerConfigImpl : virtual public DefaultMQPushConsumerConf
         allocate_mq_strategy_(new AllocateMQAveragely()) {}
   virtual ~DefaultMQPushConsumerConfigImpl() = default;
 
-  MessageModel getMessageModel() const override { return message_model_; }
-  void setMessageModel(MessageModel messageModel) override { message_model_ = messageModel; }
+  MessageModel message_model() const override { return message_model_; }
+  void set_message_model(MessageModel messageModel) override { message_model_ = messageModel; }
 
-  ConsumeFromWhere getConsumeFromWhere() const override { return consume_from_where_; }
-  void setConsumeFromWhere(ConsumeFromWhere consumeFromWhere) override { consume_from_where_ = consumeFromWhere; }
+  ConsumeFromWhere consume_from_where() const override { return consume_from_where_; }
+  void set_consume_from_where(ConsumeFromWhere consumeFromWhere) override { consume_from_where_ = consumeFromWhere; }
 
-  const std::string& getConsumeTimestamp() const override { return consume_timestamp_; }
-  void setConsumeTimestamp(const std::string& consumeTimestamp) override { consume_timestamp_ = consumeTimestamp; }
+  const std::string& consume_timestamp() const override { return consume_timestamp_; }
+  void set_consume_timestamp(const std::string& consumeTimestamp) override { consume_timestamp_ = consumeTimestamp; }
 
-  int getConsumeThreadNum() const override { return consume_thread_num_; }
-  void setConsumeThreadNum(int threadNum) override {
+  int consume_thread_nums() const override { return consume_thread_nums_; }
+  void set_consume_thread_nums(int threadNum) override {
     if (threadNum > 0) {
-      consume_thread_num_ = threadNum;
+      consume_thread_nums_ = threadNum;
     }
   }
 
-  int getConsumeMessageBatchMaxSize() const override { return consume_message_batch_max_size_; }
-  void setConsumeMessageBatchMaxSize(int consumeMessageBatchMaxSize) override {
+  int consume_message_batch_max_size() const override { return consume_message_batch_max_size_; }
+  void set_consume_message_batch_max_size(int consumeMessageBatchMaxSize) override {
     if (consumeMessageBatchMaxSize >= 1) {
       consume_message_batch_max_size_ = consumeMessageBatchMaxSize;
     }
   }
 
-  int getMaxCacheMsgSizePerQueue() const override { return max_msg_cache_size_; }
-  void setMaxCacheMsgSizePerQueue(int maxCacheSize) override {
+  int max_cache_msg_size_per_queue() const override { return max_msg_cache_size_; }
+  void set_max_cache_msg_size_per_queue(int maxCacheSize) override {
     if (maxCacheSize > 0 && maxCacheSize < 65535) {
       max_msg_cache_size_ = maxCacheSize;
     }
   }
 
-  int getAsyncPullTimeout() const override { return async_pull_timeout_; }
-  void setAsyncPullTimeout(int asyncPullTimeout) override { async_pull_timeout_ = asyncPullTimeout; }
+  int async_pull_timeout() const override { return async_pull_timeout_; }
+  void set_async_pull_timeout(int asyncPullTimeout) override { async_pull_timeout_ = asyncPullTimeout; }
 
-  int getMaxReconsumeTimes() const override { return max_reconsume_times_; }
-  void setMaxReconsumeTimes(int maxReconsumeTimes) override { max_reconsume_times_ = maxReconsumeTimes; }
+  int max_reconsume_times() const override { return max_reconsume_times_; }
+  void set_max_reconsume_times(int maxReconsumeTimes) override { max_reconsume_times_ = maxReconsumeTimes; }
 
-  long getPullTimeDelayMillsWhenException() const override { return pull_time_delay_mills_when_exception_; }
-  void setPullTimeDelayMillsWhenException(long pullTimeDelayMillsWhenException) override {
+  long pull_time_delay_mills_when_exception() const override { return pull_time_delay_mills_when_exception_; }
+  void set_pull_time_delay_mills_when_exception(long pullTimeDelayMillsWhenException) override {
     pull_time_delay_mills_when_exception_ = pullTimeDelayMillsWhenException;
   }
 
-  AllocateMQStrategy* getAllocateMQStrategy() const override { return allocate_mq_strategy_.get(); }
-  void setAllocateMQStrategy(AllocateMQStrategy* strategy) override { allocate_mq_strategy_.reset(strategy); }
+  AllocateMQStrategy* allocate_mq_strategy() const override { return allocate_mq_strategy_.get(); }
+  void set_allocate_mq_strategy(AllocateMQStrategy* strategy) override { allocate_mq_strategy_.reset(strategy); }
 
  protected:
   MessageModel message_model_;
@@ -95,7 +95,7 @@ class DefaultMQPushConsumerConfigImpl : virtual public DefaultMQPushConsumerConf
   ConsumeFromWhere consume_from_where_;
   std::string consume_timestamp_;
 
-  int consume_thread_num_;
+  int consume_thread_nums_;
   int consume_message_batch_max_size_;
   int max_msg_cache_size_;
 
diff --git a/src/consumer/DefaultMQPushConsumerImpl.cpp b/src/consumer/DefaultMQPushConsumerImpl.cpp
index 71097b2..de90889 100644
--- a/src/consumer/DefaultMQPushConsumerImpl.cpp
+++ b/src/consumer/DefaultMQPushConsumerImpl.cpp
@@ -69,7 +69,7 @@ class AsyncPullCallback : public AutoDeletePullCallback {
         if (result.msg_found_list().empty()) {
           defaultMQPushConsumer->executePullRequestImmediately(pull_request_);
         } else {
-          firstMsgOffset = result.msg_found_list()[0]->getQueueOffset();
+          firstMsgOffset = result.msg_found_list()[0]->queue_offset();
 
           pull_request_->process_queue()->putMessage(result.msg_found_list());
           defaultMQPushConsumer->getConsumerMsgService()->submitConsumeRequest(
@@ -96,7 +96,7 @@ class AsyncPullCallback : public AutoDeletePullCallback {
         defaultMQPushConsumer->correctTagsOffset(pull_request_);
         defaultMQPushConsumer->executePullRequestLater(
             pull_request_,
-            defaultMQPushConsumer->getDefaultMQPushConsumerConfig()->getPullTimeDelayMillsWhenException());
+            defaultMQPushConsumer->getDefaultMQPushConsumerConfig()->pull_time_delay_mills_when_exception());
         break;
       case OFFSET_ILLEGAL: {
         LOG_WARN_NEW("the pull request offset illegal, {} {}", pull_request_->toString(), result.toString());
@@ -139,7 +139,7 @@ class AsyncPullCallback : public AutoDeletePullCallback {
 
     // TODO
     defaultMQPushConsumer->executePullRequestLater(
-        pull_request_, defaultMQPushConsumer->getDefaultMQPushConsumerConfig()->getPullTimeDelayMillsWhenException());
+        pull_request_, defaultMQPushConsumer->getDefaultMQPushConsumerConfig()->pull_time_delay_mills_when_exception());
   }
 
  private:
@@ -176,7 +176,7 @@ void DefaultMQPushConsumerImpl::start() {
 
   switch (service_state_) {
     case CREATE_JUST: {
-      LOG_INFO_NEW("the consumer [{}] start beginning.", client_config_->getGroupName());
+      LOG_INFO_NEW("the consumer [{}] start beginning.", client_config_->group_name());
 
       service_state_ = START_FAILED;
 
@@ -192,59 +192,59 @@ void DefaultMQPushConsumerImpl::start() {
       MQClientImpl::start();
 
       // init rebalance_impl_
-      rebalance_impl_->set_consumer_group(client_config_->getGroupName());
+      rebalance_impl_->set_consumer_group(client_config_->group_name());
       rebalance_impl_->set_message_model(
-          dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->getMessageModel());
+          dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->message_model());
       rebalance_impl_->set_allocate_mq_strategy(
-          dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->getAllocateMQStrategy());
+          dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->allocate_mq_strategy());
       rebalance_impl_->set_client_instance(client_instance_.get());
 
       // init pull_api_wrapper_
-      pull_api_wrapper_.reset(new PullAPIWrapper(client_instance_.get(), client_config_->getGroupName()));
+      pull_api_wrapper_.reset(new PullAPIWrapper(client_instance_.get(), client_config_->group_name()));
       // TODO: registerFilterMessageHook
 
       // init offset_store_
-      switch (dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->getMessageModel()) {
+      switch (dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->message_model()) {
         case MessageModel::BROADCASTING:
-          offset_store_.reset(new LocalFileOffsetStore(client_instance_.get(), client_config_->getGroupName()));
+          offset_store_.reset(new LocalFileOffsetStore(client_instance_.get(), client_config_->group_name()));
           break;
         case MessageModel::CLUSTERING:
-          offset_store_.reset(new RemoteBrokerOffsetStore(client_instance_.get(), client_config_->getGroupName()));
+          offset_store_.reset(new RemoteBrokerOffsetStore(client_instance_.get(), client_config_->group_name()));
           break;
       }
       offset_store_->load();
 
       // checkConfig() guarantee message_listener_ is not nullptr
       if (message_listener_->getMessageListenerType() == messageListenerOrderly) {
-        LOG_INFO_NEW("start orderly consume service: {}", client_config_->getGroupName());
+        LOG_INFO_NEW("start orderly consume service: {}", client_config_->group_name());
         consume_orderly_ = true;
         consume_service_.reset(new ConsumeMessageOrderlyService(
-            this, dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->getConsumeThreadNum(),
+            this, dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->consume_thread_nums(),
             message_listener_));
       } else {
         // for backward compatible, defaultly and concurrently listeners are allocating
         // ConsumeMessageConcurrentlyService
-        LOG_INFO_NEW("start concurrently consume service: {}", client_config_->getGroupName());
+        LOG_INFO_NEW("start concurrently consume service: {}", client_config_->group_name());
         consume_orderly_ = false;
         consume_service_.reset(new ConsumeMessageConcurrentlyService(
-            this, dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->getConsumeThreadNum(),
+            this, dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->consume_thread_nums(),
             message_listener_));
       }
       consume_service_->start();
 
       // register consumer
-      bool registerOK = client_instance_->registerConsumer(client_config_->getGroupName(), this);
+      bool registerOK = client_instance_->registerConsumer(client_config_->group_name(), this);
       if (!registerOK) {
         service_state_ = CREATE_JUST;
         consume_service_->shutdown();
-        THROW_MQEXCEPTION(MQClientException, "The cousumer group[" + client_config_->getGroupName() +
+        THROW_MQEXCEPTION(MQClientException, "The cousumer group[" + client_config_->group_name() +
                                                  "] has been created before, specify another name please.",
                           -1);
       }
 
       client_instance_->start();
 
-      LOG_INFO_NEW("the consumer [{}] start OK", client_config_->getGroupName());
+      LOG_INFO_NEW("the consumer [{}] start OK", client_config_->group_name());
       service_state_ = RUNNING;
       break;
     }
@@ -263,7 +263,7 @@ void DefaultMQPushConsumerImpl::start() {
 }
 
 void DefaultMQPushConsumerImpl::checkConfig() {
-  std::string groupname = client_config_->getGroupName();
+  std::string groupname = client_config_->group_name();
 
   // check consumerGroup
   Validators::checkGroup(groupname);
@@ -274,13 +274,13 @@ void DefaultMQPushConsumerImpl::checkConfig() {
                       "consumerGroup can not equal " + DEFAULT_CONSUMER_GROUP + ", please specify another one.", -1);
   }
 
-  if (dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->getMessageModel() != BROADCASTING &&
-      dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->getMessageModel() != CLUSTERING) {
+  if (dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->message_model() != BROADCASTING &&
+      dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->message_model() != CLUSTERING) {
     THROW_MQEXCEPTION(MQClientException, "messageModel is valid", -1);
   }
 
   // allocateMessageQueueStrategy
-  if (nullptr == dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->getAllocateMQStrategy()) {
+  if (nullptr == dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->allocate_mq_strategy()) {
     THROW_MQEXCEPTION(MQClientException, "allocateMessageQueueStrategy is null", -1);
   }
 
@@ -302,12 +302,12 @@ void DefaultMQPushConsumerImpl::copySubscription() {
     rebalance_impl_->setSubscriptionData(it.first, subscriptionData);
   }
 
-  switch (dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->getMessageModel()) {
+  switch (dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->message_model()) {
     case BROADCASTING:
       break;
     case CLUSTERING: {
       // auto subscript retry topic
-      std::string retryTopic = UtilAll::getRetryTopic(client_config_->getGroupName());
+      std::string retryTopic = UtilAll::getRetryTopic(client_config_->group_name());
       SubscriptionData* subscriptionData = FilterAPI::buildSubscriptionData(retryTopic, SUB_ALL);
       rebalance_impl_->setSubscriptionData(retryTopic, subscriptionData);
       break;
@@ -333,9 +333,9 @@ void DefaultMQPushConsumerImpl::shutdown() {
     case RUNNING: {
       consume_service_->shutdown();
       persistConsumerOffset();
-      client_instance_->unregisterConsumer(client_config_->getGroupName());
+      client_instance_->unregisterConsumer(client_config_->group_name());
       client_instance_->shutdown();
-      LOG_INFO_NEW("the consumer [{}] shutdown OK", client_config_->getGroupName());
+      LOG_INFO_NEW("the consumer [{}] shutdown OK", client_config_->group_name());
       rebalance_impl_->destroy();
       service_state_ = SHUTDOWN_ALREADY;
       break;
@@ -354,16 +354,16 @@ bool DefaultMQPushConsumerImpl::sendMessageBack(MessageExtPtr msg, int delayLeve
 
 bool DefaultMQPushConsumerImpl::sendMessageBack(MessageExtPtr msg, int delayLevel, const std::string& brokerName) {
   try {
-    std::string brokerAddr = brokerName.empty() ? socketAddress2String(msg->getStoreHost())
+    std::string brokerAddr = brokerName.empty() ? socketAddress2String(msg->store_host())
                                                 : client_instance_->findBrokerAddressInPublish(brokerName);
 
     client_instance_->getMQClientAPIImpl()->consumerSendMessageBack(
-        brokerAddr, msg, dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->getGroupName(), delayLevel,
+        brokerAddr, msg, dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->group_name(), delayLevel,
         5000, getMaxReconsumeTimes());
     return true;
   } catch (const std::exception& e) {
     LOG_ERROR_NEW("sendMessageBack exception, group: {}, msg: {}. {}",
-                  dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->getGroupName(), msg->toString(),
+                  dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->group_name(), msg->toString(),
                   e.what());
   }
   return false;
@@ -404,13 +404,13 @@ void DefaultMQPushConsumerImpl::subscribe(const std::string& topic, const std::s
 
 void DefaultMQPushConsumerImpl::suspend() {
   pause_ = true;
-  LOG_INFO_NEW("suspend this consumer, {}", client_config_->getGroupName());
+  LOG_INFO_NEW("suspend this consumer, {}", client_config_->group_name());
 }
 
 void DefaultMQPushConsumerImpl::resume() {
   pause_ = false;
   doRebalance();
-  LOG_INFO_NEW("resume this consumer, {}", client_config_->getGroupName());
+  LOG_INFO_NEW("resume this consumer, {}", client_config_->group_name());
 }
 
 void DefaultMQPushConsumerImpl::doRebalance() {
@@ -422,7 +422,7 @@ void DefaultMQPushConsumerImpl::doRebalance() {
 void DefaultMQPushConsumerImpl::persistConsumerOffset() {
   if (isServiceStateOk()) {
     std::vector<MQMessageQueue> mqs = rebalance_impl_->getAllocatedMQ();
-    if (dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->getMessageModel() == BROADCASTING) {
+    if (dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->message_model() == BROADCASTING) {
       offset_store_->persistAll(mqs);
     } else {
       for (const auto& mq : mqs) {
@@ -478,7 +478,7 @@ void DefaultMQPushConsumerImpl::pullMessage(PullRequestPtr pullRequest) {
 
   int cachedMessageCount = processQueue->getCacheMsgCount();
   if (cachedMessageCount >
-      dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->getMaxCacheMsgSizePerQueue()) {
+      dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->max_cache_msg_size_per_queue()) {
     // too many message in cache, wait to process
     executePullRequestLater(pullRequest, 1000);
     return;
@@ -505,7 +505,7 @@ void DefaultMQPushConsumerImpl::pullMessage(PullRequestPtr pullRequest) {
     } else {
       executePullRequestLater(
           pullRequest,
-          dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->getPullTimeDelayMillsWhenException());
+          dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->pull_time_delay_mills_when_exception());
       LOG_INFO_NEW("pull message later because not locked in broker, {}", pullRequest->toString());
       return;
     }
@@ -516,14 +516,14 @@ void DefaultMQPushConsumerImpl::pullMessage(PullRequestPtr pullRequest) {
   if (nullptr == subscriptionData) {
     executePullRequestLater(
         pullRequest,
-        dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->getPullTimeDelayMillsWhenException());
+        dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->pull_time_delay_mills_when_exception());
     LOG_WARN_NEW("find the consumer's subscription failed, {}", pullRequest->toString());
     return;
   }
 
   bool commitOffsetEnable = false;
   int64_t commitOffsetValue = 0;
-  if (CLUSTERING == dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->getMessageModel()) {
+  if (CLUSTERING == dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->message_model()) {
     commitOffsetValue = offset_store_->readOffset(messageQueue, READ_FROM_MEMORY);
     if (commitOffsetValue > 0) {
       commitOffsetEnable = true;
@@ -540,22 +540,22 @@ void DefaultMQPushConsumerImpl::pullMessage(PullRequestPtr pullRequest) {
   try {
     auto* callback = new AsyncPullCallback(shared_from_this(), pullRequest, subscriptionData);
     pull_api_wrapper_->pullKernelImpl(
-        messageQueue,                                                                             // 1
-        subExpression,                                                                            // 2
-        subscriptionData->sub_version(),                                                          // 3
-        pullRequest->next_offset(),                                                               // 4
-        32,                                                                                       // 5
-        sysFlag,                                                                                  // 6
-        commitOffsetValue,                                                                        // 7
-        1000 * 15,                                                                                // 8
-        dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->getAsyncPullTimeout(),  // 9
-        CommunicationMode::ASYNC,                                                                 // 10
-        callback);                                                                                // 11
+        messageQueue,                                                                            // 1
+        subExpression,                                                                           // 2
+        subscriptionData->sub_version(),                                                         // 3
+        pullRequest->next_offset(),                                                              // 4
+        32,                                                                                      // 5
+        sysFlag,                                                                                 // 6
+        commitOffsetValue,                                                                       // 7
+        1000 * 15,                                                                               // 8
+        dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->async_pull_timeout(),  // 9
+        CommunicationMode::ASYNC,                                                                // 10
+        callback);                                                                               // 11
   } catch (MQException& e) {
     LOG_ERROR_NEW("pullKernelImpl exception: {}", e.what());
     executePullRequestLater(
         pullRequest,
-        dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->getPullTimeDelayMillsWhenException());
+        dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->pull_time_delay_mills_when_exception());
   }
 }
 
@@ -564,27 +564,27 @@ void DefaultMQPushConsumerImpl::resetRetryTopic(const std::vector<MessageExtPtr>
   std::string groupTopic = UtilAll::getRetryTopic(consumerGroup);
   for (auto& msg : msgs) {
     std::string retryTopic = msg->getProperty(MQMessageConst::PROPERTY_RETRY_TOPIC);
-    if (!retryTopic.empty() && groupTopic == msg->getTopic()) {
-      msg->setTopic(retryTopic);
+    if (!retryTopic.empty() && groupTopic == msg->topic()) {
+      msg->set_topic(retryTopic);
     }
   }
 }
 
 int DefaultMQPushConsumerImpl::getMaxReconsumeTimes() {
   // default reconsume times: 16
-  if (dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->getMaxReconsumeTimes() == -1) {
+  if (dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->max_reconsume_times() == -1) {
     return 16;
   } else {
-    return dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->getMaxReconsumeTimes();
+    return dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->max_reconsume_times();
   }
 }
 
 std::string DefaultMQPushConsumerImpl::groupName() const {
-  return client_config_->getGroupName();
+  return client_config_->group_name();
 }
 
 MessageModel DefaultMQPushConsumerImpl::messageModel() const {
-  return dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->getMessageModel();
+  return dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->message_model();
 };
 
 ConsumeType DefaultMQPushConsumerImpl::consumeType() const {
@@ -592,7 +592,7 @@ ConsumeType DefaultMQPushConsumerImpl::consumeType() const {
 }
 
 ConsumeFromWhere DefaultMQPushConsumerImpl::consumeFromWhere() const {
-  return dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->getConsumeFromWhere();
+  return dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->consume_from_where();
 }
 
 std::vector<SubscriptionData> DefaultMQPushConsumerImpl::subscriptions() const {
@@ -610,7 +610,7 @@ ConsumerRunningInfo* DefaultMQPushConsumerImpl::consumerRunningInfo() {
   info->setProperty(ConsumerRunningInfo::PROP_CONSUME_ORDERLY, UtilAll::to_string(consume_orderly_));
   info->setProperty(
       ConsumerRunningInfo::PROP_THREADPOOL_CORE_SIZE,
-      UtilAll::to_string(dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->getConsumeThreadNum()));
+      UtilAll::to_string(dynamic_cast<DefaultMQPushConsumerConfig*>(client_config_.get())->consume_thread_nums()));
   info->setProperty(ConsumerRunningInfo::PROP_CONSUMER_START_TIMESTAMP, UtilAll::to_string(start_time_));
 
   auto subSet = subscriptions();
diff --git a/src/consumer/ProcessQueue.cpp b/src/consumer/ProcessQueue.cpp
index dee12f3..bc6f29d 100644
--- a/src/consumer/ProcessQueue.cpp
+++ b/src/consumer/ProcessQueue.cpp
@@ -52,7 +52,7 @@ void ProcessQueue::putMessage(const std::vector<MessageExtPtr>& msgs) {
   std::lock_guard<std::mutex> lock(lock_tree_map_);
 
   for (const auto& msg : msgs) {
-    int64_t offset = msg->getQueueOffset();
+    int64_t offset = msg->queue_offset();
     msg_tree_map_[offset] = msg;
     if (offset > queue_offset_max_) {
       queue_offset_max_ = offset;
@@ -74,8 +74,8 @@ int64_t ProcessQueue::removeMessage(const std::vector<MessageExtPtr>& msgs) {
     LOG_DEBUG_NEW("offset result is:{}, queue_offset_max is:{}, msgs size:{}", result, queue_offset_max_, msgs.size());
 
     for (auto& msg : msgs) {
-      LOG_DEBUG_NEW("remove these msg from msg_tree_map, its offset:{}", msg->getQueueOffset());
-      msg_tree_map_.erase(msg->getQueueOffset());
+      LOG_DEBUG_NEW("remove these msg from msg_tree_map, its offset:{}", msg->queue_offset());
+      msg_tree_map_.erase(msg->queue_offset());
     }
 
     if (!msg_tree_map_.empty()) {
@@ -121,8 +121,8 @@ int64_t ProcessQueue::commit() {
 void ProcessQueue::makeMessageToCosumeAgain(std::vector<MessageExtPtr>& msgs) {
   std::lock_guard<std::mutex> lock(lock_tree_map_);
   for (const auto& msg : msgs) {
-    msg_tree_map_[msg->getQueueOffset()] = msg;
-    consuming_msg_orderly_tree_map_.erase(msg->getQueueOffset());
+    msg_tree_map_[msg->queue_offset()] = msg;
+    consuming_msg_orderly_tree_map_.erase(msg->queue_offset());
   }
 }
 
diff --git a/src/consumer/PullAPIWrapper.cpp b/src/consumer/PullAPIWrapper.cpp
index 96a9a8f..54a5512 100644
--- a/src/consumer/PullAPIWrapper.cpp
+++ b/src/consumer/PullAPIWrapper.cpp
@@ -69,7 +69,7 @@ PullResult PullAPIWrapper::processPullResult(const MQMessageQueue& mq,
     if (subscriptionData != nullptr && !subscriptionData->tags_set().empty()) {
       msgListFilterAgain.reserve(msgList.size());
       for (const auto& msg : msgList) {
-        const auto& msgTag = msg->getTags();
+        const auto& msgTag = msg->tags();
         if (subscriptionData->contain_tag(msgTag)) {
           msgListFilterAgain.push_back(msg);
         }
@@ -81,7 +81,7 @@ PullResult PullAPIWrapper::processPullResult(const MQMessageQueue& mq,
     for (auto& msg : msgListFilterAgain) {
       const auto& tranMsg = msg->getProperty(MQMessageConst::PROPERTY_TRANSACTION_PREPARED);
       if (UtilAll::stob(tranMsg)) {
-        msg->setTransactionId(msg->getProperty(MQMessageConst::PROPERTY_UNIQ_CLIENT_MESSAGE_ID_KEYIDX));
+        msg->set_transaction_id(msg->getProperty(MQMessageConst::PROPERTY_UNIQ_CLIENT_MESSAGE_ID_KEYIDX));
       }
       MessageAccessor::putProperty(*msg, MQMessageConst::PROPERTY_MIN_OFFSET,
                                    UtilAll::to_string(pullResult.min_offset()));
diff --git a/src/consumer/RebalancePushImpl.cpp b/src/consumer/RebalancePushImpl.cpp
index ecffc95..7c2cf46 100644
--- a/src/consumer/RebalancePushImpl.cpp
+++ b/src/consumer/RebalancePushImpl.cpp
@@ -61,7 +61,7 @@ void RebalancePushImpl::removeDirtyOffset(const MQMessageQueue& mq) {
 int64_t RebalancePushImpl::computePullFromWhere(const MQMessageQueue& mq) {
   int64_t result = -1;
   ConsumeFromWhere consumeFromWhere =
-      default_mq_push_consumer_impl_->getDefaultMQPushConsumerConfig()->getConsumeFromWhere();
+      default_mq_push_consumer_impl_->getDefaultMQPushConsumerConfig()->consume_from_where();
   OffsetStore* offsetStore = default_mq_push_consumer_impl_->getOffsetStore();
   switch (consumeFromWhere) {
     case CONSUME_FROM_LAST_OFFSET: {
@@ -119,7 +119,7 @@ int64_t RebalancePushImpl::computePullFromWhere(const MQMessageQueue& mq) {
           try {
             // FIXME: parseDate by YYYYMMDDHHMMSS
             auto timestamp =
-                std::stoull(default_mq_push_consumer_impl_->getDefaultMQPushConsumerConfig()->getConsumeTimestamp());
+                std::stoull(default_mq_push_consumer_impl_->getDefaultMQPushConsumerConfig()->consume_timestamp());
             result = default_mq_push_consumer_impl_->searchOffset(mq, timestamp);
           } catch (MQClientException& e) {
             LOG_ERROR_NEW("CONSUME_FROM_TIMESTAMP error, searchOffset of mq:{}, return 0", mq.toString());
diff --git a/src/extern/CMessage.cpp b/src/extern/CMessage.cpp
index b7db245..2a30147 100644
--- a/src/extern/CMessage.cpp
+++ b/src/extern/CMessage.cpp
@@ -23,7 +23,7 @@ using namespace rocketmq;
 CMessage* CreateMessage(const char* topic) {
   auto* msg = new MQMessage();
   if (topic != NULL) {
-    msg->setTopic(topic);
+    msg->set_topic(topic);
   }
   return reinterpret_cast<CMessage*>(msg);
 }
@@ -40,7 +40,7 @@ int SetMessageTopic(CMessage* msg, const char* topic) {
   if (msg == NULL) {
     return NULL_POINTER;
   }
-  reinterpret_cast<MQMessage*>(msg)->setTopic(topic);
+  reinterpret_cast<MQMessage*>(msg)->set_topic(topic);
   return OK;
 }
 
@@ -48,7 +48,7 @@ int SetMessageTags(CMessage* msg, const char* tags) {
   if (msg == NULL) {
     return NULL_POINTER;
   }
-  reinterpret_cast<MQMessage*>(msg)->setTags(tags);
+  reinterpret_cast<MQMessage*>(msg)->set_tags(tags);
   return OK;
 }
 
@@ -56,7 +56,7 @@ int SetMessageKeys(CMessage* msg, const char* keys) {
   if (msg == NULL) {
     return NULL_POINTER;
   }
-  reinterpret_cast<MQMessage*>(msg)->setKeys(keys);
+  reinterpret_cast<MQMessage*>(msg)->set_keys(keys);
   return OK;
 }
 
@@ -64,7 +64,7 @@ int SetMessageBody(CMessage* msg, const char* body) {
   if (msg == NULL) {
     return NULL_POINTER;
   }
-  reinterpret_cast<MQMessage*>(msg)->setBody(std::string(body));
+  reinterpret_cast<MQMessage*>(msg)->set_body(std::string(body));
   return OK;
 }
 
@@ -73,7 +73,7 @@ int SetByteMessageBody(CMessage* msg, const char* body, int len) {
     return NULL_POINTER;
   }
 
-  reinterpret_cast<MQMessage*>(msg)->setBody(std::string(body, len));
+  reinterpret_cast<MQMessage*>(msg)->set_body(std::string(body, len));
   return OK;
 }
 
@@ -89,7 +89,7 @@ int SetDelayTimeLevel(CMessage* msg, int level) {
   if (msg == NULL) {
     return NULL_POINTER;
   }
-  reinterpret_cast<MQMessage*>(msg)->setDelayTimeLevel(level);
+  reinterpret_cast<MQMessage*>(msg)->set_delay_time_level(level);
   return OK;
 }
 
@@ -97,28 +97,28 @@ const char* GetOriginMessageTopic(CMessage* msg) {
   if (msg == NULL) {
     return NULL;
   }
-  return reinterpret_cast<MQMessage*>(msg)->getTopic().c_str();
+  return reinterpret_cast<MQMessage*>(msg)->topic().c_str();
 }
 
 const char* GetOriginMessageTags(CMessage* msg) {
   if (msg == NULL) {
     return NULL;
   }
-  return reinterpret_cast<MQMessage*>(msg)->getTags().c_str();
+  return reinterpret_cast<MQMessage*>(msg)->tags().c_str();
 }
 
 const char* GetOriginMessageKeys(CMessage* msg) {
   if (msg == NULL) {
     return NULL;
   }
-  return reinterpret_cast<MQMessage*>(msg)->getKeys().c_str();
+  return reinterpret_cast<MQMessage*>(msg)->keys().c_str();
 }
 
 const char* GetOriginMessageBody(CMessage* msg) {
   if (msg == NULL) {
     return NULL;
   }
-  return reinterpret_cast<MQMessage*>(msg)->getBody().c_str();
+  return reinterpret_cast<MQMessage*>(msg)->body().c_str();
 }
 
 const char* GetOriginMessageProperty(CMessage* msg, const char* key) {
@@ -132,5 +132,5 @@ int GetOriginDelayTimeLevel(CMessage* msg) {
   if (msg == NULL) {
     return -1;
   }
-  return reinterpret_cast<MQMessage*>(msg)->getDelayTimeLevel();
+  return reinterpret_cast<MQMessage*>(msg)->delay_time_level();
 }
diff --git a/src/extern/CMessageExt.cpp b/src/extern/CMessageExt.cpp
index 247ba5b..1ddde93 100644
--- a/src/extern/CMessageExt.cpp
+++ b/src/extern/CMessageExt.cpp
@@ -24,28 +24,28 @@ const char* GetMessageTopic(CMessageExt* msg) {
   if (msg == NULL) {
     return NULL;
   }
-  return reinterpret_cast<MQMessageExt*>(msg)->getTopic().c_str();
+  return reinterpret_cast<MQMessageExt*>(msg)->topic().c_str();
 }
 
 const char* GetMessageTags(CMessageExt* msg) {
   if (msg == NULL) {
     return NULL;
   }
-  return reinterpret_cast<MQMessageExt*>(msg)->getTags().c_str();
+  return reinterpret_cast<MQMessageExt*>(msg)->tags().c_str();
 }
 
 const char* GetMessageKeys(CMessageExt* msg) {
   if (msg == NULL) {
     return NULL;
   }
-  return reinterpret_cast<MQMessageExt*>(msg)->getKeys().c_str();
+  return reinterpret_cast<MQMessageExt*>(msg)->keys().c_str();
 }
 
 const char* GetMessageBody(CMessageExt* msg) {
   if (msg == NULL) {
     return NULL;
   }
-  return reinterpret_cast<MQMessageExt*>(msg)->getBody().c_str();
+  return reinterpret_cast<MQMessageExt*>(msg)->body().c_str();
 }
 
 const char* GetMessageProperty(CMessageExt* msg, const char* key) {
@@ -59,68 +59,68 @@ const char* GetMessageId(CMessageExt* msg) {
   if (msg == NULL) {
     return NULL;
   }
-  return reinterpret_cast<MQMessageExt*>(msg)->getMsgId().c_str();
+  return reinterpret_cast<MQMessageExt*>(msg)->msg_id().c_str();
 }
 
 int GetMessageDelayTimeLevel(CMessageExt* msg) {
   if (msg == NULL) {
     return NULL_POINTER;
   }
-  return reinterpret_cast<MQMessageExt*>(msg)->getDelayTimeLevel();
+  return reinterpret_cast<MQMessageExt*>(msg)->delay_time_level();
 }
 
 int GetMessageQueueId(CMessageExt* msg) {
   if (msg == NULL) {
     return NULL_POINTER;
   }
-  return reinterpret_cast<MQMessageExt*>(msg)->getQueueId();
+  return reinterpret_cast<MQMessageExt*>(msg)->queue_id();
 }
 
 int GetMessageReconsumeTimes(CMessageExt* msg) {
   if (msg == NULL) {
     return NULL_POINTER;
   }
-  return reinterpret_cast<MQMessageExt*>(msg)->getReconsumeTimes();
+  return reinterpret_cast<MQMessageExt*>(msg)->reconsume_times();
 }
 
 int GetMessageStoreSize(CMessageExt* msg) {
   if (msg == NULL) {
     return NULL_POINTER;
   }
-  return reinterpret_cast<MQMessageExt*>(msg)->getStoreSize();
+  return reinterpret_cast<MQMessageExt*>(msg)->store_size();
 }
 
 long long GetMessageBornTimestamp(CMessageExt* msg) {
   if (msg == NULL) {
     return NULL_POINTER;
   }
-  return reinterpret_cast<MQMessageExt*>(msg)->getBornTimestamp();
+  return reinterpret_cast<MQMessageExt*>(msg)->born_timestamp();
 }
 
 long long GetMessageStoreTimestamp(CMessageExt* msg) {
   if (msg == NULL) {
     return NULL_POINTER;
   }
-  return reinterpret_cast<MQMessageExt*>(msg)->getStoreTimestamp();
+  return reinterpret_cast<MQMessageExt*>(msg)->store_timestamp();
 }
 
 long long GetMessageQueueOffset(CMessageExt* msg) {
   if (msg == NULL) {
     return NULL_POINTER;
   }
-  return reinterpret_cast<MQMessageExt*>(msg)->getQueueOffset();
+  return reinterpret_cast<MQMessageExt*>(msg)->queue_offset();
 }
 
 long long GetMessageCommitLogOffset(CMessageExt* msg) {
   if (msg == NULL) {
     return NULL_POINTER;
   }
-  return reinterpret_cast<MQMessageExt*>(msg)->getCommitLogOffset();
+  return reinterpret_cast<MQMessageExt*>(msg)->commit_log_offset();
 }
 
 long long GetMessagePreparedTransactionOffset(CMessageExt* msg) {
   if (msg == NULL) {
     return NULL_POINTER;
   }
-  return reinterpret_cast<MQMessageExt*>(msg)->getPreparedTransactionOffset();
+  return reinterpret_cast<MQMessageExt*>(msg)->prepared_transaction_offset();
 }
diff --git a/src/extern/CProducer.cpp b/src/extern/CProducer.cpp
index 33dd4da..edf6072 100644
--- a/src/extern/CProducer.cpp
+++ b/src/extern/CProducer.cpp
@@ -127,9 +127,9 @@ class COnSendCallback : public AutoDeleteSendCallback {
 
   void onSuccess(SendResult& sendResult) override {
     CSendResult result;
-    result.sendStatus = CSendStatus((int)sendResult.getSendStatus());
-    result.offset = sendResult.getQueueOffset();
-    strncpy(result.msgId, sendResult.getMsgId().c_str(), MAX_MESSAGE_ID_LENGTH - 1);
+    result.sendStatus = CSendStatus((int)sendResult.send_status());
+    result.offset = sendResult.queue_offset();
+    strncpy(result.msgId, sendResult.msg_id().c_str(), MAX_MESSAGE_ID_LENGTH - 1);
     result.msgId[MAX_MESSAGE_ID_LENGTH - 1] = 0;
     send_success_callback_(result, message_, user_data_);
   }
@@ -159,9 +159,9 @@ class CSendCallback : public AutoDeleteSendCallback {
 
   void onSuccess(SendResult& sendResult) override {
     CSendResult result;
-    result.sendStatus = CSendStatus((int)sendResult.getSendStatus());
-    result.offset = sendResult.getQueueOffset();
-    strncpy(result.msgId, sendResult.getMsgId().c_str(), MAX_MESSAGE_ID_LENGTH - 1);
+    result.sendStatus = CSendStatus((int)sendResult.send_status());
+    result.offset = sendResult.queue_offset();
+    strncpy(result.msgId, sendResult.msg_id().c_str(), MAX_MESSAGE_ID_LENGTH - 1);
     result.msgId[MAX_MESSAGE_ID_LENGTH - 1] = 0;
     send_success_callback_(result);
   }
@@ -236,7 +236,7 @@ int SetProducerNameServerAddress(CProducer* producer, const char* namesrv) {
   if (producer == NULL) {
     return NULL_POINTER;
   }
-  reinterpret_cast<DefaultMQProducer*>(producer)->setNamesrvAddr(namesrv);
+  reinterpret_cast<DefaultMQProducer*>(producer)->set_namesrv_addr(namesrv);
   return OK;
 }
 
@@ -257,7 +257,7 @@ int SendMessageSync(CProducer* producer, CMessage* msg, CSendResult* result) {
     auto* defaultMQProducer = reinterpret_cast<DefaultMQProducer*>(producer);
     auto* message = reinterpret_cast<MQMessage*>(msg);
     auto sendResult = defaultMQProducer->send(*message);
-    switch (sendResult.getSendStatus()) {
+    switch (sendResult.send_status()) {
       case SEND_OK:
         result->sendStatus = E_SEND_OK;
         break;
@@ -274,8 +274,8 @@ int SendMessageSync(CProducer* producer, CMessage* msg, CSendResult* result) {
         result->sendStatus = E_SEND_OK;
         break;
     }
-    result->offset = sendResult.getQueueOffset();
-    strncpy(result->msgId, sendResult.getMsgId().c_str(), MAX_MESSAGE_ID_LENGTH - 1);
+    result->offset = sendResult.queue_offset();
+    strncpy(result->msgId, sendResult.msg_id().c_str(), MAX_MESSAGE_ID_LENGTH - 1);
     result->msgId[MAX_MESSAGE_ID_LENGTH - 1] = 0;
   } catch (std::exception& e) {
     CErrorContainer::setErrorMessage(e.what());
@@ -292,7 +292,7 @@ int SendBatchMessage(CProducer* producer, CBatchMessage* batcMsg, CSendResult* r
     auto* defaultMQProducer = reinterpret_cast<DefaultMQProducer*>(producer);
     auto* message = reinterpret_cast<std::vector<MQMessage>*>(batcMsg);
     auto sendResult = defaultMQProducer->send(*message);
-    switch (sendResult.getSendStatus()) {
+    switch (sendResult.send_status()) {
       case SEND_OK:
         result->sendStatus = E_SEND_OK;
         break;
@@ -309,8 +309,8 @@ int SendBatchMessage(CProducer* producer, CBatchMessage* batcMsg, CSendResult* r
         result->sendStatus = E_SEND_OK;
         break;
     }
-    result->offset = sendResult.getQueueOffset();
-    strncpy(result->msgId, sendResult.getMsgId().c_str(), MAX_MESSAGE_ID_LENGTH - 1);
+    result->offset = sendResult.queue_offset();
+    strncpy(result->msgId, sendResult.msg_id().c_str(), MAX_MESSAGE_ID_LENGTH - 1);
     result->msgId[MAX_MESSAGE_ID_LENGTH - 1] = 0;
   } catch (std::exception& e) {
     return PRODUCER_SEND_SYNC_FAILED;
@@ -412,9 +412,9 @@ int SendMessageOrderly(CProducer* producer,
     SelectMessageQueue selectMessageQueue(selectorCallback);
     SendResult send_result = defaultMQProducer->send(*message, &selectMessageQueue, arg);
     // Convert SendStatus to CSendStatus
-    result->sendStatus = CSendStatus((int)send_result.getSendStatus());
-    result->offset = send_result.getQueueOffset();
-    strncpy(result->msgId, send_result.getMsgId().c_str(), MAX_MESSAGE_ID_LENGTH - 1);
+    result->sendStatus = CSendStatus((int)send_result.send_status());
+    result->offset = send_result.queue_offset();
+    strncpy(result->msgId, send_result.msg_id().c_str(), MAX_MESSAGE_ID_LENGTH - 1);
     result->msgId[MAX_MESSAGE_ID_LENGTH - 1] = 0;
   } catch (std::exception& e) {
     CErrorContainer::setErrorMessage(e.what());
@@ -435,9 +435,9 @@ int SendMessageOrderlyByShardingKey(CProducer* producer, CMessage* msg, const ch
     SelectMessageQueueInner selectMessageQueue;
     SendResult send_esult = defaultMQProducer->send(*message, &selectMessageQueue, (void*)shardingKey, retryTimes);
     // Convert SendStatus to CSendStatus
-    result->sendStatus = CSendStatus((int)send_esult.getSendStatus());
-    result->offset = send_esult.getQueueOffset();
-    strncpy(result->msgId, send_esult.getMsgId().c_str(), MAX_MESSAGE_ID_LENGTH - 1);
+    result->sendStatus = CSendStatus((int)send_esult.send_status());
+    result->offset = send_esult.queue_offset();
+    strncpy(result->msgId, send_esult.msg_id().c_str(), MAX_MESSAGE_ID_LENGTH - 1);
     result->msgId[MAX_MESSAGE_ID_LENGTH - 1] = 0;
   } catch (std::exception& e) {
     CErrorContainer::setErrorMessage(e.what());
@@ -459,9 +459,9 @@ int SendMessageTransaction(CProducer* producer,
     auto* message = reinterpret_cast<MQMessage*>(msg);
     LocalTransactionExecutorInner executorInner(callback, msg, userData);
     auto send_result = transactionMQProducer->sendMessageInTransaction(*message, &executorInner);
-    result->sendStatus = CSendStatus((int)send_result.getSendStatus());
-    result->offset = send_result.getQueueOffset();
-    strncpy(result->msgId, send_result.getMsgId().c_str(), MAX_MESSAGE_ID_LENGTH - 1);
+    result->sendStatus = CSendStatus((int)send_result.send_status());
+    result->offset = send_result.queue_offset();
+    strncpy(result->msgId, send_result.msg_id().c_str(), MAX_MESSAGE_ID_LENGTH - 1);
     result->msgId[MAX_MESSAGE_ID_LENGTH - 1] = 0;
   } catch (std::exception& e) {
     CErrorContainer::setErrorMessage(e.what());
@@ -474,7 +474,7 @@ int SetProducerGroupName(CProducer* producer, const char* groupName) {
   if (producer == NULL) {
     return NULL_POINTER;
   }
-  reinterpret_cast<DefaultMQProducer*>(producer)->setGroupName(groupName);
+  reinterpret_cast<DefaultMQProducer*>(producer)->set_group_name(groupName);
   return OK;
 }
 
@@ -482,7 +482,7 @@ int SetProducerInstanceName(CProducer* producer, const char* instanceName) {
   if (producer == NULL) {
     return NULL_POINTER;
   }
-  reinterpret_cast<DefaultMQProducer*>(producer)->setInstanceName(instanceName);
+  reinterpret_cast<DefaultMQProducer*>(producer)->set_instance_name(instanceName);
   return OK;
 }
 
@@ -527,7 +527,7 @@ int SetProducerSendMsgTimeout(CProducer* producer, int timeout) {
   if (producer == NULL) {
     return NULL_POINTER;
   }
-  reinterpret_cast<DefaultMQProducer*>(producer)->setSendMsgTimeout(timeout);
+  reinterpret_cast<DefaultMQProducer*>(producer)->set_send_msg_timeout(timeout);
   return OK;
 }
 
@@ -535,7 +535,7 @@ int SetProducerCompressMsgBodyOverHowmuch(CProducer* producer, int howmuch) {
   if (producer == NULL) {
     return NULL_POINTER;
   }
-  reinterpret_cast<DefaultMQProducer*>(producer)->setCompressMsgBodyOverHowmuch(howmuch);
+  reinterpret_cast<DefaultMQProducer*>(producer)->set_compress_msg_body_over_howmuch(howmuch);
   return OK;
 }
 
@@ -543,7 +543,7 @@ int SetProducerCompressLevel(CProducer* producer, int level) {
   if (producer == NULL) {
     return NULL_POINTER;
   }
-  reinterpret_cast<DefaultMQProducer*>(producer)->setCompressLevel(level);
+  reinterpret_cast<DefaultMQProducer*>(producer)->set_compress_level(level);
   return OK;
 }
 
@@ -551,6 +551,6 @@ int SetProducerMaxMessageSize(CProducer* producer, int size) {
   if (producer == NULL) {
     return NULL_POINTER;
   }
-  reinterpret_cast<DefaultMQProducer*>(producer)->setMaxMessageSize(size);
+  reinterpret_cast<DefaultMQProducer*>(producer)->set_max_message_size(size);
   return OK;
 }
diff --git a/src/extern/CPullConsumer.cpp b/src/extern/CPullConsumer.cpp
index bce4b61..b4ed9ac 100644
--- a/src/extern/CPullConsumer.cpp
+++ b/src/extern/CPullConsumer.cpp
@@ -66,7 +66,7 @@ int SetPullConsumerGroupID(CPullConsumer* consumer, const char* groupId) {
   if (consumer == NULL || groupId == NULL) {
     return NULL_POINTER;
   }
-  reinterpret_cast<DefaultMQPullConsumer*>(consumer)->setGroupName(groupId);
+  reinterpret_cast<DefaultMQPullConsumer*>(consumer)->set_group_name(groupId);
   return OK;
 }
 
@@ -74,14 +74,14 @@ const char* GetPullConsumerGroupID(CPullConsumer* consumer) {
   if (consumer == NULL) {
     return NULL;
   }
-  return reinterpret_cast<DefaultMQPullConsumer*>(consumer)->getGroupName().c_str();
+  return reinterpret_cast<DefaultMQPullConsumer*>(consumer)->group_name().c_str();
 }
 
 int SetPullConsumerNameServerAddress(CPullConsumer* consumer, const char* namesrv) {
   if (consumer == NULL) {
     return NULL_POINTER;
   }
-  reinterpret_cast<DefaultMQPullConsumer*>(consumer)->setNamesrvAddr(namesrv);
+  reinterpret_cast<DefaultMQPullConsumer*>(consumer)->set_namesrv_addr(namesrv);
   return OK;
 }
 
diff --git a/src/extern/CPushConsumer.cpp b/src/extern/CPushConsumer.cpp
index 6287a2e..feb7693 100644
--- a/src/extern/CPushConsumer.cpp
+++ b/src/extern/CPushConsumer.cpp
@@ -79,7 +79,7 @@ CPushConsumer* CreatePushConsumer(const char* groupId) {
     return NULL;
   }
   auto* defaultMQPushConsumer = new DefaultMQPushConsumer(groupId);
-  defaultMQPushConsumer->setConsumeFromWhere(CONSUME_FROM_LAST_OFFSET);
+  defaultMQPushConsumer->set_consume_from_where(CONSUME_FROM_LAST_OFFSET);
   return reinterpret_cast<CPushConsumer*>(defaultMQPushConsumer);
 }
 
@@ -116,7 +116,7 @@ int SetPushConsumerGroupID(CPushConsumer* consumer, const char* groupId) {
   if (consumer == NULL || groupId == NULL) {
     return NULL_POINTER;
   }
-  reinterpret_cast<DefaultMQPushConsumer*>(consumer)->setGroupName(groupId);
+  reinterpret_cast<DefaultMQPushConsumer*>(consumer)->set_group_name(groupId);
   return OK;
 }
 
@@ -124,14 +124,14 @@ const char* GetPushConsumerGroupID(CPushConsumer* consumer) {
   if (consumer == NULL) {
     return NULL;
   }
-  return reinterpret_cast<DefaultMQPushConsumer*>(consumer)->getGroupName().c_str();
+  return reinterpret_cast<DefaultMQPushConsumer*>(consumer)->group_name().c_str();
 }
 
 int SetPushConsumerNameServerAddress(CPushConsumer* consumer, const char* namesrv) {
   if (consumer == NULL) {
     return NULL_POINTER;
   }
-  reinterpret_cast<DefaultMQPushConsumer*>(consumer)->setNamesrvAddr(namesrv);
+  reinterpret_cast<DefaultMQPushConsumer*>(consumer)->set_namesrv_addr(namesrv);
   return OK;
 }
 
@@ -191,7 +191,7 @@ int SetPushConsumerMessageModel(CPushConsumer* consumer, CMessageModel messageMo
   if (consumer == NULL) {
     return NULL_POINTER;
   }
-  reinterpret_cast<DefaultMQPushConsumer*>(consumer)->setMessageModel(MessageModel((int)messageModel));
+  reinterpret_cast<DefaultMQPushConsumer*>(consumer)->set_message_model(MessageModel((int)messageModel));
   return OK;
 }
 
@@ -199,7 +199,7 @@ int SetPushConsumerThreadCount(CPushConsumer* consumer, int threadCount) {
   if (consumer == NULL || threadCount == 0) {
     return NULL_POINTER;
   }
-  reinterpret_cast<DefaultMQPushConsumer*>(consumer)->setConsumeThreadNum(threadCount);
+  reinterpret_cast<DefaultMQPushConsumer*>(consumer)->set_consume_thread_nums(threadCount);
   return OK;
 }
 
@@ -207,7 +207,7 @@ int SetPushConsumerMessageBatchMaxSize(CPushConsumer* consumer, int batchSize) {
   if (consumer == NULL || batchSize == 0) {
     return NULL_POINTER;
   }
-  reinterpret_cast<DefaultMQPushConsumer*>(consumer)->setConsumeMessageBatchMaxSize(batchSize);
+  reinterpret_cast<DefaultMQPushConsumer*>(consumer)->set_consume_message_batch_max_size(batchSize);
   return OK;
 }
 
@@ -215,7 +215,7 @@ int SetPushConsumerMaxCacheMessageSize(CPushConsumer* consumer, int maxCacheSize
   if (consumer == NULL || maxCacheSize <= 0) {
     return NULL_POINTER;
   }
-  reinterpret_cast<DefaultMQPushConsumer*>(consumer)->setMaxCacheMsgSizePerQueue(maxCacheSize);
+  reinterpret_cast<DefaultMQPushConsumer*>(consumer)->set_max_cache_msg_size_per_queue(maxCacheSize);
   return OK;
 }
 
@@ -229,7 +229,7 @@ int SetPushConsumerInstanceName(CPushConsumer* consumer, const char* instanceNam
   if (consumer == NULL) {
     return NULL_POINTER;
   }
-  reinterpret_cast<DefaultMQPushConsumer*>(consumer)->setInstanceName(instanceName);
+  reinterpret_cast<DefaultMQPushConsumer*>(consumer)->set_instance_name(instanceName);
   return OK;
 }
 
diff --git a/src/message/MQMessage.cpp b/src/message/MQMessage.cpp
index 0e46e9d..af115be 100644
--- a/src/message/MQMessage.cpp
+++ b/src/message/MQMessage.cpp
@@ -62,92 +62,92 @@ void MQMessage::clearProperty(const std::string& name) {
   message_impl_->clearProperty(name);
 }
 
-const std::string& MQMessage::getTopic() const {
-  return message_impl_->getTopic();
+const std::string& MQMessage::topic() const {
+  return message_impl_->topic();
 }
 
-void MQMessage::setTopic(const std::string& topic) {
-  message_impl_->setTopic(topic);
+void MQMessage::set_topic(const std::string& topic) {
+  message_impl_->set_topic(topic);
 }
 
-void MQMessage::setTopic(const char* body, int len) {
-  message_impl_->setTopic(body, len);
+void MQMessage::set_topic(const char* body, int len) {
+  message_impl_->set_topic(body, len);
 }
 
-const std::string& MQMessage::getTags() const {
-  return message_impl_->getTags();
+const std::string& MQMessage::tags() const {
+  return message_impl_->tags();
 }
 
-void MQMessage::setTags(const std::string& tags) {
-  message_impl_->setTags(tags);
+void MQMessage::set_tags(const std::string& tags) {
+  message_impl_->set_tags(tags);
 }
 
-const std::string& MQMessage::getKeys() const {
-  return message_impl_->getKeys();
+const std::string& MQMessage::keys() const {
+  return message_impl_->keys();
 }
 
-void MQMessage::setKeys(const std::string& keys) {
-  message_impl_->setKeys(keys);
+void MQMessage::set_keys(const std::string& keys) {
+  message_impl_->set_keys(keys);
 }
 
-void MQMessage::setKeys(const std::vector<std::string>& keys) {
-  message_impl_->setKeys(keys);
+void MQMessage::set_keys(const std::vector<std::string>& keys) {
+  message_impl_->set_keys(keys);
 }
 
-int MQMessage::getDelayTimeLevel() const {
-  return message_impl_->getDelayTimeLevel();
+int MQMessage::delay_time_level() const {
+  return message_impl_->delay_time_level();
 }
 
-void MQMessage::setDelayTimeLevel(int level) {
-  message_impl_->setDelayTimeLevel(level);
+void MQMessage::set_delay_time_level(int level) {
+  message_impl_->set_delay_time_level(level);
 }
 
-bool MQMessage::isWaitStoreMsgOK() const {
-  return message_impl_->isWaitStoreMsgOK();
+bool MQMessage::wait_store_msg_ok() const {
+  return message_impl_->wait_store_msg_ok();
 }
 
-void MQMessage::setWaitStoreMsgOK(bool waitStoreMsgOK) {
-  message_impl_->setWaitStoreMsgOK(waitStoreMsgOK);
+void MQMessage::set_wait_store_msg_ok(bool waitStoreMsgOK) {
+  message_impl_->set_wait_store_msg_ok(waitStoreMsgOK);
 }
 
-int32_t MQMessage::getFlag() const {
-  return message_impl_->getFlag();
+int32_t MQMessage::flag() const {
+  return message_impl_->flag();
 }
 
-void MQMessage::setFlag(int32_t flag) {
-  message_impl_->setFlag(flag);
+void MQMessage::set_flag(int32_t flag) {
+  message_impl_->set_flag(flag);
 }
 
-const std::string& MQMessage::getBody() const {
-  return message_impl_->getBody();
+const std::string& MQMessage::body() const {
+  return message_impl_->body();
 }
 
-void MQMessage::setBody(const std::string& body) {
-  message_impl_->setBody(body);
+void MQMessage::set_body(const std::string& body) {
+  message_impl_->set_body(body);
 }
 
-void MQMessage::setBody(std::string&& body) {
-  message_impl_->setBody(std::move(body));
+void MQMessage::set_body(std::string&& body) {
+  message_impl_->set_body(std::move(body));
 }
 
-const std::string& MQMessage::getTransactionId() const {
-  return message_impl_->getTransactionId();
+const std::string& MQMessage::transaction_id() const {
+  return message_impl_->transaction_id();
 }
 
-void MQMessage::setTransactionId(const std::string& transactionId) {
-  message_impl_->setTransactionId(transactionId);
+void MQMessage::set_transaction_id(const std::string& transactionId) {
+  message_impl_->set_transaction_id(transactionId);
 }
 
-const std::map<std::string, std::string>& MQMessage::getProperties() const {
-  return message_impl_->getProperties();
+const std::map<std::string, std::string>& MQMessage::properties() const {
+  return message_impl_->properties();
 }
 
-void MQMessage::setProperties(const std::map<std::string, std::string>& properties) {
-  message_impl_->setProperties(properties);
+void MQMessage::set_properties(const std::map<std::string, std::string>& properties) {
+  message_impl_->set_properties(properties);
 }
 
-void MQMessage::setProperties(std::map<std::string, std::string>&& properties) {
-  message_impl_->setProperties(std::move(properties));
+void MQMessage::set_properties(std::map<std::string, std::string>&& properties) {
+  message_impl_->set_properties(std::move(properties));
 }
 
 bool MQMessage::isBatch() const {
diff --git a/src/message/MQMessageExt.cpp b/src/message/MQMessageExt.cpp
index 957c023..a58d035 100644
--- a/src/message/MQMessageExt.cpp
+++ b/src/message/MQMessageExt.cpp
@@ -33,116 +33,116 @@ MQMessageExt::MQMessageExt(int queueId,
 
 MQMessageExt::~MQMessageExt() = default;
 
-int32_t MQMessageExt::getStoreSize() const {
-  return dynamic_cast<MessageExt*>(message_impl_.get())->getStoreSize();
+int32_t MQMessageExt::store_size() const {
+  return dynamic_cast<MessageExt*>(message_impl_.get())->store_size();
 }
 
-void MQMessageExt::setStoreSize(int32_t storeSize) {
-  dynamic_cast<MessageExt*>(message_impl_.get())->setStoreSize(storeSize);
+void MQMessageExt::set_store_size(int32_t storeSize) {
+  dynamic_cast<MessageExt*>(message_impl_.get())->set_store_size(storeSize);
 }
 
-int32_t MQMessageExt::getBodyCRC() const {
-  return dynamic_cast<MessageExt*>(message_impl_.get())->getBodyCRC();
+int32_t MQMessageExt::body_crc() const {
+  return dynamic_cast<MessageExt*>(message_impl_.get())->body_crc();
 }
 
-void MQMessageExt::setBodyCRC(int32_t bodyCRC) {
-  dynamic_cast<MessageExt*>(message_impl_.get())->setBodyCRC(bodyCRC);
+void MQMessageExt::set_body_crc(int32_t bodyCRC) {
+  dynamic_cast<MessageExt*>(message_impl_.get())->set_body_crc(bodyCRC);
 }
 
-int32_t MQMessageExt::getQueueId() const {
-  return dynamic_cast<MessageExt*>(message_impl_.get())->getQueueId();
+int32_t MQMessageExt::queue_id() const {
+  return dynamic_cast<MessageExt*>(message_impl_.get())->queue_id();
 }
 
-void MQMessageExt::setQueueId(int32_t queueId) {
-  dynamic_cast<MessageExt*>(message_impl_.get())->setQueueId(queueId);
+void MQMessageExt::set_queue_id(int32_t queueId) {
+  dynamic_cast<MessageExt*>(message_impl_.get())->set_queue_id(queueId);
 }
 
-int64_t MQMessageExt::getQueueOffset() const {
-  return dynamic_cast<MessageExt*>(message_impl_.get())->getQueueOffset();
+int64_t MQMessageExt::queue_offset() const {
+  return dynamic_cast<MessageExt*>(message_impl_.get())->queue_offset();
 }
 
-void MQMessageExt::setQueueOffset(int64_t queueOffset) {
-  dynamic_cast<MessageExt*>(message_impl_.get())->setQueueOffset(queueOffset);
+void MQMessageExt::set_queue_offset(int64_t queueOffset) {
+  dynamic_cast<MessageExt*>(message_impl_.get())->set_queue_offset(queueOffset);
 }
 
-int64_t MQMessageExt::getCommitLogOffset() const {
-  return dynamic_cast<MessageExt*>(message_impl_.get())->getCommitLogOffset();
+int64_t MQMessageExt::commit_log_offset() const {
+  return dynamic_cast<MessageExt*>(message_impl_.get())->commit_log_offset();
 }
 
-void MQMessageExt::setCommitLogOffset(int64_t physicOffset) {
-  dynamic_cast<MessageExt*>(message_impl_.get())->setCommitLogOffset(physicOffset);
+void MQMessageExt::set_commit_log_offset(int64_t physicOffset) {
+  dynamic_cast<MessageExt*>(message_impl_.get())->set_commit_log_offset(physicOffset);
 }
 
-int32_t MQMessageExt::getSysFlag() const {
-  return dynamic_cast<MessageExt*>(message_impl_.get())->getSysFlag();
+int32_t MQMessageExt::sys_flag() const {
+  return dynamic_cast<MessageExt*>(message_impl_.get())->sys_flag();
 }
 
-void MQMessageExt::setSysFlag(int32_t sysFlag) {
-  dynamic_cast<MessageExt*>(message_impl_.get())->setSysFlag(sysFlag);
+void MQMessageExt::set_sys_flag(int32_t sysFlag) {
+  dynamic_cast<MessageExt*>(message_impl_.get())->set_sys_flag(sysFlag);
 }
 
-int64_t MQMessageExt::getBornTimestamp() const {
-  return dynamic_cast<MessageExt*>(message_impl_.get())->getBornTimestamp();
+int64_t MQMessageExt::born_timestamp() const {
+  return dynamic_cast<MessageExt*>(message_impl_.get())->born_timestamp();
 }
 
-void MQMessageExt::setBornTimestamp(int64_t bornTimestamp) {
-  dynamic_cast<MessageExt*>(message_impl_.get())->setBornTimestamp(bornTimestamp);
+void MQMessageExt::set_born_timestamp(int64_t bornTimestamp) {
+  dynamic_cast<MessageExt*>(message_impl_.get())->set_born_timestamp(bornTimestamp);
 }
 
-std::string MQMessageExt::getBornHostString() const {
-  return dynamic_cast<MessageExt*>(message_impl_.get())->getBornHostString();
+std::string MQMessageExt::born_host_string() const {
+  return dynamic_cast<MessageExt*>(message_impl_.get())->born_host_string();
 }
 
-const struct sockaddr* MQMessageExt::getBornHost() const {
-  return dynamic_cast<MessageExt*>(message_impl_.get())->getBornHost();
+const struct sockaddr* MQMessageExt::born_host() const {
+  return dynamic_cast<MessageExt*>(message_impl_.get())->born_host();
 }
 
-void MQMessageExt::setBornHost(const struct sockaddr* bornHost) {
-  dynamic_cast<MessageExt*>(message_impl_.get())->setBornHost(bornHost);
+void MQMessageExt::set_born_host(const struct sockaddr* bornHost) {
+  dynamic_cast<MessageExt*>(message_impl_.get())->set_born_host(bornHost);
 }
 
-int64_t MQMessageExt::getStoreTimestamp() const {
-  return dynamic_cast<MessageExt*>(message_impl_.get())->getStoreTimestamp();
+int64_t MQMessageExt::store_timestamp() const {
+  return dynamic_cast<MessageExt*>(message_impl_.get())->store_timestamp();
 }
 
-void MQMessageExt::setStoreTimestamp(int64_t storeTimestamp) {
-  dynamic_cast<MessageExt*>(message_impl_.get())->setStoreTimestamp(storeTimestamp);
+void MQMessageExt::set_store_timestamp(int64_t storeTimestamp) {
+  dynamic_cast<MessageExt*>(message_impl_.get())->set_store_timestamp(storeTimestamp);
 }
 
-std::string MQMessageExt::getStoreHostString() const {
-  return dynamic_cast<MessageExt*>(message_impl_.get())->getStoreHostString();
+std::string MQMessageExt::store_host_string() const {
+  return dynamic_cast<MessageExt*>(message_impl_.get())->store_host_string();
 }
 
-const struct sockaddr* MQMessageExt::getStoreHost() const {
-  return dynamic_cast<MessageExt*>(message_impl_.get())->getStoreHost();
+const struct sockaddr* MQMessageExt::store_host() const {
+  return dynamic_cast<MessageExt*>(message_impl_.get())->store_host();
 }
 
-void MQMessageExt::setStoreHost(const struct sockaddr* storeHost) {
-  dynamic_cast<MessageExt*>(message_impl_.get())->setStoreHost(storeHost);
+void MQMessageExt::set_store_host(const struct sockaddr* storeHost) {
+  dynamic_cast<MessageExt*>(message_impl_.get())->set_store_host(storeHost);
 }
 
-int32_t MQMessageExt::getReconsumeTimes() const {
-  return dynamic_cast<MessageExt*>(message_impl_.get())->getReconsumeTimes();
+int32_t MQMessageExt::reconsume_times() const {
+  return dynamic_cast<MessageExt*>(message_impl_.get())->reconsume_times();
 }
 
-void MQMessageExt::setReconsumeTimes(int32_t reconsumeTimes) {
-  dynamic_cast<MessageExt*>(message_impl_.get())->setReconsumeTimes(reconsumeTimes);
+void MQMessageExt::set_reconsume_times(int32_t reconsumeTimes) {
+  dynamic_cast<MessageExt*>(message_impl_.get())->set_reconsume_times(reconsumeTimes);
 }
 
-int64_t MQMessageExt::getPreparedTransactionOffset() const {
-  return dynamic_cast<MessageExt*>(message_impl_.get())->getPreparedTransactionOffset();
+int64_t MQMessageExt::prepared_transaction_offset() const {
+  return dynamic_cast<MessageExt*>(message_impl_.get())->prepared_transaction_offset();
 }
 
-void MQMessageExt::setPreparedTransactionOffset(int64_t preparedTransactionOffset) {
-  dynamic_cast<MessageExt*>(message_impl_.get())->setPreparedTransactionOffset(preparedTransactionOffset);
+void MQMessageExt::set_prepared_transaction_offset(int64_t preparedTransactionOffset) {
+  dynamic_cast<MessageExt*>(message_impl_.get())->set_prepared_transaction_offset(preparedTransactionOffset);
 }
 
-const std::string& MQMessageExt::getMsgId() const {
-  return dynamic_cast<MessageExt*>(message_impl_.get())->getMsgId();
+const std::string& MQMessageExt::msg_id() const {
+  return dynamic_cast<MessageExt*>(message_impl_.get())->msg_id();
 }
 
-void MQMessageExt::setMsgId(const std::string& msgId) {
-  dynamic_cast<MessageExt*>(message_impl_.get())->setMsgId(msgId);
+void MQMessageExt::set_msg_id(const std::string& msgId) {
+  dynamic_cast<MessageExt*>(message_impl_.get())->set_msg_id(msgId);
 }
 
 }  // namespace rocketmq
diff --git a/src/message/MessageAccessor.hpp b/src/message/MessageAccessor.hpp
index c10f9e0..87c1cac 100644
--- a/src/message/MessageAccessor.hpp
+++ b/src/message/MessageAccessor.hpp
@@ -28,7 +28,7 @@ class MessageAccessor {
   static inline void clearProperty(Message& msg, const std::string& name) { msg.clearProperty(name); }
 
   static inline void setProperties(Message& msg, std::map<std::string, std::string>&& properties) {
-    msg.setProperties(std::move(properties));
+    msg.set_properties(std::move(properties));
   }
 
   static inline void putProperty(Message& msg, const std::string& name, const std::string& value) {
diff --git a/src/message/MessageBatch.cpp b/src/message/MessageBatch.cpp
index 1f859f6..4030fd6 100644
--- a/src/message/MessageBatch.cpp
+++ b/src/message/MessageBatch.cpp
@@ -28,30 +28,30 @@ std::shared_ptr<MessageBatch> MessageBatch::generateFromList(std::vector<MQMessa
 
   // check messages
   for (auto& message : messages) {
-    if (message.getDelayTimeLevel() > 0) {
+    if (message.delay_time_level() > 0) {
       THROW_MQEXCEPTION(MQClientException, "TimeDelayLevel in not supported for batching", -1);
     }
     if (is_first) {
       is_first = false;
-      topic = message.getTopic();
-      wait_store_msg_ok = message.isWaitStoreMsgOK();
+      topic = message.topic();
+      wait_store_msg_ok = message.wait_store_msg_ok();
 
       if (UtilAll::isRetryTopic(topic)) {
         THROW_MQEXCEPTION(MQClientException, "Retry Group is not supported for batching", -1);
       }
     } else {
-      if (message.getTopic() != topic) {
+      if (message.topic() != topic) {
         THROW_MQEXCEPTION(MQClientException, "The topic of the messages in one batch should be the same", -1);
       }
-      if (message.isWaitStoreMsgOK() != wait_store_msg_ok) {
+      if (message.wait_store_msg_ok() != wait_store_msg_ok) {
         THROW_MQEXCEPTION(MQClientException, "The waitStoreMsgOK of the messages in one batch should the same", -2);
       }
     }
   }
 
   auto batchMessage = std::make_shared<MessageBatch>(messages);
-  batchMessage->setTopic(topic);
-  batchMessage->setWaitStoreMsgOK(wait_store_msg_ok);
+  batchMessage->set_topic(topic);
+  batchMessage->set_wait_store_msg_ok(wait_store_msg_ok);
   return batchMessage;
 }
 
diff --git a/src/message/MessageDecoder.cpp b/src/message/MessageDecoder.cpp
index 128ca7f..a36d3bf 100644
--- a/src/message/MessageDecoder.cpp
+++ b/src/message/MessageDecoder.cpp
@@ -89,64 +89,64 @@ MessageExtPtr MessageDecoder::decode(ByteBuffer& byteBuffer, bool readBody, bool
 
   // 1 TOTALSIZE
   int32_t storeSize = byteBuffer.getInt();
-  msgExt->setStoreSize(storeSize);
+  msgExt->set_store_size(storeSize);
 
   // 2 MAGICCODE sizeof(int)
   byteBuffer.getInt();
 
   // 3 BODYCRC
   int32_t bodyCRC = byteBuffer.getInt();
-  msgExt->setBodyCRC(bodyCRC);
+  msgExt->set_body_crc(bodyCRC);
 
   // 4 QUEUEID
   int32_t queueId = byteBuffer.getInt();
-  msgExt->setQueueId(queueId);
+  msgExt->set_queue_id(queueId);
 
   // 5 FLAG
   int32_t flag = byteBuffer.getInt();
-  msgExt->setFlag(flag);
+  msgExt->set_flag(flag);
 
   // 6 QUEUEOFFSET
   int64_t queueOffset = byteBuffer.getLong();
-  msgExt->setQueueOffset(queueOffset);
+  msgExt->set_queue_offset(queueOffset);
 
   // 7 PHYSICALOFFSET
   int64_t physicOffset = byteBuffer.getLong();
-  msgExt->setCommitLogOffset(physicOffset);
+  msgExt->set_commit_log_offset(physicOffset);
 
   // 8 SYSFLAG
   int32_t sysFlag = byteBuffer.getInt();
-  msgExt->setSysFlag(sysFlag);
+  msgExt->set_sys_flag(sysFlag);
 
   // 9 BORNTIMESTAMP
   int64_t bornTimeStamp = byteBuffer.getLong();
-  msgExt->setBornTimestamp(bornTimeStamp);
+  msgExt->set_born_timestamp(bornTimeStamp);
 
   // 10 BORNHOST
   int bornhostIPLength = (sysFlag & MessageSysFlag::BORNHOST_V6_FLAG) == 0 ? 4 : 16;
   ByteArray bornHost(bornhostIPLength);
   byteBuffer.get(bornHost, 0, bornhostIPLength);
   int32_t bornPort = byteBuffer.getInt();
-  msgExt->setBornHost(ipPort2SocketAddress(bornHost, bornPort));
+  msgExt->set_born_host(ipPort2SocketAddress(bornHost, bornPort));
 
   // 11 STORETIMESTAMP
   int64_t storeTimestamp = byteBuffer.getLong();
-  msgExt->setStoreTimestamp(storeTimestamp);
+  msgExt->set_store_timestamp(storeTimestamp);
 
   // 12 STOREHOST
   int storehostIPLength = (sysFlag & MessageSysFlag::STOREHOST_V6_FLAG) == 0 ? 4 : 16;
   ByteArray storeHost(bornhostIPLength);
   byteBuffer.get(storeHost, 0, storehostIPLength);
   int32_t storePort = byteBuffer.getInt();
-  msgExt->setStoreHost(ipPort2SocketAddress(storeHost, storePort));
+  msgExt->set_store_host(ipPort2SocketAddress(storeHost, storePort));
 
   // 13 RECONSUMETIMES
   int32_t reconsumeTimes = byteBuffer.getInt();
-  msgExt->setReconsumeTimes(reconsumeTimes);
+  msgExt->set_reconsume_times(reconsumeTimes);
 
   // 14 Prepared Transaction Offset
   int64_t preparedTransactionOffset = byteBuffer.getLong();
-  msgExt->setPreparedTransactionOffset(preparedTransactionOffset);
+  msgExt->set_prepared_transaction_offset(preparedTransactionOffset);
 
   // 15 BODY
   int uncompress_failed = false;
@@ -160,12 +160,12 @@ MessageExtPtr MessageDecoder::decode(ByteBuffer& byteBuffer, bool readBody, bool
       if (deCompressBody && (sysFlag & MessageSysFlag::COMPRESSED_FLAG) == MessageSysFlag::COMPRESSED_FLAG) {
         std::string origin_body;
         if (UtilAll::inflate(body, origin_body)) {
-          msgExt->setBody(std::move(origin_body));
+          msgExt->set_body(std::move(origin_body));
         } else {
           uncompress_failed = true;
         }
       } else {
-        msgExt->setBody(std::string(body.array(), body.size()));
+        msgExt->set_body(std::string(body.array(), body.size()));
       }
     } else {
       // skip body
@@ -177,7 +177,7 @@ MessageExtPtr MessageDecoder::decode(ByteBuffer& byteBuffer, bool readBody, bool
   int8_t topicLen = byteBuffer.get();
   ByteArray topic(topicLen);
   byteBuffer.get(topic);
-  msgExt->setTopic(topic.array(), topic.size());
+  msgExt->set_topic(topic.array(), topic.size());
 
   // 17 properties
   int16_t propertiesLen = byteBuffer.getShort();
@@ -190,11 +190,11 @@ MessageExtPtr MessageDecoder::decode(ByteBuffer& byteBuffer, bool readBody, bool
   }
 
   // 18 msg ID
-  std::string msgId = createMessageId(msgExt->getStoreHost(), (int64_t)msgExt->getCommitLogOffset());
-  msgExt->MessageExtImpl::setMsgId(msgId);
+  std::string msgId = createMessageId(msgExt->store_host(), (int64_t)msgExt->commit_log_offset());
+  msgExt->MessageExtImpl::set_msg_id(msgId);
 
   if (uncompress_failed) {
-    LOG_WARN_NEW("can not uncompress message, id:{}", msgExt->getMsgId());
+    LOG_WARN_NEW("can not uncompress message, id:{}", msgExt->msg_id());
   }
 
   return msgExt;
@@ -254,9 +254,9 @@ std::map<std::string, std::string> MessageDecoder::string2messageProperties(cons
 }
 
 std::string MessageDecoder::encodeMessage(Message& message) {
-  const auto& body = message.getBody();
+  const auto& body = message.body();
   uint32_t bodyLen = body.size();
-  std::string properties = MessageDecoder::messageProperties2String(message.getProperties());
+  std::string properties = MessageDecoder::messageProperties2String(message.properties());
   uint16_t propertiesLength = (int16_t)properties.size();
   uint32_t storeSize = 4                        // 1 TOTALSIZE
                        + 4                      // 2 MAGICCODE
@@ -283,7 +283,7 @@ std::string MessageDecoder::encodeMessage(Message& message) {
   encodeMsg.append((char*)&bodyCrc_net, sizeof(uint32_t));
 
   // 4 FLAG
-  uint32_t flag = message.getFlag();
+  uint32_t flag = message.flag();
   uint32_t flag_net = ByteOrderUtil::NorminalBigEndian(flag);
   encodeMsg.append((char*)&flag_net, sizeof(uint32_t));
 
diff --git a/src/message/MessageExtImpl.cpp b/src/message/MessageExtImpl.cpp
index 94b38c4..f43ac35 100644
--- a/src/message/MessageExtImpl.cpp
+++ b/src/message/MessageExtImpl.cpp
@@ -66,123 +66,123 @@ TopicFilterType MessageExtImpl::parseTopicFilterType(int32_t sysFlag) {
   return SINGLE_TAG;
 }
 
-int32_t MessageExtImpl::getStoreSize() const {
+int32_t MessageExtImpl::store_size() const {
   return store_size_;
 }
 
-void MessageExtImpl::setStoreSize(int32_t storeSize) {
+void MessageExtImpl::set_store_size(int32_t storeSize) {
   store_size_ = storeSize;
 }
 
-int32_t MessageExtImpl::getBodyCRC() const {
+int32_t MessageExtImpl::body_crc() const {
   return body_crc_;
 }
 
-void MessageExtImpl::setBodyCRC(int32_t bodyCRC) {
+void MessageExtImpl::set_body_crc(int32_t bodyCRC) {
   body_crc_ = bodyCRC;
 }
 
-int32_t MessageExtImpl::getQueueId() const {
+int32_t MessageExtImpl::queue_id() const {
   return queue_id_;
 }
 
-void MessageExtImpl::setQueueId(int32_t queueId) {
+void MessageExtImpl::set_queue_id(int32_t queueId) {
   queue_id_ = queueId;
 }
 
-int64_t MessageExtImpl::getQueueOffset() const {
+int64_t MessageExtImpl::queue_offset() const {
   return queue_offset_;
 }
 
-void MessageExtImpl::setQueueOffset(int64_t queueOffset) {
+void MessageExtImpl::set_queue_offset(int64_t queueOffset) {
   queue_offset_ = queueOffset;
 }
 
-int64_t MessageExtImpl::getCommitLogOffset() const {
+int64_t MessageExtImpl::commit_log_offset() const {
   return commit_log_offset_;
 }
 
-void MessageExtImpl::setCommitLogOffset(int64_t physicOffset) {
+void MessageExtImpl::set_commit_log_offset(int64_t physicOffset) {
   commit_log_offset_ = physicOffset;
 }
 
-int32_t MessageExtImpl::getSysFlag() const {
+int32_t MessageExtImpl::sys_flag() const {
   return sys_flag_;
 }
 
-void MessageExtImpl::setSysFlag(int32_t sysFlag) {
+void MessageExtImpl::set_sys_flag(int32_t sysFlag) {
   sys_flag_ = sysFlag;
 }
 
-int64_t MessageExtImpl::getBornTimestamp() const {
+int64_t MessageExtImpl::born_timestamp() const {
   return born_timestamp_;
 }
 
-void MessageExtImpl::setBornTimestamp(int64_t bornTimestamp) {
+void MessageExtImpl::set_born_timestamp(int64_t bornTimestamp) {
   born_timestamp_ = bornTimestamp;
 }
 
-const struct sockaddr* MessageExtImpl::getBornHost() const {
+const struct sockaddr* MessageExtImpl::born_host() const {
   return born_host_;
 }
 
-std::string MessageExtImpl::getBornHostString() const {
+std::string MessageExtImpl::born_host_string() const {
   return socketAddress2String(born_host_);
 }
 
-void MessageExtImpl::setBornHost(const struct sockaddr* bornHost) {
+void MessageExtImpl::set_born_host(const struct sockaddr* bornHost) {
   born_host_ = copySocketAddress(born_host_, bornHost);
 }
 
-int64_t MessageExtImpl::getStoreTimestamp() const {
+int64_t MessageExtImpl::store_timestamp() const {
   return store_timestamp_;
 }
 
-void MessageExtImpl::setStoreTimestamp(int64_t storeTimestamp) {
+void MessageExtImpl::set_store_timestamp(int64_t storeTimestamp) {
   store_timestamp_ = storeTimestamp;
 }
 
-const struct sockaddr* MessageExtImpl::getStoreHost() const {
+const struct sockaddr* MessageExtImpl::store_host() const {
   return store_host_;
 }
 
-std::string MessageExtImpl::getStoreHostString() const {
+std::string MessageExtImpl::store_host_string() const {
   return socketAddress2String(store_host_);
 }
 
-void MessageExtImpl::setStoreHost(const struct sockaddr* storeHost) {
+void MessageExtImpl::set_store_host(const struct sockaddr* storeHost) {
   store_host_ = copySocketAddress(store_host_, storeHost);
 }
 
-const std::string& MessageExtImpl::getMsgId() const {
+const std::string& MessageExtImpl::msg_id() const {
   return msg_id_;
 }
 
-void MessageExtImpl::setMsgId(const std::string& msgId) {
+void MessageExtImpl::set_msg_id(const std::string& msgId) {
   msg_id_ = msgId;
 }
 
-int32_t MessageExtImpl::getReconsumeTimes() const {
+int32_t MessageExtImpl::reconsume_times() const {
   return reconsume_times_;
 }
 
-void MessageExtImpl::setReconsumeTimes(int32_t reconsumeTimes) {
+void MessageExtImpl::set_reconsume_times(int32_t reconsumeTimes) {
   reconsume_times_ = reconsumeTimes;
 }
 
-int64_t MessageExtImpl::getPreparedTransactionOffset() const {
+int64_t MessageExtImpl::prepared_transaction_offset() const {
   return prepared_transaction_offset_;
 }
 
-void MessageExtImpl::setPreparedTransactionOffset(int64_t preparedTransactionOffset) {
+void MessageExtImpl::set_prepared_transaction_offset(int64_t preparedTransactionOffset) {
   prepared_transaction_offset_ = preparedTransactionOffset;
 }
 
 std::string MessageExtImpl::toString() const {
   std::stringstream ss;
   ss << "MessageExt [queueId=" << queue_id_ << ", storeSize=" << store_size_ << ", queueOffset=" << queue_offset_
-     << ", sysFlag=" << sys_flag_ << ", bornTimestamp=" << born_timestamp_ << ", bornHost=" << getBornHostString()
-     << ", storeTimestamp=" << store_timestamp_ << ", storeHost=" << getStoreHostString() << ", msgId=" << getMsgId()
+     << ", sysFlag=" << sys_flag_ << ", bornTimestamp=" << born_timestamp_ << ", bornHost=" << born_host_string()
+     << ", storeTimestamp=" << store_timestamp_ << ", storeHost=" << store_host_string() << ", msgId=" << msg_id()
      << ", commitLogOffset=" << commit_log_offset_ << ", bodyCRC=" << body_crc_
      << ", reconsumeTimes=" << reconsume_times_ << ", preparedTransactionOffset=" << prepared_transaction_offset_
      << ", toString()=" << MessageImpl::toString() << "]";
@@ -193,22 +193,22 @@ std::string MessageExtImpl::toString() const {
 // MessageClientExtImpl
 // ============================
 
-const std::string& MessageClientExtImpl::getMsgId() const {
+const std::string& MessageClientExtImpl::msg_id() const {
   const auto& unique_id = MessageClientIDSetter::getUniqID(*this);
-  return unique_id.empty() ? getOffsetMsgId() : unique_id;
+  return unique_id.empty() ? offset_msg_id() : unique_id;
 }
 
-void MessageClientExtImpl::setMsgId(const std::string& msgId) {
+void MessageClientExtImpl::set_msg_id(const std::string& msgId) {
   // DO NOTHING
   // MessageClientIDSetter::setUniqID(*this);
 }
 
-const std::string& MessageClientExtImpl::getOffsetMsgId() const {
-  return MessageExtImpl::getMsgId();
+const std::string& MessageClientExtImpl::offset_msg_id() const {
+  return MessageExtImpl::msg_id();
 }
 
-void MessageClientExtImpl::setOffsetMsgId(const std::string& offsetMsgId) {
-  return MessageExtImpl::setMsgId(offsetMsgId);
+void MessageClientExtImpl::set_offset_msg_id(const std::string& offsetMsgId) {
+  return MessageExtImpl::set_msg_id(offsetMsgId);
 }
 
 }  // namespace rocketmq
diff --git a/src/message/MessageExtImpl.h b/src/message/MessageExtImpl.h
index af9e1ff..5d85cea 100644
--- a/src/message/MessageExtImpl.h
+++ b/src/message/MessageExtImpl.h
@@ -14,8 +14,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#ifndef ROCKETMQ_MESSAGE_MESSAGEEXT_H_
-#define ROCKETMQ_MESSAGE_MESSAGEEXT_H_
+#ifndef ROCKETMQ_MESSAGE_MESSAGEEXTIMPL_H_
+#define ROCKETMQ_MESSAGE_MESSAGEEXTIMPL_H_
 
 #include "MessageExt.h"
 #include "MessageImpl.h"
@@ -43,46 +43,46 @@ class MessageExtImpl : public MessageImpl,        // base
   static TopicFilterType parseTopicFilterType(int32_t sysFlag);
 
  public:  // MessageExt
-  int32_t getStoreSize() const override;
-  void setStoreSize(int32_t storeSize) override;
+  int32_t store_size() const override;
+  void set_store_size(int32_t storeSize) override;
 
-  int32_t getBodyCRC() const override;
-  void setBodyCRC(int32_t bodyCRC) override;
+  int32_t body_crc() const override;
+  void set_body_crc(int32_t bodyCRC) override;
 
-  int32_t getQueueId() const override;
-  void setQueueId(int32_t queueId) override;
+  int32_t queue_id() const override;
+  void set_queue_id(int32_t queueId) override;
 
-  int64_t getQueueOffset() const override;
-  void setQueueOffset(int64_t queueOffset) override;
+  int64_t queue_offset() const override;
+  void set_queue_offset(int64_t queueOffset) override;
 
-  int64_t getCommitLogOffset() const override;
-  void setCommitLogOffset(int64_t physicOffset) override;
+  int64_t commit_log_offset() const override;
+  void set_commit_log_offset(int64_t physicOffset) override;
 
-  int32_t getSysFlag() const override;
-  void setSysFlag(int32_t sysFlag) override;
+  int32_t sys_flag() const override;
+  void set_sys_flag(int32_t sysFlag) override;
 
-  int64_t getBornTimestamp() const override;
-  void setBornTimestamp(int64_t bornTimestamp) override;
+  int64_t born_timestamp() const override;
+  void set_born_timestamp(int64_t bornTimestamp) override;
 
-  const struct sockaddr* getBornHost() const override;
-  std::string getBornHostString() const override;
-  void setBornHost(const struct sockaddr* bornHost) override;
+  const struct sockaddr* born_host() const override;
+  std::string born_host_string() const override;
+  void set_born_host(const struct sockaddr* bornHost) override;
 
-  int64_t getStoreTimestamp() const override;
-  void setStoreTimestamp(int64_t storeTimestamp) override;
+  int64_t store_timestamp() const override;
+  void set_store_timestamp(int64_t storeTimestamp) override;
 
-  const struct sockaddr* getStoreHost() const override;
-  std::string getStoreHostString() const override;
-  void setStoreHost(const struct sockaddr* storeHost) override;
+  const struct sockaddr* store_host() const override;
+  std::string store_host_string() const override;
+  void set_store_host(const struct sockaddr* storeHost) override;
 
-  int32_t getReconsumeTimes() const override;
-  void setReconsumeTimes(int32_t reconsumeTimes) override;
+  int32_t reconsume_times() const override;
+  void set_reconsume_times(int32_t reconsumeTimes) override;
 
-  int64_t getPreparedTransactionOffset() const override;
-  void setPreparedTransactionOffset(int64_t preparedTransactionOffset) override;
+  int64_t prepared_transaction_offset() const override;
+  void set_prepared_transaction_offset(int64_t preparedTransactionOffset) override;
 
-  const std::string& getMsgId() const override;
-  void setMsgId(const std::string& msgId) override;
+  const std::string& msg_id() const override;
+  void set_msg_id(const std::string& msgId) override;
 
   std::string toString() const override;
 
@@ -104,14 +104,14 @@ class MessageExtImpl : public MessageImpl,        // base
 
 class MessageClientExtImpl : public MessageExtImpl {
  public:  // MessageExt
-  const std::string& getMsgId() const override;
-  void setMsgId(const std::string& msgId) override;
+  const std::string& msg_id() const override;
+  void set_msg_id(const std::string& msgId) override;
 
  public:
-  const std::string& getOffsetMsgId() const;
-  void setOffsetMsgId(const std::string& offsetMsgId);
+  const std::string& offset_msg_id() const;
+  void set_offset_msg_id(const std::string& offsetMsgId);
 };
 
 }  // namespace rocketmq
 
-#endif  // ROCKETMQ_MESSAGE_MESSAGEEXT_H_
+#endif  // ROCKETMQ_MESSAGE_MESSAGEEXTIMPL_H_
diff --git a/src/message/MessageImpl.cpp b/src/message/MessageImpl.cpp
index 1738952..d24f8ba 100644
--- a/src/message/MessageImpl.cpp
+++ b/src/message/MessageImpl.cpp
@@ -38,64 +38,48 @@ MessageImpl::MessageImpl(const std::string& topic,
                          bool waitStoreMsgOK)
     : topic_(topic), flag_(flag), body_(body) {
   if (tags.length() > 0) {
-    setTags(tags);
+    set_tags(tags);
   }
 
   if (keys.length() > 0) {
-    setKeys(keys);
+    set_keys(keys);
   }
 
-  setWaitStoreMsgOK(waitStoreMsgOK);
+  set_wait_store_msg_ok(waitStoreMsgOK);
 }
 
 MessageImpl::~MessageImpl() = default;
 
-const std::string& MessageImpl::getProperty(const std::string& name) const {
-  const auto& it = properties_.find(name);
-  if (it != properties_.end()) {
-    return it->second;
-  }
-  return null;
-}
-
-void MessageImpl::putProperty(const std::string& name, const std::string& value) {
-  properties_[name] = value;
-}
-
-void MessageImpl::clearProperty(const std::string& name) {
-  properties_.erase(name);
-}
-
-const std::string& MessageImpl::getTopic() const {
+const std::string& MessageImpl::topic() const {
   return topic_;
 }
 
-void MessageImpl::setTopic(const std::string& topic) {
+void MessageImpl::set_topic(const std::string& topic) {
   topic_ = topic;
 }
 
-void MessageImpl::setTopic(const char* body, int len) {
+void MessageImpl::set_topic(const char* topic, int len) {
   topic_.clear();
-  topic_.append(body, len);
+  topic_.append(topic, len);
 }
 
-const std::string& MessageImpl::getTags() const {
+const std::string& MessageImpl::tags() const {
   return getProperty(MQMessageConst::PROPERTY_TAGS);
 }
 
-void MessageImpl::setTags(const std::string& tags) {
+void MessageImpl::set_tags(const std::string& tags) {
   putProperty(MQMessageConst::PROPERTY_TAGS, tags);
 }
 
-const std::string& MessageImpl::getKeys() const {
+const std::string& MessageImpl::keys() const {
   return getProperty(MQMessageConst::PROPERTY_KEYS);
 }
 
-void MessageImpl::setKeys(const std::string& keys) {
+void MessageImpl::set_keys(const std::string& keys) {
   putProperty(MQMessageConst::PROPERTY_KEYS, keys);
 }
 
-void MessageImpl::setKeys(const std::vector<std::string>& keys) {
+void MessageImpl::set_keys(const std::vector<std::string>& keys) {
   if (keys.empty()) {
     return;
   }
@@ -108,10 +92,10 @@ void MessageImpl::setKeys(const std::vector<std::string>& keys) {
     strKeys += *it;
   }
 
-  setKeys(strKeys);
+  set_keys(strKeys);
 }
 
-int MessageImpl::getDelayTimeLevel() const {
+int MessageImpl::delay_time_level() const {
   std::string tmp = getProperty(MQMessageConst::PROPERTY_DELAY_TIME_LEVEL);
   if (!tmp.empty()) {
     return atoi(tmp.c_str());
@@ -119,62 +103,78 @@ int MessageImpl::getDelayTimeLevel() const {
   return 0;
 }
 
-void MessageImpl::setDelayTimeLevel(int level) {
+void MessageImpl::set_delay_time_level(int level) {
   putProperty(MQMessageConst::PROPERTY_DELAY_TIME_LEVEL, UtilAll::to_string(level));
 }
 
-bool MessageImpl::isWaitStoreMsgOK() const {
+bool MessageImpl::wait_store_msg_ok() const {
   std::string tmp = getProperty(MQMessageConst::PROPERTY_WAIT_STORE_MSG_OK);
   return tmp.empty() || UtilAll::stob(tmp);
 }
 
-void MessageImpl::setWaitStoreMsgOK(bool waitStoreMsgOK) {
+void MessageImpl::set_wait_store_msg_ok(bool waitStoreMsgOK) {
   putProperty(MQMessageConst::PROPERTY_WAIT_STORE_MSG_OK, UtilAll::to_string(waitStoreMsgOK));
 }
 
-int32_t MessageImpl::getFlag() const {
+int32_t MessageImpl::flag() const {
   return flag_;
 }
 
-void MessageImpl::setFlag(int32_t flag) {
+void MessageImpl::set_flag(int32_t flag) {
   flag_ = flag;
 }
 
-const std::string& MessageImpl::getBody() const {
+const std::string& MessageImpl::body() const {
   return body_;
 }
 
-void MessageImpl::setBody(const std::string& body) {
+void MessageImpl::set_body(const std::string& body) {
   body_ = body;
 }
 
-void MessageImpl::setBody(std::string&& body) {
+void MessageImpl::set_body(std::string&& body) {
   body_ = std::move(body);
 }
 
-const std::string& MessageImpl::getTransactionId() const {
+const std::string& MessageImpl::transaction_id() const {
   return transaction_id_;
 }
 
-void MessageImpl::setTransactionId(const std::string& transactionId) {
+void MessageImpl::set_transaction_id(const std::string& transactionId) {
   transaction_id_ = transactionId;
 }
 
-const std::map<std::string, std::string>& MessageImpl::getProperties() const {
+const std::map<std::string, std::string>& MessageImpl::properties() const {
   return properties_;
 }
 
-void MessageImpl::setProperties(const std::map<std::string, std::string>& properties) {
+void MessageImpl::set_properties(const std::map<std::string, std::string>& properties) {
   properties_ = properties;
 }
 
-void MessageImpl::setProperties(std::map<std::string, std::string>&& properties) {
+void MessageImpl::set_properties(std::map<std::string, std::string>&& properties) {
   properties_ = std::move(properties);
 }
 
+const std::string& MessageImpl::getProperty(const std::string& name) const {
+  const auto& it = properties_.find(name);
+  if (it != properties_.end()) {
+    return it->second;
+  }
+  return null;
+}
+
+void MessageImpl::putProperty(const std::string& name, const std::string& value) {
+  properties_[name] = value;
+}
+
+void MessageImpl::clearProperty(const std::string& name) {
+  properties_.erase(name);
+}
+
 std::string MessageImpl::toString() const {
   std::stringstream ss;
-  ss << "Message [topic=" << topic_ << ", flag=" << flag_ << ", tag=" << getTags() << ", transactionId='"
+  ss << "Message [topic=" << topic_ << ", flag=" << flag_ << ", tag=" << tags() << ", transactionId='"
      << transaction_id_ + "']";
   return ss.str();
 }
diff --git a/src/message/MessageImpl.h b/src/message/MessageImpl.h
index de83e5e..efe4977 100644
--- a/src/message/MessageImpl.h
+++ b/src/message/MessageImpl.h
@@ -44,36 +44,36 @@ class MessageImpl : public noncopyable,     // base
   void putProperty(const std::string& name, const std::string& value) override;
   void clearProperty(const std::string& name) override;
 
-  const std::string& getTopic() const override;
-  void setTopic(const std::string& topic) override;
-  void setTopic(const char* body, int len) override;
+  const std::string& topic() const override;
+  void set_topic(const std::string& topic) override;
+  void set_topic(const char* body, int len) override;
 
-  const std::string& getTags() const override;
-  void setTags(const std::string& tags) override;
+  const std::string& tags() const override;
+  void set_tags(const std::string& tags) override;
 
-  const std::string& getKeys() const override;
-  void setKeys(const std::string& keys) override;
-  void setKeys(const std::vector<std::string>& keys) override;
+  const std::string& keys() const override;
+  void set_keys(const std::string& keys) override;
+  void set_keys(const std::vector<std::string>& keys) override;
 
-  int getDelayTimeLevel() const override;
-  void setDelayTimeLevel(int level) override;
+  int delay_time_level() const override;
+  void set_delay_time_level(int level) override;
 
-  bool isWaitStoreMsgOK() const override;
-  void setWaitStoreMsgOK(bool waitStoreMsgOK) override;
+  bool wait_store_msg_ok() const override;
+  void set_wait_store_msg_ok(bool waitStoreMsgOK) override;
 
-  int32_t getFlag() const override;
-  void setFlag(int32_t flag) override;
+  int32_t flag() const override;
+  void set_flag(int32_t flag) override;
 
-  const std::string& getBody() const override;
-  void setBody(const std::string& body) override;
-  void setBody(std::string&& body) override;
+  const std::string& body() const override;
+  void set_body(const std::string& body) override;
+  void set_body(std::string&& body) override;
 
-  const std::string& getTransactionId() const override;
-  void setTransactionId(const std::string& transactionId) override;
+  const std::string& transaction_id() const override;
+  void set_transaction_id(const std::string& transactionId) override;
 
-  const std::map<std::string, std::string>& getProperties() const override;
-  void setProperties(const std::map<std::string, std::string>& properties) override;
-  void setProperties(std::map<std::string, std::string>&& properties) override;
+  const std::map<std::string, std::string>& properties() const override;
+  void set_properties(const std::map<std::string, std::string>& properties) override;
+  void set_properties(std::map<std::string, std::string>&& properties) override;
 
   std::string toString() const override;
 
diff --git a/src/producer/DefaultMQProducer.cpp b/src/producer/DefaultMQProducer.cpp
index f4c61f4..89fd57a 100644
--- a/src/producer/DefaultMQProducer.cpp
+++ b/src/producer/DefaultMQProducer.cpp
@@ -33,9 +33,9 @@ DefaultMQProducer::DefaultMQProducer(const std::string& groupname,
     : DefaultMQProducerConfigProxy(producerConfig), producer_impl_(nullptr) {
   // set default group name
   if (groupname.empty()) {
-    setGroupName(DEFAULT_PRODUCER_GROUP);
+    set_group_name(DEFAULT_PRODUCER_GROUP);
   } else {
-    setGroupName(groupname);
+    set_group_name(groupname);
   }
 
   // create DefaultMQProducerImpl
@@ -69,7 +69,7 @@ SendResult DefaultMQProducer::send(MQMessage& msg, const MQMessageQueue& mq, lon
 }
 
 void DefaultMQProducer::send(MQMessage& msg, SendCallback* sendCallback) noexcept {
-  producer_impl_->send(msg, sendCallback, getSendMsgTimeout());
+  producer_impl_->send(msg, sendCallback, send_msg_timeout());
 }
 
 void DefaultMQProducer::send(MQMessage& msg, SendCallback* sendCallback, long timeout) noexcept {
@@ -174,11 +174,11 @@ void DefaultMQProducer::request(MQMessage& msg,
   producer_impl_->request(msg, selector, arg, requestCallback, timeout);
 }
 
-bool DefaultMQProducer::isSendLatencyFaultEnable() const {
+bool DefaultMQProducer::send_latency_fault_enable() const {
   return dynamic_cast<DefaultMQProducerImpl*>(producer_impl_.get())->isSendLatencyFaultEnable();
 }
 
-void DefaultMQProducer::setSendLatencyFaultEnable(bool sendLatencyFaultEnable) {
+void DefaultMQProducer::set_send_latency_fault_enable(bool sendLatencyFaultEnable) {
   dynamic_cast<DefaultMQProducerImpl*>(producer_impl_.get())->setSendLatencyFaultEnable(sendLatencyFaultEnable);
 }
 
diff --git a/src/producer/DefaultMQProducerConfigImpl.hpp b/src/producer/DefaultMQProducerConfigImpl.hpp
index 11d8223..5b1f78d 100644
--- a/src/producer/DefaultMQProducerConfigImpl.hpp
+++ b/src/producer/DefaultMQProducerConfigImpl.hpp
@@ -40,32 +40,32 @@ class DefaultMQProducerConfigImpl : virtual public DefaultMQProducerConfig, publ
 
   virtual ~DefaultMQProducerConfigImpl() = default;
 
-  int getMaxMessageSize() const override { return max_message_size_; }
-  void setMaxMessageSize(int maxMessageSize) override { max_message_size_ = maxMessageSize; }
+  int max_message_size() const override { return max_message_size_; }
+  void set_max_message_size(int maxMessageSize) override { max_message_size_ = maxMessageSize; }
 
-  int getCompressMsgBodyOverHowmuch() const override { return compress_msg_body_over_howmuch_; }
-  void setCompressMsgBodyOverHowmuch(int compressMsgBodyOverHowmuch) override {
+  int compress_msg_body_over_howmuch() const override { return compress_msg_body_over_howmuch_; }
+  void set_compress_msg_body_over_howmuch(int compressMsgBodyOverHowmuch) override {
     compress_msg_body_over_howmuch_ = compressMsgBodyOverHowmuch;
   }
 
-  int getCompressLevel() const override { return compress_level_; }
-  void setCompressLevel(int compressLevel) override {
+  int compress_level() const override { return compress_level_; }
+  void set_compress_level(int compressLevel) override {
     if ((compressLevel >= 0 && compressLevel <= 9) || compressLevel == -1) {
       compress_level_ = compressLevel;
     }
   }
 
-  int getSendMsgTimeout() const override { return send_msg_timeout_; }
-  void setSendMsgTimeout(int sendMsgTimeout) override { send_msg_timeout_ = sendMsgTimeout; }
+  int send_msg_timeout() const override { return send_msg_timeout_; }
+  void set_send_msg_timeout(int sendMsgTimeout) override { send_msg_timeout_ = sendMsgTimeout; }
 
-  int getRetryTimes() const override { return retry_times_; }
-  void setRetryTimes(int times) override { retry_times_ = std::min(std::max(0, times), 15); }
+  int retry_times() const override { return retry_times_; }
+  void set_retry_times(int times) override { retry_times_ = std::min(std::max(0, times), 15); }
 
-  int getRetryTimesForAsync() const override { return retry_times_for_async_; }
-  void setRetryTimesForAsync(int times) override { retry_times_for_async_ = std::min(std::max(0, times), 15); }
+  int retry_times_for_async() const override { return retry_times_for_async_; }
+  void set_retry_times_for_async(int times) override { retry_times_for_async_ = std::min(std::max(0, times), 15); }
 
-  bool isRetryAnotherBrokerWhenNotStoreOK() const override { return retry_another_broker_when_not_store_ok_; }
-  void setRetryAnotherBrokerWhenNotStoreOK(bool retryAnotherBrokerWhenNotStoreOK) override {
+  bool retry_another_broker_when_not_store_ok() const override { return retry_another_broker_when_not_store_ok_; }
+  void set_retry_another_broker_when_not_store_ok(bool retryAnotherBrokerWhenNotStoreOK) override {
     retry_another_broker_when_not_store_ok_ = retryAnotherBrokerWhenNotStoreOK;
   }
 
diff --git a/src/producer/DefaultMQProducerImpl.cpp b/src/producer/DefaultMQProducerImpl.cpp
index 3c6b9e3..b33d052 100644
--- a/src/producer/DefaultMQProducerImpl.cpp
+++ b/src/producer/DefaultMQProducerImpl.cpp
@@ -106,7 +106,7 @@ void DefaultMQProducerImpl::start() {
 
   switch (service_state_) {
     case CREATE_JUST: {
-      LOG_INFO_NEW("DefaultMQProducerImpl: {} start", client_config_->getGroupName());
+      LOG_INFO_NEW("DefaultMQProducerImpl: {} start", client_config_->group_name());
 
       service_state_ = START_FAILED;
 
@@ -115,17 +115,17 @@ void DefaultMQProducerImpl::start() {
       MQClientImpl::start();
 
       bool registerOK = client_instance_->registerProducer(
-          dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->getGroupName(), this);
+          dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->group_name(), this);
       if (!registerOK) {
         service_state_ = CREATE_JUST;
-        THROW_MQEXCEPTION(MQClientException, "The producer group[" + client_config_->getGroupName() +
+        THROW_MQEXCEPTION(MQClientException, "The producer group[" + client_config_->group_name() +
                                                  "] has been created before, specify another name please.",
                           -1);
       }
 
       client_instance_->start();
 
-      LOG_INFO_NEW("the producer [{}] start OK.", client_config_->getGroupName());
+      LOG_INFO_NEW("the producer [{}] start OK.", client_config_->group_name());
       service_state_ = RUNNING;
       break;
     }
@@ -145,7 +145,7 @@ void DefaultMQProducerImpl::shutdown() {
   switch (service_state_) {
     case RUNNING: {
       LOG_INFO("DefaultMQProducerImpl shutdown");
-      client_instance_->unregisterProducer(client_config_->getGroupName());
+      client_instance_->unregisterProducer(client_config_->group_name());
       client_instance_->shutdown();
 
       service_state_ = SHUTDOWN_ALREADY;
@@ -160,7 +160,7 @@ void DefaultMQProducerImpl::shutdown() {
 }
 
 SendResult DefaultMQProducerImpl::send(MQMessage& msg) {
-  return send(msg, dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->getSendMsgTimeout());
+  return send(msg, dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->send_msg_timeout());
 }
 
 SendResult DefaultMQProducerImpl::send(MQMessage& msg, long timeout) {
@@ -174,13 +174,13 @@ SendResult DefaultMQProducerImpl::send(MQMessage& msg, long timeout) {
 }
 
 SendResult DefaultMQProducerImpl::send(MQMessage& msg, const MQMessageQueue& mq) {
-  return send(msg, mq, dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->getSendMsgTimeout());
+  return send(msg, mq, dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->send_msg_timeout());
 }
 
 SendResult DefaultMQProducerImpl::send(MQMessage& msg, const MQMessageQueue& mq, long timeout) {
-  Validators::checkMessage(msg, dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->getMaxMessageSize());
+  Validators::checkMessage(msg, dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->max_message_size());
 
-  if (msg.getTopic() != mq.topic()) {
+  if (msg.topic() != mq.topic()) {
     THROW_MQEXCEPTION(MQClientException, "message's topic not equal mq's topic", -1);
   }
 
@@ -194,7 +194,7 @@ SendResult DefaultMQProducerImpl::send(MQMessage& msg, const MQMessageQueue& mq,
 }
 
 void DefaultMQProducerImpl::send(MQMessage& msg, SendCallback* sendCallback) noexcept {
-  return send(msg, sendCallback, dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->getSendMsgTimeout());
+  return send(msg, sendCallback, dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->send_msg_timeout());
 }
 
 void DefaultMQProducerImpl::send(MQMessage& msg, SendCallback* sendCallback, long timeout) noexcept {
@@ -213,7 +213,7 @@ void DefaultMQProducerImpl::send(MQMessage& msg, SendCallback* sendCallback, lon
 }
 
 void DefaultMQProducerImpl::send(MQMessage& msg, const MQMessageQueue& mq, SendCallback* sendCallback) noexcept {
-  return send(msg, mq, sendCallback, dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->getSendMsgTimeout());
+  return send(msg, mq, sendCallback, dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->send_msg_timeout());
 }
 
 void DefaultMQProducerImpl::send(MQMessage& msg,
@@ -221,9 +221,9 @@ void DefaultMQProducerImpl::send(MQMessage& msg,
                                  SendCallback* sendCallback,
                                  long timeout) noexcept {
   try {
-    Validators::checkMessage(msg, dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->getMaxMessageSize());
+    Validators::checkMessage(msg, dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->max_message_size());
 
-    if (msg.getTopic() != mq.topic()) {
+    if (msg.topic() != mq.topic()) {
       THROW_MQEXCEPTION(MQClientException, "message's topic not equal mq's topic", -1);
     }
 
@@ -248,7 +248,7 @@ void DefaultMQProducerImpl::send(MQMessage& msg,
 void DefaultMQProducerImpl::sendOneway(MQMessage& msg) {
   try {
     sendDefaultImpl(msg.getMessageImpl(), ONEWAY, nullptr,
-                    dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->getSendMsgTimeout());
+                    dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->send_msg_timeout());
   } catch (MQBrokerException& e) {
     std::string info = std::string("unknown exception, ") + e.what();
     THROW_MQEXCEPTION(MQClientException, info, e.GetError());
@@ -256,15 +256,15 @@ void DefaultMQProducerImpl::sendOneway(MQMessage& msg) {
 }
 
 void DefaultMQProducerImpl::sendOneway(MQMessage& msg, const MQMessageQueue& mq) {
-  Validators::checkMessage(msg, dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->getMaxMessageSize());
+  Validators::checkMessage(msg, dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->max_message_size());
 
-  if (msg.getTopic() != mq.topic()) {
+  if (msg.topic() != mq.topic()) {
     THROW_MQEXCEPTION(MQClientException, "message's topic not equal mq's topic", -1);
   }
 
   try {
     sendKernelImpl(msg.getMessageImpl(), mq, ONEWAY, nullptr, nullptr,
-                   dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->getSendMsgTimeout());
+                   dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->send_msg_timeout());
   } catch (MQBrokerException& e) {
     std::string info = std::string("unknown exception, ") + e.what();
     THROW_MQEXCEPTION(MQClientException, info, e.GetError());
@@ -272,7 +272,7 @@ void DefaultMQProducerImpl::sendOneway(MQMessage& msg, const MQMessageQueue& mq)
 }
 
 SendResult DefaultMQProducerImpl::send(MQMessage& msg, MessageQueueSelector* selector, void* arg) {
-  return send(msg, selector, arg, dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->getSendMsgTimeout());
+  return send(msg, selector, arg, dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->send_msg_timeout());
 }
 
 SendResult DefaultMQProducerImpl::send(MQMessage& msg, MessageQueueSelector* selector, void* arg, long timeout) {
@@ -290,7 +290,7 @@ void DefaultMQProducerImpl::send(MQMessage& msg,
                                  void* arg,
                                  SendCallback* sendCallback) noexcept {
   return send(msg, selector, arg, sendCallback,
-              dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->getSendMsgTimeout());
+              dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->send_msg_timeout());
 }
 
 void DefaultMQProducerImpl::send(MQMessage& msg,
@@ -320,7 +320,7 @@ void DefaultMQProducerImpl::send(MQMessage& msg,
 void DefaultMQProducerImpl::sendOneway(MQMessage& msg, MessageQueueSelector* selector, void* arg) {
   try {
     sendSelectImpl(msg.getMessageImpl(), selector, arg, ONEWAY, nullptr,
-                   dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->getSendMsgTimeout());
+                   dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->send_msg_timeout());
   } catch (MQBrokerException& e) {
     std::string info = std::string("unknown exception, ") + e.what();
     THROW_MQEXCEPTION(MQClientException, info, e.GetError());
@@ -330,7 +330,7 @@ void DefaultMQProducerImpl::sendOneway(MQMessage& msg, MessageQueueSelector* sel
 TransactionSendResult DefaultMQProducerImpl::sendMessageInTransaction(MQMessage& msg, void* arg) {
   try {
     std::unique_ptr<TransactionSendResult> sendResult(sendMessageInTransactionImpl(
-        msg.getMessageImpl(), arg, dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->getSendMsgTimeout()));
+        msg.getMessageImpl(), arg, dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->send_msg_timeout()));
     return *sendResult;
   } catch (MQException& e) {
     LOG_ERROR_NEW("sendMessageInTransaction failed, exception:{}", e.what());
@@ -367,10 +367,10 @@ MessagePtr DefaultMQProducerImpl::batch(std::vector<MQMessage>& msgs) {
     auto messageBatch = MessageBatch::generateFromList(msgs);
     for (auto& message : messageBatch->messages()) {
       Validators::checkMessage(message,
-                               dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->getMaxMessageSize());
+                               dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->max_message_size());
       MessageClientIDSetter::setUniqID(const_cast<MQMessage&>(message));
     }
-    messageBatch->setBody(messageBatch->encode());
+    messageBatch->set_body(messageBatch->encode());
     return messageBatch;
   } catch (std::exception& e) {
     THROW_MQEXCEPTION(MQClientException, "Failed to initiate the MessageBatch", -1);
@@ -395,11 +395,11 @@ MQMessage DefaultMQProducerImpl::request(MQMessage& msg, long timeout) {
     responseMessage = requestResponseFuture->waitResponseMessage(timeout - cost);
     if (responseMessage == nullptr) {
       if (requestResponseFuture->send_request_ok()) {
-        std::string info = "send request message to <" + msg.getTopic() + "> OK, but wait reply message timeout, " +
+        std::string info = "send request message to <" + msg.topic() + "> OK, but wait reply message timeout, " +
                            UtilAll::to_string(timeout) + " ms.";
         THROW_MQEXCEPTION(RequestTimeoutException, info, ClientErrorCode::REQUEST_TIMEOUT_EXCEPTION);
       } else {
-        std::string info = "send request message to <" + msg.getTopic() + "> fail";
+        std::string info = "send request message to <" + msg.topic() + "> fail";
         THROW_MQEXCEPTION2(MQClientException, info, -1, requestResponseFuture->cause());
       }
     }
@@ -448,11 +448,11 @@ MQMessage DefaultMQProducerImpl::request(MQMessage& msg, const MQMessageQueue& m
     responseMessage = requestResponseFuture->waitResponseMessage(timeout - cost);
     if (responseMessage == nullptr) {
       if (requestResponseFuture->send_request_ok()) {
-        std::string info = "send request message to <" + msg.getTopic() + "> OK, but wait reply message timeout, " +
+        std::string info = "send request message to <" + msg.topic() + "> OK, but wait reply message timeout, " +
                            UtilAll::to_string(timeout) + " ms.";
         THROW_MQEXCEPTION(RequestTimeoutException, info, ClientErrorCode::REQUEST_TIMEOUT_EXCEPTION);
       } else {
-        std::string info = "send request message to <" + msg.getTopic() + "> fail";
+        std::string info = "send request message to <" + msg.topic() + "> fail";
         THROW_MQEXCEPTION2(MQClientException, info, -1, requestResponseFuture->cause());
       }
     }
@@ -504,11 +504,11 @@ MQMessage DefaultMQProducerImpl::request(MQMessage& msg, MessageQueueSelector* s
     responseMessage = requestResponseFuture->waitResponseMessage(timeout - cost);
     if (responseMessage == nullptr) {
       if (requestResponseFuture->send_request_ok()) {
-        std::string info = "send request message to <" + msg.getTopic() + "> OK, but wait reply message timeout, " +
+        std::string info = "send request message to <" + msg.topic() + "> OK, but wait reply message timeout, " +
                            UtilAll::to_string(timeout) + " ms.";
         THROW_MQEXCEPTION(RequestTimeoutException, info, ClientErrorCode::REQUEST_TIMEOUT_EXCEPTION);
       } else {
-        std::string info = "send request message to <" + msg.getTopic() + "> fail";
+        std::string info = "send request message to <" + msg.topic() + "> fail";
         THROW_MQEXCEPTION2(MQClientException, info, -1, requestResponseFuture->cause());
       }
     }
@@ -550,14 +550,14 @@ void DefaultMQProducerImpl::prepareSendRequest(Message& msg, long timeout) {
   MessageAccessor::putProperty(msg, MQMessageConst::PROPERTY_MESSAGE_REPLY_TO_CLIENT, requestClientId);
   MessageAccessor::putProperty(msg, MQMessageConst::PROPERTY_MESSAGE_TTL, UtilAll::to_string(timeout));
 
-  auto hasRouteData = client_instance_->getTopicRouteData(msg.getTopic()) != nullptr;
+  auto hasRouteData = client_instance_->getTopicRouteData(msg.topic()) != nullptr;
   if (!hasRouteData) {
     auto beginTimestamp = UtilAll::currentTimeMillis();
-    client_instance_->tryToFindTopicPublishInfo(msg.getTopic());
+    client_instance_->tryToFindTopicPublishInfo(msg.topic());
     client_instance_->sendHeartbeatToAllBrokerWithLock();
     auto cost = UtilAll::currentTimeMillis() - beginTimestamp;
     if (cost > 500) {
-      LOG_WARN_NEW("prepare send request for <{}> cost {} ms", msg.getTopic(), cost);
+      LOG_WARN_NEW("prepare send request for <{}> cost {} ms", msg.topic(), cost);
     }
   }
 }
@@ -566,17 +566,17 @@ SendResult* DefaultMQProducerImpl::sendDefaultImpl(MessagePtr msg,
                                                    CommunicationMode communicationMode,
                                                    SendCallback* sendCallback,
                                                    long timeout) {
-  Validators::checkMessage(*msg, dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->getMaxMessageSize());
+  Validators::checkMessage(*msg, dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->max_message_size());
 
   uint64_t beginTimestampFirst = UtilAll::currentTimeMillis();
   uint64_t beginTimestampPrev = beginTimestampFirst;
   uint64_t endTimestamp = beginTimestampFirst;
-  auto topicPublishInfo = client_instance_->tryToFindTopicPublishInfo(msg->getTopic());
+  auto topicPublishInfo = client_instance_->tryToFindTopicPublishInfo(msg->topic());
   if (topicPublishInfo != nullptr && topicPublishInfo->ok()) {
     bool callTimeout = false;
     std::unique_ptr<SendResult> sendResult;
     int timesTotal = communicationMode == CommunicationMode::SYNC
-                         ? 1 + dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->getRetryTimes()
+                         ? 1 + dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->retry_times()
                          : 1;
     int times = 0;
     std::string lastBrokerName;
@@ -607,8 +607,9 @@ SendResult* DefaultMQProducerImpl::sendDefaultImpl(MessagePtr msg,
           case ONEWAY:
             return nullptr;
           case SYNC:
-            if (sendResult->getSendStatus() != SEND_OK) {
-              if (dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->isRetryAnotherBrokerWhenNotStoreOK()) {
+            if (sendResult->send_status() != SEND_OK) {
+              if (dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())
+                      ->retry_another_broker_when_not_store_ok()) {
                 continue;
               }
             }
@@ -633,11 +634,11 @@ SendResult* DefaultMQProducerImpl::sendDefaultImpl(MessagePtr msg,
 
     std::string info = "Send [" + UtilAll::to_string(times) + "] times, still failed, cost [" +
                        UtilAll::to_string(UtilAll::currentTimeMillis() - beginTimestampFirst) + "]ms, Topic: " +
-                       msg->getTopic();
+                       msg->topic();
     THROW_MQEXCEPTION(MQClientException, info, -1);
   }
 
-  THROW_MQEXCEPTION(MQClientException, "No route info of this topic: " + msg->getTopic(), -1);
+  THROW_MQEXCEPTION(MQClientException, "No route info of this topic: " + msg->topic(), -1);
 }
 
 const MQMessageQueue& DefaultMQProducerImpl::selectOneMessageQueue(const TopicPublishInfo* tpInfo,
@@ -685,15 +686,15 @@ SendResult* DefaultMQProducerImpl::sendKernelImpl(MessagePtr msg,
       // TOOD: send message hook
 
       std::unique_ptr<SendMessageRequestHeader> requestHeader(new SendMessageRequestHeader());
-      requestHeader->producerGroup = client_config_->getGroupName();
-      requestHeader->topic = msg->getTopic();
+      requestHeader->producerGroup = client_config_->group_name();
+      requestHeader->topic = msg->topic();
       requestHeader->defaultTopic = AUTO_CREATE_TOPIC_KEY_TOPIC;
       requestHeader->defaultTopicQueueNums = 4;
       requestHeader->queueId = mq.queue_id();
       requestHeader->sysFlag = sysFlag;
       requestHeader->bornTimestamp = UtilAll::currentTimeMillis();
-      requestHeader->flag = msg->getFlag();
-      requestHeader->properties = MessageDecoder::messageProperties2String(msg->getProperties());
+      requestHeader->flag = msg->flag();
+      requestHeader->properties = MessageDecoder::messageProperties2String(msg->properties());
       requestHeader->reconsumeTimes = 0;
       requestHeader->unitMode = false;
       requestHeader->batch = msg->isBatch();
@@ -722,7 +723,7 @@ SendResult* DefaultMQProducerImpl::sendKernelImpl(MessagePtr msg,
           sendResult = client_instance_->getMQClientAPIImpl()->sendMessage(
               brokerAddr, mq.broker_name(), msg, std::move(requestHeader), timeout, communicationMode, sendCallback,
               topicPublishInfo, client_instance_,
-              dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->getRetryTimesForAsync(),
+              dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->retry_times_for_async(),
               shared_from_this());
         } break;
         case ONEWAY:
@@ -760,12 +761,12 @@ bool DefaultMQProducerImpl::tryToCompressMessage(Message& msg) {
     return true;
   }
 
-  const auto& body = msg.getBody();
-  if (body.size() >= dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->getCompressMsgBodyOverHowmuch()) {
+  const auto& body = msg.body();
+  if (body.size() >= dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->compress_msg_body_over_howmuch()) {
     std::string out_body;
     if (UtilAll::deflate(body, out_body,
-                         dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->getCompressLevel())) {
-      msg.setBody(std::move(out_body));
+                         dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->compress_level())) {
+      msg.set_body(std::move(out_body));
       msg.putProperty(MQMessageConst::PROPERTY_ALREADY_COMPRESSED_FLAG, "true");
       return true;
     }
@@ -781,9 +782,9 @@ SendResult* DefaultMQProducerImpl::sendSelectImpl(MessagePtr msg,
                                                   SendCallback* sendCallback,
                                                   long timeout) {
   auto beginStartTime = UtilAll::currentTimeMillis();
-  Validators::checkMessage(*msg, dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->getMaxMessageSize());
+  Validators::checkMessage(*msg, dynamic_cast<DefaultMQProducerConfig*>(client_config_.get())->max_message_size());
 
-  TopicPublishInfoPtr topicPublishInfo = client_instance_->tryToFindTopicPublishInfo(msg->getTopic());
+  TopicPublishInfoPtr topicPublishInfo = client_instance_->tryToFindTopicPublishInfo(msg->topic());
   if (topicPublishInfo != nullptr && topicPublishInfo->ok()) {
     MQMessageQueue mq = selector->select(topicPublishInfo->getMessageQueueList(), MQMessage(msg), arg);
 
@@ -795,7 +796,7 @@ SendResult* DefaultMQProducerImpl::sendSelectImpl(MessagePtr msg,
     return sendKernelImpl(msg, mq, communicationMode, sendCallback, nullptr, timeout - costTime);
   }
 
-  std::string info = std::string("No route info for this topic, ") + msg->getTopic();
+  std::string info = std::string("No route info for this topic, ") + msg->topic();
   THROW_MQEXCEPTION(MQClientException, info, -1);
 }
 
@@ -826,7 +827,7 @@ TransactionSendResult* DefaultMQProducerImpl::sendMessageInTransactionImpl(Messa
 
   std::unique_ptr<SendResult> sendResult;
   MessageAccessor::putProperty(*msg, MQMessageConst::PROPERTY_TRANSACTION_PREPARED, "true");
-  MessageAccessor::putProperty(*msg, MQMessageConst::PROPERTY_PRODUCER_GROUP, client_config_->getGroupName());
+  MessageAccessor::putProperty(*msg, MQMessageConst::PROPERTY_PRODUCER_GROUP, client_config_->group_name());
   try {
     sendResult.reset(sendDefaultImpl(msg, SYNC, nullptr, timeout));
   } catch (MQException& e) {
@@ -835,15 +836,15 @@ TransactionSendResult* DefaultMQProducerImpl::sendMessageInTransactionImpl(Messa
 
   LocalTransactionState localTransactionState = LocalTransactionState::UNKNOWN;
   std::exception_ptr localException;
-  switch (sendResult->getSendStatus()) {
+  switch (sendResult->send_status()) {
     case SendStatus::SEND_OK:
       try {
-        if (!sendResult->getTransactionId().empty()) {
-          msg->putProperty("__transactionId__", sendResult->getTransactionId());
+        if (!sendResult->transaction_id().empty()) {
+          msg->putProperty("__transactionId__", sendResult->transaction_id());
         }
         const auto& transactionId = msg->getProperty(MQMessageConst::PROPERTY_UNIQ_CLIENT_MESSAGE_ID_KEYIDX);
         if (!transactionId.empty()) {
-          msg->setTransactionId(transactionId);
+          msg->set_transaction_id(transactionId);
         }
         localTransactionState = transactionListener->executeLocalTransaction(MQMessage(msg), arg);
         if (localTransactionState != LocalTransactionState::COMMIT_MESSAGE) {
@@ -873,18 +874,18 @@ TransactionSendResult* DefaultMQProducerImpl::sendMessageInTransactionImpl(Messa
 
   // FIXME: setTransactionId will cause OOM?
   TransactionSendResult* transactionSendResult = new TransactionSendResult(*sendResult.get());
-  transactionSendResult->setTransactionId(msg->getTransactionId());
-  transactionSendResult->setLocalTransactionState(localTransactionState);
+  transactionSendResult->set_transaction_id(msg->transaction_id());
+  transactionSendResult->set_local_transaction_state(localTransactionState);
   return transactionSendResult;
 }
 
 void DefaultMQProducerImpl::endTransaction(SendResult& sendResult,
                                            LocalTransactionState localTransactionState,
                                            std::exception_ptr& localException) {
-  const auto& msg_id = !sendResult.getOffsetMsgId().empty() ? sendResult.getOffsetMsgId() : sendResult.getMsgId();
+  const auto& msg_id = !sendResult.offset_msg_id().empty() ? sendResult.offset_msg_id() : sendResult.msg_id();
   auto id = MessageDecoder::decodeMessageId(msg_id);
-  const auto& transactionId = sendResult.getTransactionId();
-  std::string brokerAddr = client_instance_->findBrokerAddressInPublish(sendResult.getMessageQueue().broker_name());
+  const auto& transactionId = sendResult.transaction_id();
+  std::string brokerAddr = client_instance_->findBrokerAddressInPublish(sendResult.message_queue().broker_name());
   EndTransactionRequestHeader* requestHeader = new EndTransactionRequestHeader();
   requestHeader->transactionId = transactionId;
   requestHeader->commitLogOffset = id.getOffset();
@@ -902,9 +903,9 @@ void DefaultMQProducerImpl::endTransaction(SendResult& sendResult,
       break;
   }
 
-  requestHeader->producerGroup = client_config_->getGroupName();
-  requestHeader->tranStateTableOffset = sendResult.getQueueOffset();
-  requestHeader->msgId = sendResult.getMsgId();
+  requestHeader->producerGroup = client_config_->group_name();
+  requestHeader->tranStateTableOffset = sendResult.queue_offset();
+  requestHeader->msgId = sendResult.msg_id();
 
   std::string remark =
       localException ? ("executeLocalTransactionBranch exception: " + UtilAll::to_string(localException)) : null;
@@ -936,7 +937,7 @@ void DefaultMQProducerImpl::checkTransactionStateImpl(const std::string& addr,
   auto* transactionCheckListener = getCheckListener();
   if (nullptr == transactionCheckListener) {
     LOG_WARN_NEW("CheckTransactionState, pick transactionCheckListener by group[{}] failed",
-                 client_config_->getGroupName());
+                 client_config_->group_name());
     return;
   }
 
@@ -951,13 +952,13 @@ void DefaultMQProducerImpl::checkTransactionStateImpl(const std::string& addr,
 
   EndTransactionRequestHeader* endHeader = new EndTransactionRequestHeader();
   endHeader->commitLogOffset = commitLogOffset;
-  endHeader->producerGroup = client_config_->getGroupName();
+  endHeader->producerGroup = client_config_->group_name();
   endHeader->tranStateTableOffset = tranStateTableOffset;
   endHeader->fromTransactionCheck = true;
 
   std::string uniqueKey = message->getProperty(MQMessageConst::PROPERTY_UNIQ_CLIENT_MESSAGE_ID_KEYIDX);
   if (uniqueKey.empty()) {
-    uniqueKey = message->getMsgId();
+    uniqueKey = message->msg_id();
   }
 
   endHeader->msgId = uniqueKey;
diff --git a/test/src/common/ClientRPCHookTest.cpp b/test/src/common/ClientRPCHookTest.cpp
index 02ce843..e454f42 100644
--- a/test/src/common/ClientRPCHookTest.cpp
+++ b/test/src/common/ClientRPCHookTest.cpp
@@ -35,9 +35,9 @@ using rocketmq::SessionCredentials;
 
 TEST(ClientRPCHookTest, BeforeRequest) {
   SessionCredentials sessionCredentials;
-  sessionCredentials.setAccessKey("accessKey");
-  sessionCredentials.setSecretKey("secretKey");
-  sessionCredentials.setAuthChannel("onsChannel");
+  sessionCredentials.set_access_key("accessKey");
+  sessionCredentials.set_secret_key("secretKey");
+  sessionCredentials.set_auth_channel("onsChannel");
 
   ClientRPCHook clientRPCHook(sessionCredentials);
 
diff --git a/test/src/extern/CMessageExtTest.cpp b/test/src/extern/CMessageExtTest.cpp
index 442ae57..02218ca 100644
--- a/test/src/extern/CMessageExtTest.cpp
+++ b/test/src/extern/CMessageExtTest.cpp
@@ -32,50 +32,50 @@ TEST(CMessageExtTest, CheckProperties) {
   MQMessageExt* mqMessageExt = new MQMessageExt();
   CMessageExt* messageExt = (CMessageExt*)mqMessageExt;
 
-  mqMessageExt->setTopic("testTopic");
-  EXPECT_EQ(GetMessageTopic(messageExt), mqMessageExt->getTopic());
+  mqMessageExt->set_topic("testTopic");
+  EXPECT_EQ(GetMessageTopic(messageExt), mqMessageExt->topic());
 
-  mqMessageExt->setTags("testTags");
-  EXPECT_EQ(GetMessageTags(messageExt), mqMessageExt->getTags());
+  mqMessageExt->set_tags("testTags");
+  EXPECT_EQ(GetMessageTags(messageExt), mqMessageExt->tags());
 
-  mqMessageExt->setKeys("testKeys");
-  EXPECT_EQ(GetMessageKeys(messageExt), mqMessageExt->getKeys());
+  mqMessageExt->set_keys("testKeys");
+  EXPECT_EQ(GetMessageKeys(messageExt), mqMessageExt->keys());
 
-  mqMessageExt->setBody("testBody");
-  EXPECT_EQ(GetMessageBody(messageExt), mqMessageExt->getBody());
+  mqMessageExt->set_body("testBody");
+  EXPECT_EQ(GetMessageBody(messageExt), mqMessageExt->body());
 
   mqMessageExt->putProperty("testProperty", "testValue");
   EXPECT_EQ(GetMessageProperty(messageExt, "testProperty"), mqMessageExt->getProperty("testProperty"));
 
-  mqMessageExt->setMsgId("msgId123456");
-  EXPECT_EQ(GetMessageId(messageExt), mqMessageExt->getMsgId());
+  mqMessageExt->set_msg_id("msgId123456");
+  EXPECT_EQ(GetMessageId(messageExt), mqMessageExt->msg_id());
 
-  mqMessageExt->setDelayTimeLevel(1);
-  EXPECT_EQ(GetMessageDelayTimeLevel(messageExt), mqMessageExt->getDelayTimeLevel());
+  mqMessageExt->set_delay_time_level(1);
+  EXPECT_EQ(GetMessageDelayTimeLevel(messageExt), mqMessageExt->delay_time_level());
 
-  mqMessageExt->setQueueId(4);
-  EXPECT_EQ(GetMessageQueueId(messageExt), mqMessageExt->getQueueId());
+  mqMessageExt->set_queue_id(4);
+  EXPECT_EQ(GetMessageQueueId(messageExt), mqMessageExt->queue_id());
 
-  mqMessageExt->setReconsumeTimes(1234567);
-  EXPECT_EQ(GetMessageReconsumeTimes(messageExt), mqMessageExt->getReconsumeTimes());
+  mqMessageExt->set_reconsume_times(1234567);
+  EXPECT_EQ(GetMessageReconsumeTimes(messageExt), mqMessageExt->reconsume_times());
 
-  mqMessageExt->setStoreSize(127);
-  EXPECT_EQ(GetMessageStoreSize(messageExt), mqMessageExt->getStoreSize());
+  mqMessageExt->set_store_size(127);
+  EXPECT_EQ(GetMessageStoreSize(messageExt), mqMessageExt->store_size());
 
-  mqMessageExt->setBornTimestamp(9876543);
-  EXPECT_EQ(GetMessageBornTimestamp(messageExt), mqMessageExt->getBornTimestamp());
+  mqMessageExt->set_born_timestamp(9876543);
+  EXPECT_EQ(GetMessageBornTimestamp(messageExt), mqMessageExt->born_timestamp());
 
-  mqMessageExt->setStoreTimestamp(123123);
-  EXPECT_EQ(GetMessageStoreTimestamp(messageExt), mqMessageExt->getStoreTimestamp());
+  mqMessageExt->set_store_timestamp(123123);
+  EXPECT_EQ(GetMessageStoreTimestamp(messageExt), mqMessageExt->store_timestamp());
 
-  mqMessageExt->setQueueOffset(1024);
-  EXPECT_EQ(GetMessageQueueOffset(messageExt), mqMessageExt->getQueueOffset());
+  mqMessageExt->set_queue_offset(1024);
+  EXPECT_EQ(GetMessageQueueOffset(messageExt), mqMessageExt->queue_offset());
 
-  mqMessageExt->setCommitLogOffset(2048);
-  EXPECT_EQ(GetMessageCommitLogOffset(messageExt), mqMessageExt->getCommitLogOffset());
+  mqMessageExt->set_commit_log_offset(2048);
+  EXPECT_EQ(GetMessageCommitLogOffset(messageExt), mqMessageExt->commit_log_offset());
 
-  mqMessageExt->setPreparedTransactionOffset(4096);
-  EXPECT_EQ(GetMessagePreparedTransactionOffset(messageExt), mqMessageExt->getPreparedTransactionOffset());
+  mqMessageExt->set_prepared_transaction_offset(4096);
+  EXPECT_EQ(GetMessagePreparedTransactionOffset(messageExt), mqMessageExt->prepared_transaction_offset());
 
   delete mqMessageExt;
 }
diff --git a/test/src/extern/CMessageTest.cpp b/test/src/extern/CMessageTest.cpp
index 446c3d8..4956c39 100644
--- a/test/src/extern/CMessageTest.cpp
+++ b/test/src/extern/CMessageTest.cpp
@@ -30,34 +30,34 @@ using rocketmq::MQMessage;
 TEST(CMessagesTest, CheckProperties) {
   CMessage* message = CreateMessage(NULL);
   MQMessage* mqMessage = (MQMessage*)message;
-  EXPECT_EQ(mqMessage->getTopic(), "");
+  EXPECT_EQ(mqMessage->topic(), "");
 
   SetMessageTopic(message, "testTopic");
-  EXPECT_EQ(mqMessage->getTopic(), "testTopic");
+  EXPECT_EQ(mqMessage->topic(), "testTopic");
 
   SetMessageTags(message, "testTags");
-  EXPECT_EQ(mqMessage->getTags(), "testTags");
+  EXPECT_EQ(mqMessage->tags(), "testTags");
 
   SetMessageKeys(message, "testKeys");
-  EXPECT_EQ(mqMessage->getKeys(), "testKeys");
+  EXPECT_EQ(mqMessage->keys(), "testKeys");
 
   SetMessageBody(message, "testBody");
-  EXPECT_EQ(mqMessage->getBody(), "testBody");
+  EXPECT_EQ(mqMessage->body(), "testBody");
 
   SetByteMessageBody(message, "testBody", 5);
-  EXPECT_EQ(mqMessage->getBody(), "testB");
+  EXPECT_EQ(mqMessage->body(), "testB");
 
   SetMessageProperty(message, "testProperty", "testValue");
   EXPECT_EQ(mqMessage->getProperty("testProperty"), "testValue");
 
   SetDelayTimeLevel(message, 1);
-  EXPECT_EQ(mqMessage->getDelayTimeLevel(), 1);
+  EXPECT_EQ(mqMessage->delay_time_level(), 1);
 
   EXPECT_EQ(DestroyMessage(message), OK);
 
   message = CreateMessage("testTopic");
   mqMessage = (MQMessage*)message;
-  EXPECT_EQ(mqMessage->getTopic(), "testTopic");
+  EXPECT_EQ(mqMessage->topic(), "testTopic");
 
   EXPECT_EQ(DestroyMessage(message), OK);
 }
diff --git a/test/src/extern/CProducerTest.cpp b/test/src/extern/CProducerTest.cpp
index 17ed7c6..bb09884 100644
--- a/test/src/extern/CProducerTest.cpp
+++ b/test/src/extern/CProducerTest.cpp
@@ -174,25 +174,25 @@ TEST(CProducerTest, Info) {
   CProducer* cProducer = CreateProducer("groupTest");
   DefaultMQProducer* defaultMQProducer = (DefaultMQProducer*)cProducer;
   EXPECT_TRUE(cProducer != NULL);
-  EXPECT_EQ(defaultMQProducer->getGroupName(), "groupTest");
+  EXPECT_EQ(defaultMQProducer->group_name(), "groupTest");
 
   EXPECT_EQ(SetProducerNameServerAddress(cProducer, "127.0.0.1:9876"), OK);
-  EXPECT_EQ(defaultMQProducer->getNamesrvAddr(), "127.0.0.1:9876");
+  EXPECT_EQ(defaultMQProducer->namesrv_addr(), "127.0.0.1:9876");
 
   EXPECT_EQ(SetProducerGroupName(cProducer, "testGroup"), OK);
-  EXPECT_EQ(defaultMQProducer->getGroupName(), "testGroup");
+  EXPECT_EQ(defaultMQProducer->group_name(), "testGroup");
 
   EXPECT_EQ(SetProducerInstanceName(cProducer, "instance"), OK);
-  EXPECT_EQ(defaultMQProducer->getInstanceName(), "instance");
+  EXPECT_EQ(defaultMQProducer->instance_name(), "instance");
 
   EXPECT_EQ(SetProducerSendMsgTimeout(cProducer, 1), OK);
-  EXPECT_EQ(defaultMQProducer->getSendMsgTimeout(), 1);
+  EXPECT_EQ(defaultMQProducer->send_msg_timeout(), 1);
 
   EXPECT_EQ(SetProducerMaxMessageSize(cProducer, 2), OK);
-  EXPECT_EQ(defaultMQProducer->getMaxMessageSize(), 2);
+  EXPECT_EQ(defaultMQProducer->max_message_size(), 2);
 
   EXPECT_EQ(SetProducerCompressLevel(cProducer, 1), OK);
-  EXPECT_EQ(defaultMQProducer->getCompressLevel(), 1);
+  EXPECT_EQ(defaultMQProducer->compress_level(), 1);
 
   EXPECT_EQ(SetProducerSessionCredentials(NULL, NULL, NULL, NULL), NULL_POINTER);
   EXPECT_EQ(SetProducerSessionCredentials(cProducer, "accessKey", "secretKey", "channel"), OK);
diff --git a/test/src/extern/CPullConsumerTest.cpp b/test/src/extern/CPullConsumerTest.cpp
index df32364..51b79dc 100644
--- a/test/src/extern/CPullConsumerTest.cpp
+++ b/test/src/extern/CPullConsumerTest.cpp
@@ -147,10 +147,10 @@ TEST(CPullConsumerTest, Init) {
   EXPECT_FALSE(pullConsumer == NULL);
 
   EXPECT_EQ(SetPullConsumerGroupID(pullConsumer, "groupId"), OK);
-  EXPECT_EQ(GetPullConsumerGroupID(pullConsumer), defaultMQPullConsumer->getGroupName().c_str());
+  EXPECT_EQ(GetPullConsumerGroupID(pullConsumer), defaultMQPullConsumer->group_name().c_str());
 
   EXPECT_EQ(SetPullConsumerNameServerAddress(pullConsumer, "127.0.0.1:10091"), OK);
-  EXPECT_EQ(defaultMQPullConsumer->getNamesrvAddr(), "127.0.0.1:10091");
+  EXPECT_EQ(defaultMQPullConsumer->namesrv_addr(), "127.0.0.1:10091");
 
   EXPECT_EQ(SetPullConsumerSessionCredentials(pullConsumer, "accessKey", "secretKey", "channel"), OK);
   // SessionCredentials sessionCredentials = defaultMQPullConsumer->getSessionCredentials();
@@ -168,10 +168,10 @@ TEST(CPullConsumerTest, CheckNull) {
   EXPECT_FALSE(pullConsumer == NULL);
 
   EXPECT_EQ(SetPullConsumerGroupID(pullConsumer, "groupId"), OK);
-  EXPECT_EQ(GetPullConsumerGroupID(pullConsumer), defaultMQPullConsumer->getGroupName().c_str());
+  EXPECT_EQ(GetPullConsumerGroupID(pullConsumer), defaultMQPullConsumer->group_name().c_str());
 
   EXPECT_EQ(SetPullConsumerNameServerAddress(pullConsumer, "127.0.0.1:10091"), OK);
-  EXPECT_EQ(defaultMQPullConsumer->getNamesrvAddr(), "127.0.0.1:10091");
+  EXPECT_EQ(defaultMQPullConsumer->namesrv_addr(), "127.0.0.1:10091");
 
   EXPECT_EQ(SetPullConsumerSessionCredentials(pullConsumer, "accessKey", "secretKey", "channel"), OK);
   // SessionCredentials sessionCredentials = defaultMQPullConsumer->getSessionCredentials();
diff --git a/test/src/extern/CPushConsumerTest.cpp b/test/src/extern/CPushConsumerTest.cpp
index e41d7f8..a599169 100644
--- a/test/src/extern/CPushConsumerTest.cpp
+++ b/test/src/extern/CPushConsumerTest.cpp
@@ -71,7 +71,7 @@ TEST(CPushComsumerTest, Info) {
   EXPECT_STREQ(GetPushConsumerGroupID(cPushConsumer), "testGroupTwo");
 
   EXPECT_EQ(SetPushConsumerNameServerAddress(cPushConsumer, "127.0.0.1:9876"), OK);
-  EXPECT_EQ(mqPushConsumer->getNamesrvAddr(), "127.0.0.1:9876");
+  EXPECT_EQ(mqPushConsumer->namesrv_addr(), "127.0.0.1:9876");
 
   EXPECT_EQ(Subscribe(cPushConsumer, "testTopic", "testSub"), OK);
 
@@ -86,20 +86,20 @@ TEST(CPushComsumerTest, Info) {
   EXPECT_EQ(UnregisterMessageCallback(cPushConsumer), OK);
 
   EXPECT_EQ(SetPushConsumerThreadCount(cPushConsumer, 10), OK);
-  EXPECT_EQ(mqPushConsumer->getConsumeThreadNum(), 10);
+  EXPECT_EQ(mqPushConsumer->consume_thread_nums(), 10);
 
   EXPECT_EQ(SetPushConsumerMessageBatchMaxSize(cPushConsumer, 1024), OK);
-  EXPECT_EQ(mqPushConsumer->getConsumeMessageBatchMaxSize(), 1024);
+  EXPECT_EQ(mqPushConsumer->consume_message_batch_max_size(), 1024);
 
   EXPECT_EQ(SetPushConsumerInstanceName(cPushConsumer, "instance"), OK);
-  EXPECT_EQ(mqPushConsumer->getInstanceName(), "instance");
+  EXPECT_EQ(mqPushConsumer->instance_name(), "instance");
 
   EXPECT_EQ(SetPushConsumerSessionCredentials(cPushConsumer, "accessKey", "secretKey", "channel"), OK);
   // SessionCredentials sessionCredentials = mqPushConsumer->getSessionCredentials();
   // EXPECT_EQ(sessionCredentials.getAccessKey(), "accessKey");
 
   EXPECT_EQ(SetPushConsumerMessageModel(cPushConsumer, BROADCASTING), OK);
-  EXPECT_EQ(mqPushConsumer->getMessageModel(), MessageModel::BROADCASTING);
+  EXPECT_EQ(mqPushConsumer->message_model(), MessageModel::BROADCASTING);
 
   DestroyPushConsumer(cPushConsumer);
 }
diff --git a/test/src/message/MQMessageExtTest.cpp b/test/src/message/MQMessageExtTest.cpp
index 400d900..b889aa8 100644
--- a/test/src/message/MQMessageExtTest.cpp
+++ b/test/src/message/MQMessageExtTest.cpp
@@ -36,64 +36,64 @@ using rocketmq::TopicFilterType;
 
 TEST(MessageExtTest, MessageClientExtImpl) {
   MessageClientExtImpl messageClientExt;
-  EXPECT_EQ(messageClientExt.getQueueOffset(), 0);
-  EXPECT_EQ(messageClientExt.getCommitLogOffset(), 0);
-  EXPECT_EQ(messageClientExt.getBornTimestamp(), 0);
-  EXPECT_EQ(messageClientExt.getStoreTimestamp(), 0);
-  EXPECT_EQ(messageClientExt.getPreparedTransactionOffset(), 0);
-  EXPECT_EQ(messageClientExt.getQueueId(), 0);
-  EXPECT_EQ(messageClientExt.getStoreSize(), 0);
-  EXPECT_EQ(messageClientExt.getReconsumeTimes(), 3);
-  EXPECT_EQ(messageClientExt.getBodyCRC(), 0);
-  EXPECT_EQ(messageClientExt.getMsgId(), "");
-  EXPECT_EQ(messageClientExt.getOffsetMsgId(), "");
+  EXPECT_EQ(messageClientExt.queue_offset(), 0);
+  EXPECT_EQ(messageClientExt.commit_log_offset(), 0);
+  EXPECT_EQ(messageClientExt.born_timestamp(), 0);
+  EXPECT_EQ(messageClientExt.store_timestamp(), 0);
+  EXPECT_EQ(messageClientExt.prepared_transaction_offset(), 0);
+  EXPECT_EQ(messageClientExt.queue_id(), 0);
+  EXPECT_EQ(messageClientExt.store_size(), 0);
+  EXPECT_EQ(messageClientExt.reconsume_times(), 3);
+  EXPECT_EQ(messageClientExt.body_crc(), 0);
+  EXPECT_EQ(messageClientExt.msg_id(), "");
+  EXPECT_EQ(messageClientExt.offset_msg_id(), "");
 
-  messageClientExt.setQueueOffset(1);
-  EXPECT_EQ(messageClientExt.getQueueOffset(), 1);
+  messageClientExt.set_queue_offset(1);
+  EXPECT_EQ(messageClientExt.queue_offset(), 1);
 
-  messageClientExt.setCommitLogOffset(1024);
-  EXPECT_EQ(messageClientExt.getCommitLogOffset(), 1024);
+  messageClientExt.set_commit_log_offset(1024);
+  EXPECT_EQ(messageClientExt.commit_log_offset(), 1024);
 
-  messageClientExt.setBornTimestamp(1024);
-  EXPECT_EQ(messageClientExt.getBornTimestamp(), 1024);
+  messageClientExt.set_born_timestamp(1024);
+  EXPECT_EQ(messageClientExt.born_timestamp(), 1024);
 
-  messageClientExt.setStoreTimestamp(2048);
-  EXPECT_EQ(messageClientExt.getStoreTimestamp(), 2048);
+  messageClientExt.set_store_timestamp(2048);
+  EXPECT_EQ(messageClientExt.store_timestamp(), 2048);
 
-  messageClientExt.setPreparedTransactionOffset(4096);
-  EXPECT_EQ(messageClientExt.getPreparedTransactionOffset(), 4096);
+  messageClientExt.set_prepared_transaction_offset(4096);
+  EXPECT_EQ(messageClientExt.prepared_transaction_offset(), 4096);
 
-  messageClientExt.setQueueId(2);
-  EXPECT_EQ(messageClientExt.getQueueId(), 2);
+  messageClientExt.set_queue_id(2);
+  EXPECT_EQ(messageClientExt.queue_id(), 2);
 
-  messageClientExt.setStoreSize(12);
-  EXPECT_EQ(messageClientExt.getStoreSize(), 12);
+  messageClientExt.set_store_size(12);
+  EXPECT_EQ(messageClientExt.store_size(), 12);
 
-  messageClientExt.setReconsumeTimes(48);
-  EXPECT_EQ(messageClientExt.getReconsumeTimes(), 48);
+  messageClientExt.set_reconsume_times(48);
+  EXPECT_EQ(messageClientExt.reconsume_times(), 48);
 
-  messageClientExt.setBodyCRC(32);
-  EXPECT_EQ(messageClientExt.getBodyCRC(), 32);
+  messageClientExt.set_body_crc(32);
+  EXPECT_EQ(messageClientExt.body_crc(), 32);
 
-  messageClientExt.setMsgId("MsgId");
-  EXPECT_EQ(messageClientExt.getMsgId(), "");
+  messageClientExt.set_msg_id("MsgId");
+  EXPECT_EQ(messageClientExt.msg_id(), "");
   messageClientExt.putProperty(MQMessageConst::PROPERTY_UNIQ_CLIENT_MESSAGE_ID_KEYIDX, "MsgId");
-  EXPECT_EQ(messageClientExt.getMsgId(), "MsgId");
+  EXPECT_EQ(messageClientExt.msg_id(), "MsgId");
 
-  messageClientExt.setOffsetMsgId("offsetMsgId");
-  EXPECT_EQ(messageClientExt.getOffsetMsgId(), "offsetMsgId");
+  messageClientExt.set_offset_msg_id("offsetMsgId");
+  EXPECT_EQ(messageClientExt.offset_msg_id(), "offsetMsgId");
 
-  messageClientExt.setBornTimestamp(1111);
-  EXPECT_EQ(messageClientExt.getBornTimestamp(), 1111);
+  messageClientExt.set_born_timestamp(1111);
+  EXPECT_EQ(messageClientExt.born_timestamp(), 1111);
 
-  messageClientExt.setStoreTimestamp(2222);
-  EXPECT_EQ(messageClientExt.getStoreTimestamp(), 2222);
+  messageClientExt.set_store_timestamp(2222);
+  EXPECT_EQ(messageClientExt.store_timestamp(), 2222);
 
-  messageClientExt.setBornHost(rocketmq::string2SocketAddress("127.0.0.1:10091"));
-  EXPECT_EQ(messageClientExt.getBornHostString(), "127.0.0.1:10091");
+  messageClientExt.set_born_host(rocketmq::string2SocketAddress("127.0.0.1:10091"));
+  EXPECT_EQ(messageClientExt.born_host_string(), "127.0.0.1:10091");
 
-  messageClientExt.setStoreHost(rocketmq::string2SocketAddress("127.0.0.2:10092"));
-  EXPECT_EQ(messageClientExt.getStoreHostString(), "127.0.0.2:10092");
+  messageClientExt.set_store_host(rocketmq::string2SocketAddress("127.0.0.2:10092"));
+  EXPECT_EQ(messageClientExt.store_host_string(), "127.0.0.2:10092");
 }
 
 TEST(MessageExtTest, MessageExt) {
@@ -101,18 +101,18 @@ TEST(MessageExtTest, MessageExt) {
   struct sockaddr* storeHost = rocketmq::copySocketAddress(nullptr, rocketmq::string2SocketAddress("127.0.0.2:10092"));
 
   MQMessageExt messageExt(2, 1024, bronHost, 2048, storeHost, "msgId");
-  EXPECT_EQ(messageExt.getQueueOffset(), 0);
-  EXPECT_EQ(messageExt.getCommitLogOffset(), 0);
-  EXPECT_EQ(messageExt.getBornTimestamp(), 1024);
-  EXPECT_EQ(messageExt.getStoreTimestamp(), 2048);
-  EXPECT_EQ(messageExt.getPreparedTransactionOffset(), 0);
-  EXPECT_EQ(messageExt.getQueueId(), 2);
-  EXPECT_EQ(messageExt.getStoreSize(), 0);
-  EXPECT_EQ(messageExt.getReconsumeTimes(), 3);
-  EXPECT_EQ(messageExt.getBodyCRC(), 0);
-  EXPECT_EQ(messageExt.getMsgId(), "msgId");
-  EXPECT_EQ(messageExt.getBornHostString(), "127.0.0.1:10091");
-  EXPECT_EQ(messageExt.getStoreHostString(), "127.0.0.2:10092");
+  EXPECT_EQ(messageExt.queue_offset(), 0);
+  EXPECT_EQ(messageExt.commit_log_offset(), 0);
+  EXPECT_EQ(messageExt.born_timestamp(), 1024);
+  EXPECT_EQ(messageExt.store_timestamp(), 2048);
+  EXPECT_EQ(messageExt.prepared_transaction_offset(), 0);
+  EXPECT_EQ(messageExt.queue_id(), 2);
+  EXPECT_EQ(messageExt.store_size(), 0);
+  EXPECT_EQ(messageExt.reconsume_times(), 3);
+  EXPECT_EQ(messageExt.body_crc(), 0);
+  EXPECT_EQ(messageExt.msg_id(), "msgId");
+  EXPECT_EQ(messageExt.born_host_string(), "127.0.0.1:10091");
+  EXPECT_EQ(messageExt.store_host_string(), "127.0.0.2:10092");
 
   free(bronHost);
   free(storeHost);
diff --git a/test/src/message/MQMessageTest.cpp b/test/src/message/MQMessageTest.cpp
index 515e384..b398726 100644
--- a/test/src/message/MQMessageTest.cpp
+++ b/test/src/message/MQMessageTest.cpp
@@ -31,97 +31,97 @@ using rocketmq::MQMessageConst;
 
 TEST(MessageTest, Init) {
   MQMessage messageOne;
-  EXPECT_EQ(messageOne.getTopic(), "");
-  EXPECT_EQ(messageOne.getBody(), "");
-  EXPECT_EQ(messageOne.getTags(), "");
-  EXPECT_EQ(messageOne.getFlag(), 0);
+  EXPECT_EQ(messageOne.topic(), "");
+  EXPECT_EQ(messageOne.body(), "");
+  EXPECT_EQ(messageOne.tags(), "");
+  EXPECT_EQ(messageOne.flag(), 0);
 
   MQMessage messageTwo("test", "testBody");
-  EXPECT_EQ(messageTwo.getTopic(), "test");
-  EXPECT_EQ(messageTwo.getBody(), "testBody");
-  EXPECT_EQ(messageTwo.getTags(), "");
-  EXPECT_EQ(messageTwo.getFlag(), 0);
+  EXPECT_EQ(messageTwo.topic(), "test");
+  EXPECT_EQ(messageTwo.body(), "testBody");
+  EXPECT_EQ(messageTwo.tags(), "");
+  EXPECT_EQ(messageTwo.flag(), 0);
 
   MQMessage messageThree("test", "tagTest", "testBody");
-  EXPECT_EQ(messageThree.getTopic(), "test");
-  EXPECT_EQ(messageThree.getBody(), "testBody");
-  EXPECT_EQ(messageThree.getTags(), "tagTest");
-  EXPECT_EQ(messageThree.getFlag(), 0);
+  EXPECT_EQ(messageThree.topic(), "test");
+  EXPECT_EQ(messageThree.body(), "testBody");
+  EXPECT_EQ(messageThree.tags(), "tagTest");
+  EXPECT_EQ(messageThree.flag(), 0);
 
   MQMessage messageFour("test", "tagTest", "testKey", "testBody");
-  EXPECT_EQ(messageFour.getTopic(), "test");
-  EXPECT_EQ(messageFour.getBody(), "testBody");
-  EXPECT_EQ(messageFour.getTags(), "tagTest");
-  EXPECT_EQ(messageFour.getKeys(), "testKey");
-  EXPECT_EQ(messageFour.getFlag(), 0);
+  EXPECT_EQ(messageFour.topic(), "test");
+  EXPECT_EQ(messageFour.body(), "testBody");
+  EXPECT_EQ(messageFour.tags(), "tagTest");
+  EXPECT_EQ(messageFour.keys(), "testKey");
+  EXPECT_EQ(messageFour.flag(), 0);
 
   MQMessage messageFive("test", "tagTest", "testKey", 1, "testBody", 2);
-  EXPECT_EQ(messageFive.getTopic(), "test");
-  EXPECT_EQ(messageFive.getBody(), "testBody");
-  EXPECT_EQ(messageFive.getTags(), "tagTest");
-  EXPECT_EQ(messageFive.getKeys(), "testKey");
-  EXPECT_EQ(messageFive.getFlag(), 1);
+  EXPECT_EQ(messageFive.topic(), "test");
+  EXPECT_EQ(messageFive.body(), "testBody");
+  EXPECT_EQ(messageFive.tags(), "tagTest");
+  EXPECT_EQ(messageFive.keys(), "testKey");
+  EXPECT_EQ(messageFive.flag(), 1);
 
   MQMessage messageSix(messageFive);
-  EXPECT_EQ(messageSix.getTopic(), "test");
-  EXPECT_EQ(messageSix.getBody(), "testBody");
-  EXPECT_EQ(messageSix.getTags(), "tagTest");
-  EXPECT_EQ(messageSix.getKeys(), "testKey");
-  EXPECT_EQ(messageSix.getFlag(), 1);
+  EXPECT_EQ(messageSix.topic(), "test");
+  EXPECT_EQ(messageSix.body(), "testBody");
+  EXPECT_EQ(messageSix.tags(), "tagTest");
+  EXPECT_EQ(messageSix.keys(), "testKey");
+  EXPECT_EQ(messageSix.flag(), 1);
 }
 
 TEST(MessageTest, GetterAndSetter) {
   MQMessage message;
 
-  EXPECT_EQ(message.getTopic(), "");  // default
-  message.setTopic("testTopic");
-  EXPECT_EQ(message.getTopic(), "testTopic");
+  EXPECT_EQ(message.topic(), "");  // default
+  message.set_topic("testTopic");
+  EXPECT_EQ(message.topic(), "testTopic");
 
   const char* topic = "testTopic";
-  message.setTopic(topic, 5);
-  EXPECT_EQ(message.getTopic(), "testT");
-
-  EXPECT_EQ(message.getBody(), "");  // default
-  message.setBody("testBody");
-  EXPECT_EQ(message.getBody(), "testBody");
-
-  EXPECT_EQ(message.getTags(), "");  // default
-  message.setTags("testTags");
-  EXPECT_EQ(message.getTags(), "testTags");
-
-  EXPECT_EQ(message.getKeys(), "");  // default
-  message.setKeys("testKeys");
-  EXPECT_EQ(message.getKeys(), "testKeys");
-
-  EXPECT_EQ(message.getFlag(), 0);  // default
-  message.setFlag(2);
-  EXPECT_EQ(message.getFlag(), 2);
-
-  EXPECT_EQ(message.isWaitStoreMsgOK(), true);  // default
-  message.setWaitStoreMsgOK(false);
-  EXPECT_EQ(message.isWaitStoreMsgOK(), false);
-  message.setWaitStoreMsgOK(true);
-  EXPECT_EQ(message.isWaitStoreMsgOK(), true);
-
-  EXPECT_EQ(message.getDelayTimeLevel(), 0);  // default
-  message.setDelayTimeLevel(1);
-  EXPECT_EQ(message.getDelayTimeLevel(), 1);
+  message.set_topic(topic, 5);
+  EXPECT_EQ(message.topic(), "testT");
+
+  EXPECT_EQ(message.body(), "");  // default
+  message.set_body("testBody");
+  EXPECT_EQ(message.body(), "testBody");
+
+  EXPECT_EQ(message.tags(), "");  // default
+  message.set_tags("testTags");
+  EXPECT_EQ(message.tags(), "testTags");
+
+  EXPECT_EQ(message.keys(), "");  // default
+  message.set_keys("testKeys");
+  EXPECT_EQ(message.keys(), "testKeys");
+
+  EXPECT_EQ(message.flag(), 0);  // default
+  message.set_flag(2);
+  EXPECT_EQ(message.flag(), 2);
+
+  EXPECT_EQ(message.wait_store_msg_ok(), true);  // default
+  message.set_wait_store_msg_ok(false);
+  EXPECT_EQ(message.wait_store_msg_ok(), false);
+  message.set_wait_store_msg_ok(true);
+  EXPECT_EQ(message.wait_store_msg_ok(), true);
+
+  EXPECT_EQ(message.delay_time_level(), 0);  // default
+  message.set_delay_time_level(1);
+  EXPECT_EQ(message.delay_time_level(), 1);
 }
 
 TEST(MessageTest, Properties) {
   MQMessage message;
 
-  EXPECT_EQ(message.getProperties().size(), 1);
+  EXPECT_EQ(message.properties().size(), 1);
   EXPECT_EQ(message.getProperty(MQMessageConst::PROPERTY_TRANSACTION_PREPARED), "");
 
   message.putProperty(MQMessageConst::PROPERTY_TRANSACTION_PREPARED, "true");
-  EXPECT_EQ(message.getProperties().size(), 2);
+  EXPECT_EQ(message.properties().size(), 2);
   EXPECT_EQ(message.getProperty(MQMessageConst::PROPERTY_TRANSACTION_PREPARED), "true");
 
   std::map<std::string, std::string> newProperties;
   newProperties[MQMessageConst::PROPERTY_TRANSACTION_PREPARED] = "false";
-  message.setProperties(newProperties);
-  EXPECT_EQ(message.getProperties().size(), 1);
+  message.set_properties(newProperties);
+  EXPECT_EQ(message.properties().size(), 1);
   EXPECT_EQ(message.getProperty(MQMessageConst::PROPERTY_TRANSACTION_PREPARED), "false");
 }
 
diff --git a/test/src/message/MessageDecoderTest.cpp b/test/src/message/MessageDecoderTest.cpp
index 8f15e02..d602d80 100644
--- a/test/src/message/MessageDecoderTest.cpp
+++ b/test/src/message/MessageDecoderTest.cpp
@@ -71,77 +71,77 @@ TEST(MessageDecoderTest, Decode) {
 
   // 1 TOTALSIZE  4=0+4
   byteBuffer->putInt(111);
-  msgExt.setStoreSize(111);
+  msgExt.set_store_size(111);
 
   // 2 MAGICCODE sizeof(int)  8=4+4
   byteBuffer->putInt(14);
 
   // 3 BODYCRC  12=8+4
   byteBuffer->putInt(24);
-  msgExt.setBodyCRC(24);
+  msgExt.set_body_crc(24);
 
   // 4 QUEUEID  16=12+4
   byteBuffer->putInt(4);
-  msgExt.setQueueId(4);
+  msgExt.set_queue_id(4);
 
   // 5 FLAG  20=16+4
   byteBuffer->putInt(4);
-  msgExt.setFlag(4);
+  msgExt.set_flag(4);
 
   // 6 QUEUEOFFSET  28=20+8
   byteBuffer->putLong(1024LL);
-  msgExt.setQueueOffset(1024LL);
+  msgExt.set_queue_offset(1024LL);
 
   // 7 PHYSICALOFFSET  36=28+8
   byteBuffer->putLong(2048LL);
-  msgExt.setCommitLogOffset(2048LL);
+  msgExt.set_commit_log_offset(2048LL);
 
   // 8 SYSFLAG  40=36+4
   byteBuffer->putInt(0);
-  msgExt.setSysFlag(0);
+  msgExt.set_sys_flag(0);
 
   // 9 BORNTIMESTAMP  48=40+8
   byteBuffer->putLong(4096LL);
-  msgExt.setBornTimestamp(4096LL);
+  msgExt.set_born_timestamp(4096LL);
 
   // 10 BORNHOST  56=48+4+4
   byteBuffer->putInt(ntohl(inet_addr("127.0.0.1")));
   byteBuffer->putInt(10091);
-  msgExt.setBornHost(rocketmq::string2SocketAddress("127.0.0.1:10091"));
+  msgExt.set_born_host(rocketmq::string2SocketAddress("127.0.0.1:10091"));
 
   // 11 STORETIMESTAMP  64=56+8
   byteBuffer->putLong(4096LL);
-  msgExt.setStoreTimestamp(4096LL);
+  msgExt.set_store_timestamp(4096LL);
 
   // 12 STOREHOST  72=64+4+4
   byteBuffer->putInt(ntohl(inet_addr("127.0.0.2")));
   byteBuffer->putInt(10092);
-  msgExt.setStoreHost(rocketmq::string2SocketAddress("127.0.0.2:10092"));
+  msgExt.set_store_host(rocketmq::string2SocketAddress("127.0.0.2:10092"));
 
   // 13 RECONSUMETIMES 76=72+4
   byteBuffer->putInt(18);
-  msgExt.setReconsumeTimes(18);
+  msgExt.set_reconsume_times(18);
 
   // 14 Prepared Transaction Offset  84=76+8
   byteBuffer->putLong(12LL);
-  msgExt.setPreparedTransactionOffset(12LL);
+  msgExt.set_prepared_transaction_offset(12LL);
 
   // 15 BODY  98=84+4+10
   std::string body("1234567890");
   byteBuffer->putInt(body.size());
   byteBuffer->put(*stoba(body));
-  msgExt.setBody(body);
+  msgExt.set_body(body);
 
   // 16 TOPIC  109=98+1+10
   std::string topic = "topic_1234";
   byteBuffer->put((int8_t)topic.size());
   byteBuffer->put(*stoba(topic));
-  msgExt.setTopic(topic);
+  msgExt.set_topic(topic);
 
   // 17 PROPERTIES 111=109+2
   byteBuffer->putShort(0);
 
-  msgExt.setMsgId(MessageDecoder::createMessageId(msgExt.getStoreHost(), (int64_t)msgExt.getCommitLogOffset()));
+  msgExt.set_msg_id(MessageDecoder::createMessageId(msgExt.store_host(), (int64_t)msgExt.commit_log_offset()));
 
   byteBuffer->flip();
   auto msgs = MessageDecoder::decodes(*byteBuffer);
@@ -153,7 +153,7 @@ TEST(MessageDecoderTest, Decode) {
 
   byteBuffer->rewind();
   msgs = MessageDecoder::decodes(*byteBuffer, false);
-  EXPECT_EQ(msgs[0]->getBody(), "");
+  EXPECT_EQ(msgs[0]->body(), "");
 
   //===============================================================
 
@@ -162,7 +162,7 @@ TEST(MessageDecoderTest, Decode) {
   // 8 SYSFLAG  40=36+4
   byteBuffer->position(36);
   byteBuffer->putInt(0 | MessageSysFlag::COMPRESSED_FLAG);
-  msgExt.setSysFlag(0 | MessageSysFlag::COMPRESSED_FLAG);
+  msgExt.set_sys_flag(0 | MessageSysFlag::COMPRESSED_FLAG);
 
   // 15 Body 84
   std::string compressedBody;
@@ -170,12 +170,12 @@ TEST(MessageDecoderTest, Decode) {
   byteBuffer->position(84);
   byteBuffer->putInt(compressedBody.size());
   byteBuffer->put(*stoba(compressedBody));
-  msgExt.setBody(compressedBody);
+  msgExt.set_body(compressedBody);
 
   // 16 TOPIC
   byteBuffer->put((int8_t)topic.size());
   byteBuffer->put(*stoba(topic));
-  msgExt.setTopic(topic);
+  msgExt.set_topic(topic);
 
   // 17 PROPERTIES
   std::map<std::string, std::string> properties;
@@ -184,13 +184,13 @@ TEST(MessageDecoderTest, Decode) {
   std::string props = MessageDecoder::messageProperties2String(properties);
   byteBuffer->putShort(props.size());
   byteBuffer->put(*stoba(props));
-  msgExt.setProperties(properties);
-  msgExt.setMsgId("123456");
+  msgExt.set_properties(properties);
+  msgExt.set_msg_id("123456");
 
   byteBuffer->flip();
 
   byteBuffer->putInt(byteBuffer->limit());
-  msgExt.setStoreSize(byteBuffer->limit());
+  msgExt.set_store_size(byteBuffer->limit());
 
   byteBuffer->rewind();
   msgs = MessageDecoder::decodes(*byteBuffer);


Mime
View raw message