rocketmq-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ding...@apache.org
Subject [rocketmq-client-cpp] branch master updated: feat(interface): remove boost in header file and examples (#235)
Date Fri, 07 Feb 2020 01:33:40 GMT
This is an automated email from the ASF dual-hosted git repository.

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


The following commit(s) were added to refs/heads/master by this push:
     new 7151454  feat(interface): remove boost in header file and examples (#235)
7151454 is described below

commit 7151454ace1e5cb3a762d5e52bcd2791a8d087c3
Author: dinglei <libya_003@163.com>
AuthorDate: Fri Feb 7 09:33:34 2020 +0800

    feat(interface): remove boost in header file and examples (#235)
    
    feat(interface): remove boost in header file and examples
---
 example/AsyncProducer.cpp                          |    2 +-
 example/AsyncPushConsumer.cpp                      |   33 +-
 example/BatchProducer.cpp                          |   34 +-
 example/CAsyncProducer.c                           |   34 +-
 example/COrderlyAsyncProducer.c                    |   34 +-
 example/OrderProducer.cpp                          |   35 +-
 example/OrderlyPushConsumer.cpp                    |   34 +-
 example/PullConsumeMessage.c                       |   36 +-
 example/PullConsumer.cpp                           |   31 +-
 example/PushConsumeMessage.c                       |   34 +-
 example/PushConsumer.cpp                           |   30 +-
 example/PushConsumerOrderly.c                      |   32 +-
 example/README.md                                  |    5 +-
 example/SendDelayMsg.cpp                           |   32 +-
 example/SyncProducer.cpp                           |   34 +-
 example/common.h                                   |   66 +-
 include/DefaultMQProducer.h                        |  106 +-
 include/DefaultMQPullConsumer.h                    |   70 +-
 include/DefaultMQPushConsumer.h                    |  152 ++-
 include/MQClient.h                                 |  240 +----
 include/TransactionMQProducer.h                    |   99 +-
 src/common/Arg_helper.cpp                          |    2 +-
 src/common/AsyncArg.h                              |   72 +-
 src/common/AsyncCallbackWrap.h                     |    2 +-
 src/common/ByteOrder.h                             |   32 +-
 src/common/ClientRPCHook.cpp                       |    2 +-
 src/common/ClientRPCHook.h                         |    2 +-
 src/common/CommunicationMode.h                     |    2 +-
 src/common/{MQClient.cpp => DefaultMQClient.cpp}   |   82 +-
 src/common/FilterAPI.h                             |    2 +-
 src/common/InputStream.cpp                         |   32 +-
 src/common/InputStream.h                           |   32 +-
 src/common/MemoryInputStream.cpp                   |   32 +-
 src/common/MemoryInputStream.h                     |   32 +-
 src/common/MemoryOutputStream.cpp                  |   32 +-
 src/common/MemoryOutputStream.h                    |   32 +-
 src/common/MessageSysFlag.cpp                      |    2 +-
 src/common/MessageSysFlag.h                        |    2 +-
 src/common/OutputStream.cpp                        |   32 +-
 src/common/OutputStream.h                          |   32 +-
 src/common/PermName.cpp                            |    2 +-
 src/common/PermName.h                              |    2 +-
 src/common/PullSysFlag.cpp                         |    2 +-
 src/common/PullSysFlag.h                           |    2 +-
 src/common/ServiceState.h                          |    2 +-
 src/common/SubscriptionGroupConfig.h               |    2 +-
 src/common/TopAddressing.cpp                       |    2 +-
 src/common/TopicConfig.cpp                         |    2 +-
 src/common/TopicConfig.h                           |    2 +-
 src/common/TopicFilterType.h                       |    2 +-
 src/common/UtilAll.cpp                             |    2 +-
 src/common/UtilAll.h                               |    2 +-
 src/common/Validators.cpp                          |    2 +-
 src/common/Validators.h                            |    2 +-
 src/common/VirtualEnvUtil.h                        |    2 +-
 src/common/big_endian.cpp                          |    2 +-
 src/common/big_endian.h                            |    2 +-
 src/common/dataBlock.cpp                           |   32 +-
 src/common/dataBlock.h                             |   32 +-
 src/common/sync_http_client.cpp                    |    6 +-
 src/common/sync_http_client.h                      |    2 +-
 src/common/url.cpp                                 |    2 +-
 src/common/url.h                                   |    2 +-
 src/consumer/ConsumeMsgService.h                   |    5 +-
 src/consumer/DefaultMQPullConsumer.cpp             |  449 ++-------
 ...lConsumer.cpp => DefaultMQPullConsumerImpl.cpp} |  116 +--
 .../consumer/DefaultMQPullConsumerImpl.h           |  296 +++---
 src/consumer/DefaultMQPushConsumer.cpp             | 1052 ++------------------
 ...hConsumer.cpp => DefaultMQPushConsumerImpl.cpp} |  134 +--
 .../consumer/DefaultMQPushConsumerImpl.h           |  330 +++---
 src/consumer/Rebalance.cpp                         |   10 +-
 src/extern/CMessageExt.cpp                         |    2 +-
 src/extern/CProducer.cpp                           |    1 +
 {include => src/include}/BatchMessage.h            |    0
 .../MQClient.h => src/include/DefaultMQClient.h    |  395 ++++----
 {include => src/include}/MQConsumer.h              |  136 +--
 {include => src/include}/MQProducer.h              |  122 +--
 {include => src/include}/QueryResult.h             |   84 +-
 {include => src/include}/SendMessageHook.h         |   96 +-
 src/log/Logging.h                                  |    2 +-
 src/message/BatchMessage.cpp                       |    2 +-
 src/producer/DefaultMQProducer.cpp                 |  728 +++-----------
 ...ultMQProducer.cpp => DefaultMQProducerImpl.cpp} |  121 +--
 .../producer/DefaultMQProducerImpl.h               |  236 ++---
 src/producer/TransactionMQProducer.cpp             |  337 +++----
 ...QProducer.cpp => TransactionMQProducerImpl.cpp} |   48 +-
 .../producer/TransactionMQProducerImpl.h           |   14 +-
 87 files changed, 2361 insertions(+), 4096 deletions(-)

diff --git a/example/AsyncProducer.cpp b/example/AsyncProducer.cpp
index 279cea3..5be900c 100644
--- a/example/AsyncProducer.cpp
+++ b/example/AsyncProducer.cpp
@@ -29,7 +29,7 @@
 
 using namespace rocketmq;
 
-boost::atomic<bool> g_quit;
+std::atomic<bool> g_quit;
 std::mutex g_mtx;
 std::condition_variable g_finished;
 SendCallback* g_callback = NULL;
diff --git a/example/AsyncPushConsumer.cpp b/example/AsyncPushConsumer.cpp
index 414f967..671c2e4 100644
--- a/example/AsyncPushConsumer.cpp
+++ b/example/AsyncPushConsumer.cpp
@@ -1,28 +1,25 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
-* contributor license agreements.  See the NOTICE file distributed with
-* this work for additional information regarding copyright ownership.
-* The ASF licenses this file to You under the Apache License, Version 2.0
-* (the "License"); you may not use this file except in compliance with
-* the License.  You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 #include <stdlib.h>
 #include <string.h>
 
 #include <condition_variable>
 #include <iomanip>
 #include <iostream>
-#include <map>
-#include <mutex>
-#include <string>
 #include <vector>
 
 #include "common.h"
diff --git a/example/BatchProducer.cpp b/example/BatchProducer.cpp
index d889ea9..18f33cb 100644
--- a/example/BatchProducer.cpp
+++ b/example/BatchProducer.cpp
@@ -1,26 +1,24 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
-* contributor license agreements.  See the NOTICE file distributed with
-* this work for additional information regarding copyright ownership.
-* The ASF licenses this file to You under the Apache License, Version 2.0
-* (the "License"); you may not use this file except in compliance with
-* the License.  You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <condition_variable>
 #include <iomanip>
-#include <iomanip>
-#include <iostream>
 #include <iostream>
 #include <mutex>
 #include <thread>
@@ -29,7 +27,7 @@
 
 using namespace rocketmq;
 using namespace std;
-boost::atomic<bool> g_quit;
+std::atomic<bool> g_quit;
 std::mutex g_mtx;
 std::condition_variable g_finished;
 TpsReportService g_tps;
diff --git a/example/CAsyncProducer.c b/example/CAsyncProducer.c
index 2d2af61..9837c1f 100644
--- a/example/CAsyncProducer.c
+++ b/example/CAsyncProducer.c
@@ -1,30 +1,30 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
-* contributor license agreements.  See the NOTICE file distributed with
-* this work for additional information regarding copyright ownership.
-* The ASF licenses this file to You under the Apache License, Version 2.0
-* (the "License"); you may not use this file except in compliance with
-* the License.  You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 #include <stdio.h>
-#include "CProducer.h"
 #include "CCommon.h"
 #include "CMessage.h"
+#include "CProducer.h"
 #include "CSendResult.h"
 #ifdef _WIN32
 #include <windows.h>
 #else
-#include <unistd.h>
 #include <memory.h>
+#include <unistd.h>
 #endif
 
 void thread_sleep(unsigned milliseconds) {
diff --git a/example/COrderlyAsyncProducer.c b/example/COrderlyAsyncProducer.c
index 48a822c..b48fb54 100644
--- a/example/COrderlyAsyncProducer.c
+++ b/example/COrderlyAsyncProducer.c
@@ -1,30 +1,30 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
-* contributor license agreements.  See the NOTICE file distributed with
-* this work for additional information regarding copyright ownership.
-* The ASF licenses this file to You under the Apache License, Version 2.0
-* (the "License"); you may not use this file except in compliance with
-* the License.  You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 #include <stdio.h>
-#include "CProducer.h"
 #include "CCommon.h"
 #include "CMessage.h"
+#include "CProducer.h"
 #include "CSendResult.h"
 #ifdef _WIN32
 #include <windows.h>
 #else
-#include <unistd.h>
 #include <memory.h>
+#include <unistd.h>
 #endif
 
 void thread_sleep(unsigned milliseconds) {
diff --git a/example/OrderProducer.cpp b/example/OrderProducer.cpp
index 613add4..402e916 100644
--- a/example/OrderProducer.cpp
+++ b/example/OrderProducer.cpp
@@ -1,27 +1,26 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
-* contributor license agreements.  See the NOTICE file distributed with
-* this work for additional information regarding copyright ownership.
-* The ASF licenses this file to You under the Apache License, Version 2.0
-* (the "License"); you may not use this file except in compliance with
-* the License.  You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-#include <stdio.h>
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 #include <stdlib.h>
 #include <string.h>
 
 #include <condition_variable>
 #include <iomanip>
 #include <iostream>
-#include <mutex>
 #include <thread>
 
 #include "common.h"
@@ -30,7 +29,7 @@ using namespace rocketmq;
 
 std::condition_variable g_finished;
 std::mutex g_mtx;
-boost::atomic<bool> g_quit(false);
+std::atomic<bool> g_quit(false);
 
 class SelectMessageQueueByHash : public MessageQueueSelector {
  public:
diff --git a/example/OrderlyPushConsumer.cpp b/example/OrderlyPushConsumer.cpp
index c8a9eaa..174e2b3 100644
--- a/example/OrderlyPushConsumer.cpp
+++ b/example/OrderlyPushConsumer.cpp
@@ -1,19 +1,19 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
-* contributor license agreements.  See the NOTICE file distributed with
-* this work for additional information regarding copyright ownership.
-* The ASF licenses this file to You under the Apache License, Version 2.0
-* (the "License"); you may not use this file except in compliance with
-* the License.  You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 #include <stdlib.h>
 #include <string.h>
 
@@ -31,8 +31,8 @@ using namespace rocketmq;
 
 std::condition_variable g_finished;
 std::mutex g_mtx;
-boost::atomic<int> g_consumedCount(0);
-boost::atomic<bool> g_quit(false);
+std::atomic<int> g_consumedCount(0);
+std::atomic<bool> g_quit(false);
 TpsReportService g_tps;
 
 class MyMsgListener : public MessageListenerOrderly {
diff --git a/example/PullConsumeMessage.c b/example/PullConsumeMessage.c
index 0868d08..f9b9bc2 100644
--- a/example/PullConsumeMessage.c
+++ b/example/PullConsumeMessage.c
@@ -1,31 +1,31 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
-* contributor license agreements.  See the NOTICE file distributed with
-* this work for additional information regarding copyright ownership.
-* The ASF licenses this file to You under the Apache License, Version 2.0
-* (the "License"); you may not use this file except in compliance with
-* the License.  You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 #include <stdio.h>
-#include "CPullConsumer.h"
 #include "CCommon.h"
 #include "CMessageExt.h"
-#include "CPullResult.h"
 #include "CMessageQueue.h"
+#include "CPullConsumer.h"
+#include "CPullResult.h"
 #ifdef _WIN32
 #include <windows.h>
 #else
-#include <unistd.h>
 #include <memory.h>
+#include <unistd.h>
 #endif
 
 void thread_sleep(unsigned milliseconds) {
diff --git a/example/PullConsumer.cpp b/example/PullConsumer.cpp
index 52e9094..e85a821 100644
--- a/example/PullConsumer.cpp
+++ b/example/PullConsumer.cpp
@@ -1,22 +1,21 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
-* contributor license agreements.  See the NOTICE file distributed with
-* this work for additional information regarding copyright ownership.
-* The ASF licenses this file to You under the Apache License, Version 2.0
-* (the "License"); you may not use this file except in compliance with
-* the License.  You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 #include <stdlib.h>
-#include <string.h>
 
 #include <chrono>
 #include <iomanip>
diff --git a/example/PushConsumeMessage.c b/example/PushConsumeMessage.c
index 2cb9c3f..85ea28c 100644
--- a/example/PushConsumeMessage.c
+++ b/example/PushConsumeMessage.c
@@ -1,29 +1,29 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
-* contributor license agreements.  See the NOTICE file distributed with
-* this work for additional information regarding copyright ownership.
-* The ASF licenses this file to You under the Apache License, Version 2.0
-* (the "License"); you may not use this file except in compliance with
-* the License.  You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 #include <stdio.h>
-#include "CPushConsumer.h"
 #include "CCommon.h"
 #include "CMessageExt.h"
+#include "CPushConsumer.h"
 #ifdef _WIN32
 #include <windows.h>
 #else
-#include <unistd.h>
 #include <memory.h>
+#include <unistd.h>
 #endif
 
 void thread_sleep(unsigned milliseconds) {
diff --git a/example/PushConsumer.cpp b/example/PushConsumer.cpp
index f0d4926..0b69ca5 100644
--- a/example/PushConsumer.cpp
+++ b/example/PushConsumer.cpp
@@ -1,19 +1,19 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
-* contributor license agreements.  See the NOTICE file distributed with
-* this work for additional information regarding copyright ownership.
-* The ASF licenses this file to You under the Apache License, Version 2.0
-* (the "License"); you may not use this file except in compliance with
-* the License.  You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 #include <stdlib.h>
 #include <string.h>
 
diff --git a/example/PushConsumerOrderly.c b/example/PushConsumerOrderly.c
index 4b2c2bb..9601799 100644
--- a/example/PushConsumerOrderly.c
+++ b/example/PushConsumerOrderly.c
@@ -1,26 +1,26 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
-* contributor license agreements.  See the NOTICE file distributed with
-* this work for additional information regarding copyright ownership.
-* The ASF licenses this file to You under the Apache License, Version 2.0
-* (the "License"); you may not use this file except in compliance with
-* the License.  You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 #ifndef WIN32
 #include <unistd.h>
 #endif
 #include <stdio.h>
-#include "CPushConsumer.h"
 #include "CCommon.h"
 #include "CMessageExt.h"
+#include "CPushConsumer.h"
 
 int doConsumeMessage(struct CPushConsumer* consumer, CMessageExt* msgExt) {
   printf("Hello,doConsumeMessage by Application!\n");
diff --git a/example/README.md b/example/README.md
index 91965d0..378a4ea 100644
--- a/example/README.md
+++ b/example/README.md
@@ -1,4 +1 @@
-1. AsyncProducer
-2. OrderlyProducer
-3. SyncProducer
-
+1. AsyncProducer 2. OrderlyProducer 3. SyncProducer
diff --git a/example/SendDelayMsg.cpp b/example/SendDelayMsg.cpp
index 2486427..860f5b3 100644
--- a/example/SendDelayMsg.cpp
+++ b/example/SendDelayMsg.cpp
@@ -1,27 +1,25 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
-* contributor license agreements.  See the NOTICE file distributed with
-* this work for additional information regarding copyright ownership.
-* The ASF licenses this file to You under the Apache License, Version 2.0
-* (the "License"); you may not use this file except in compliance with
-* the License.  You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include <condition_variable>
 #include <iomanip>
-#include <iomanip>
-#include <iostream>
 #include <iostream>
 #include <mutex>
 #include <thread>
diff --git a/example/SyncProducer.cpp b/example/SyncProducer.cpp
index 0edb6dc..5d66da2 100644
--- a/example/SyncProducer.cpp
+++ b/example/SyncProducer.cpp
@@ -1,27 +1,25 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
-* contributor license agreements.  See the NOTICE file distributed with
-* this work for additional information regarding copyright ownership.
-* The ASF licenses this file to You under the Apache License, Version 2.0
-* (the "License"); you may not use this file except in compliance with
-* the License.  You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include <condition_variable>
 #include <iomanip>
-#include <iomanip>
-#include <iostream>
 #include <iostream>
 #include <mutex>
 #include <thread>
@@ -30,7 +28,7 @@
 
 using namespace rocketmq;
 
-boost::atomic<bool> g_quit;
+std::atomic<bool> g_quit;
 std::mutex g_mtx;
 std::condition_variable g_finished;
 TpsReportService g_tps;
diff --git a/example/common.h b/example/common.h
index 5b674c3..e3f1b09 100644
--- a/example/common.h
+++ b/example/common.h
@@ -1,44 +1,45 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
-* contributor license agreements.  See the NOTICE file distributed with
-* this work for additional information regarding copyright ownership.
-* The ASF licenses this file to You under the Apache License, Version 2.0
-* (the "License"); you may not use this file except in compliance with
-* the License.  You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 #ifndef ROCKETMQ_CLIENT4CPP_EXAMPLE_COMMON_H_
 #define ROCKETMQ_CLIENT4CPP_EXAMPLE_COMMON_H_
 
-#include <boost/atomic.hpp>
-#include <boost/chrono.hpp>
-#include <boost/shared_ptr.hpp>
-#include <boost/thread.hpp>
+#include <atomic>
+#include <chrono>
 #include <iostream>
+#include <memory>
 #include <string>
 #include <thread>
 #include <vector>
-
+#ifndef WIN32
+#include "unistd.h"
+#endif
 #include "Arg_helper.h"
 #include "DefaultMQProducer.h"
 #include "DefaultMQPullConsumer.h"
 #include "DefaultMQPushConsumer.h"
 using namespace std;
 
-boost::atomic<int> g_msgCount(1);
+std::atomic<int> g_msgCount(1);
 
 class RocketmqSendAndConsumerArgs {
  public:
   RocketmqSendAndConsumerArgs()
       : body("msgbody for test"),
-        thread_count(boost::thread::hardware_concurrency()),
+        thread_count(std::thread::hardware_concurrency()),
         broadcasting(false),
         syncpush(false),
         SelectUnactiveBroker(false),
@@ -69,7 +70,7 @@ class TpsReportService {
       std::cout << "tps_thread_ is null" << std::endl;
       return;
     }
-    tps_thread_.reset(new boost::thread(boost::bind(&TpsReportService::TpsReport, this)));
+    tps_thread_.reset(new std::thread(std::bind(&TpsReportService::TpsReport, this)));
   }
 
   ~TpsReportService() {
@@ -86,28 +87,19 @@ class TpsReportService {
 
   void TpsReport() {
     while (!quit_flag_.load()) {
-      boost::this_thread::sleep_for(tps_interval_);
+      std::this_thread::sleep_for(tps_interval_);
       std::cout << "tps: " << tps_count_.load() << std::endl;
       tps_count_.store(0);
     }
   }
 
  private:
-  boost::chrono::seconds tps_interval_;
-  boost::shared_ptr<boost::thread> tps_thread_;
-  boost::atomic<bool> quit_flag_;
-  boost::atomic<long> tps_count_;
+  std::chrono::seconds tps_interval_;
+  std::shared_ptr<std::thread> tps_thread_;
+  std::atomic<bool> quit_flag_;
+  std::atomic<long> tps_count_;
 };
 
-/*
-static void PrintResult(rocketmq::SendResult* result) {
-  std::cout << "sendresult = " << result->getSendStatus()
-            << ", msgid = " << result->getMsgId()
-            << ", queueOffset = " << result->getQueueOffset() << ","
-            << result->getMessageQueue().toString() << endl;
-}
-*/
-
 void PrintPullResult(rocketmq::PullResult* result) {
   std::cout << result->toString() << std::endl;
   if (result->pullStatus == rocketmq::FOUND) {
diff --git a/include/DefaultMQProducer.h b/include/DefaultMQProducer.h
index 630e765..a96a59b 100644
--- a/include/DefaultMQProducer.h
+++ b/include/DefaultMQProducer.h
@@ -18,25 +18,25 @@
 #ifndef __DEFAULTMQPRODUCER_H__
 #define __DEFAULTMQPRODUCER_H__
 
-#include "BatchMessage.h"
+#include "AsyncCallback.h"
+#include "MQClient.h"
 #include "MQMessageQueue.h"
-#include "MQProducer.h"
+#include "MQSelector.h"
 #include "RocketMQClient.h"
 #include "SendResult.h"
+#include "SessionCredentials.h"
 
 namespace rocketmq {
+class DefaultMQProducerImpl;
 //<!***************************************************************************
-class ROCKETMQCLIENT_API DefaultMQProducer : public MQProducer {
+class ROCKETMQCLIENT_API DefaultMQProducer {
  public:
   DefaultMQProducer(const std::string& groupname);
   virtual ~DefaultMQProducer();
 
-  //<!begin mqadmin;
   virtual void start();
   virtual void shutdown();
-  //<!end mqadmin;
 
-  //<! begin MQProducer;
   virtual SendResult send(MQMessage& msg, bool bSelectActiveBroker = false);
   virtual SendResult send(MQMessage& msg, const MQMessageQueue& mq);
   virtual SendResult send(MQMessage& msg, MessageQueueSelector* selector, void* arg);
@@ -53,16 +53,14 @@ class ROCKETMQCLIENT_API DefaultMQProducer : public MQProducer {
   virtual void sendOneway(MQMessage& msg, bool bSelectActiveBroker = false);
   virtual void sendOneway(MQMessage& msg, const MQMessageQueue& mq);
   virtual void sendOneway(MQMessage& msg, MessageQueueSelector* selector, void* arg);
-  //<! end MQProducer;
 
-  // set and get timeout of per msg
   int getSendMsgTimeout() const;
   void setSendMsgTimeout(int sendMsgTimeout);
 
   /*
-  *  if msgBody size is large than m_compressMsgBodyOverHowmuch
-      rocketmq cpp will compress msgBody according to compressLevel
-  */
+   *  if msgBody size is large than m_compressMsgBodyOverHowmuch
+   *  rocketmq cpp will compress msgBody according to compressLevel
+   */
   int getCompressMsgBodyOverHowmuch() const;
   void setCompressMsgBodyOverHowmuch(int compressMsgBodyOverHowmuch);
   int getCompressLevel() const;
@@ -78,40 +76,64 @@ class ROCKETMQCLIENT_API DefaultMQProducer : public MQProducer {
 
   int getRetryTimes4Async() const;
   void setRetryTimes4Async(int times);
+  const std::string& getNamesrvAddr() const;
+  void setNamesrvAddr(const std::string& namesrvAddr);
+  const std::string& getNamesrvDomain() const;
+  void setNamesrvDomain(const std::string& namesrvDomain);
+  const std::string& getInstanceName() const;
+  void setInstanceName(const std::string& instanceName);
+  // nameSpace
+  const std::string& getNameSpace() const;
+  void setNameSpace(const std::string& nameSpace);
+  const std::string& getGroupName() const;
+  void setGroupName(const std::string& groupname);
 
- protected:
-  SendResult sendAutoRetrySelectImpl(MQMessage& msg,
-                                     MessageQueueSelector* pSelector,
-                                     void* pArg,
-                                     int communicationMode,
-                                     SendCallback* pSendCallback,
-                                     int retryTimes,
-                                     bool bActiveBroker = false);
-  SendResult sendSelectImpl(MQMessage& msg,
-                            MessageQueueSelector* pSelector,
-                            void* pArg,
-                            int communicationMode,
-                            SendCallback* sendCallback);
-  SendResult sendDefaultImpl(MQMessage& msg,
-                             int communicationMode,
-                             SendCallback* pSendCallback,
-                             bool bActiveBroker = false);
-  SendResult sendKernelImpl(MQMessage& msg,
-                            const MQMessageQueue& mq,
-                            int communicationMode,
-                            SendCallback* pSendCallback);
-  bool tryToCompressMessage(MQMessage& msg);
-  BatchMessage buildBatchMessage(std::vector<MQMessage>& msgs);
-  bool dealWithNameSpace();
+  // log configuration interface, default LOG_LEVEL is LOG_LEVEL_INFO, default
+  // log file num is 3, each log size is 100M
+  void setLogLevel(elogLevel inputLevel);
+  elogLevel getLogLevel();
+  void setLogFileSizeAndNum(int fileNum, long perFileSize);  // perFileSize is MB unit
+
+  /** set TcpTransport pull thread num, which dermine the num of threads to
+   *  distribute network data,
+   *  1. its default value is CPU num, it must be setted before producer/consumer
+   *     start, minimum value is CPU num;
+   *  2. this pullThread num must be tested on your environment to find the best
+   *     value for RT of sendMsg or delay time of consume msg before you change it;
+   *  3. producer and consumer need different pullThread num, if set this num,
+   *     producer and consumer must set different instanceName.
+   **/
+  void setTcpTransportPullThreadNum(int num);
+  const int getTcpTransportPullThreadNum() const;
+
+  /** timeout of tcp connect, it is same meaning for both producer and consumer;
+   *    1. default value is 3000ms
+   *    2. input parameter could only be milliSecond, suggestion value is
+   *       1000-3000ms;
+   **/
+  void setTcpTransportConnectTimeout(uint64_t timeout);  // ms
+  const uint64_t getTcpTransportConnectTimeout() const;
+
+  /** timeout of tryLock tcpTransport before sendMsg/pullMsg, if timeout,
+   *  returns NULL
+   *    1. paremeter unit is ms, default value is 3000ms, the minimun value is 1000ms
+   *       suggestion value is 3000ms;
+   *    2. if configured with value smaller than 1000ms, the tryLockTimeout value
+   *       will be setted to 1000ms
+   **/
+  void setTcpTransportTryLockTimeout(uint64_t timeout);  // ms
+  const uint64_t getTcpTransportTryLockTimeout() const;
+
+  void setUnitName(std::string unitName);
+  const std::string& getUnitName() const;
+
+  void setSessionCredentials(const std::string& accessKey,
+                             const std::string& secretKey,
+                             const std::string& accessChannel);
+  const SessionCredentials& getSessionCredentials() const;
 
  private:
-  int m_sendMsgTimeout;
-  int m_compressMsgBodyOverHowmuch;
-  int m_maxMessageSize;  //<! default:128K;
-  // bool m_retryAnotherBrokerWhenNotStoreOK;
-  int m_compressLevel;
-  int m_retryTimes;
-  int m_retryTimes4Async;
+  DefaultMQProducerImpl* impl;
 };
 //<!***************************************************************************
 }  // namespace rocketmq
diff --git a/include/DefaultMQPullConsumer.h b/include/DefaultMQPullConsumer.h
index 8e1612d..552bbab 100644
--- a/include/DefaultMQPullConsumer.h
+++ b/include/DefaultMQPullConsumer.h
@@ -20,19 +20,21 @@
 
 #include <set>
 #include <string>
-#include "MQConsumer.h"
+#include "AsyncCallback.h"
+#include "ConsumeType.h"
+#include "MQClient.h"
+#include "MQMessage.h"
+#include "MQMessageExt.h"
 #include "MQMessageQueue.h"
 #include "MQueueListener.h"
+#include "PullResult.h"
 #include "RocketMQClient.h"
 
 namespace rocketmq {
-class Rebalance;
 class SubscriptionData;
-class OffsetStore;
-class PullAPIWrapper;
-class ConsumerRunningInfo;
+class DefaultMQPullConsumerImpl;
 //<!***************************************************************************
-class ROCKETMQCLIENT_API DefaultMQPullConsumer : public MQConsumer {
+class ROCKETMQCLIENT_API DefaultMQPullConsumer {
  public:
   DefaultMQPullConsumer(const std::string& groupname);
   virtual ~DefaultMQPullConsumer();
@@ -41,11 +43,30 @@ class ROCKETMQCLIENT_API DefaultMQPullConsumer : public MQConsumer {
   virtual void start();
   virtual void shutdown();
   //<!end mqadmin;
-
+  const std::string& getNamesrvAddr() const;
+  void setNamesrvAddr(const std::string& namesrvAddr);
+  const std::string& getNamesrvDomain() const;
+  void setNamesrvDomain(const std::string& namesrvDomain);
+  const std::string& getInstanceName() const;
+  void setInstanceName(const std::string& instanceName);
+  // nameSpace
+  const std::string& getNameSpace() const;
+  void setNameSpace(const std::string& nameSpace);
+  const std::string& getGroupName() const;
+  void setGroupName(const std::string& groupname);
+
+  // log configuration interface, default LOG_LEVEL is LOG_LEVEL_INFO, default
+  // log file num is 3, each log size is 100M
+  void setLogLevel(elogLevel inputLevel);
+  elogLevel getLogLevel();
+  void setLogFileSizeAndNum(int fileNum, long perFileSize);  // perFileSize is MB unit
+
+  void setSessionCredentials(const std::string& accessKey,
+                             const std::string& secretKey,
+                             const std::string& accessChannel);
+  const SessionCredentials& getSessionCredentials() const;
   //<!begin MQConsumer
-  virtual bool sendMessageBack(MQMessageExt& msg, int delayLevel, std::string& brokerName);
   virtual void fetchSubscribeMessageQueues(const std::string& topic, std::vector<MQMessageQueue>& mqs);
-  virtual void doRebalance();
   virtual void persistConsumerOffset();
   virtual void persistConsumerOffsetByResetOffset();
   virtual void updateTopicSubscribeInfo(const std::string& topic, std::vector<MQMessageQueue>& info);
@@ -54,8 +75,6 @@ class ROCKETMQCLIENT_API DefaultMQPullConsumer : public MQConsumer {
   virtual void getSubscriptions(std::vector<SubscriptionData>&);
   virtual void updateConsumeOffset(const MQMessageQueue& mq, int64 offset);
   virtual void removeConsumeOffset(const MQMessageQueue& mq);
-  virtual bool producePullMsgTask(boost::weak_ptr<PullRequest> pullRequest);
-  virtual Rebalance* getRebalance() const;
   //<!end MQConsumer;
 
   void registerMessageQueueListener(const std::string& topic, MQueueListener* pListener);
@@ -105,8 +124,6 @@ class ROCKETMQCLIENT_API DefaultMQPullConsumer : public MQConsumer {
                            int maxNums,
                            PullCallback* pPullCallback);
 
-  virtual ConsumerRunningInfo* getConsumerRunningInfo() { return NULL; }
-
   int64 fetchConsumeOffset(const MQMessageQueue& mq, bool fromStore);
 
   void fetchMessageQueuesInBalance(const std::string& topic, std::vector<MQMessageQueue> mqs);
@@ -116,32 +133,7 @@ class ROCKETMQCLIENT_API DefaultMQPullConsumer : public MQConsumer {
   void persistConsumerOffset4PullConsumer(const MQMessageQueue& mq);
 
  private:
-  void checkConfig();
-  void copySubscription();
-  bool dealWithNameSpace();
-
-  PullResult pullSyncImpl(const MQMessageQueue& mq,
-                          const std::string& subExpression,
-                          int64 offset,
-                          int maxNums,
-                          bool block);
-
-  void pullAsyncImpl(const MQMessageQueue& mq,
-                     const std::string& subExpression,
-                     int64 offset,
-                     int maxNums,
-                     bool block,
-                     PullCallback* pPullCallback);
-
-  void subscriptionAutomatically(const std::string& topic);
-
- private:
-  std::set<std::string> m_registerTopics;
-
-  MQueueListener* m_pMessageQueueListener;
-  OffsetStore* m_pOffsetStore;
-  Rebalance* m_pRebalance;
-  PullAPIWrapper* m_pPullAPIWrapper;
+  DefaultMQPullConsumerImpl* impl;
 };
 //<!***************************************************************************
 }  // namespace rocketmq
diff --git a/include/DefaultMQPushConsumer.h b/include/DefaultMQPushConsumer.h
index 7f69258..cd4e599 100644
--- a/include/DefaultMQPushConsumer.h
+++ b/include/DefaultMQPushConsumer.h
@@ -18,87 +18,34 @@
 #ifndef __DEFAULTMQPUSHCONSUMER_H__
 #define __DEFAULTMQPUSHCONSUMER_H__
 
-#include <boost/asio.hpp>
-#include <boost/asio/io_service.hpp>
-#include <boost/bind.hpp>
-#include <boost/date_time/posix_time/posix_time.hpp>
-#include <boost/scoped_ptr.hpp>
-#include <boost/thread/thread.hpp>
 #include <string>
 #include "AsyncCallback.h"
-#include "MQConsumer.h"
+#include "ConsumeType.h"
+#include "MQClient.h"
 #include "MQMessageListener.h"
 #include "MQMessageQueue.h"
 
 namespace rocketmq {
-
-class Rebalance;
-class SubscriptionData;
-class OffsetStore;
-class PullAPIWrapper;
-class PullRequest;
-class ConsumeMsgService;
-class TaskQueue;
-class TaskThread;
-class AsyncPullCallback;
-class ConsumerRunningInfo;
+class DefaultMQPushConsumerImpl;
 //<!***************************************************************************
-class ROCKETMQCLIENT_API DefaultMQPushConsumer : public MQConsumer {
+class ROCKETMQCLIENT_API DefaultMQPushConsumer {
  public:
   DefaultMQPushConsumer(const std::string& groupname);
-  void boost_asio_work();
+
   virtual ~DefaultMQPushConsumer();
 
   //<!begin mqadmin;
   virtual void start();
   virtual void shutdown();
-  //<!end mqadmin;
-
-  //<!begin MQConsumer
-  virtual bool sendMessageBack(MQMessageExt& msg, int delayLevel, std::string& brokerName);
-  virtual void fetchSubscribeMessageQueues(const std::string& topic, std::vector<MQMessageQueue>& mqs);
-  virtual void doRebalance();
-  virtual void persistConsumerOffset();
-  virtual void persistConsumerOffsetByResetOffset();
-  virtual void updateTopicSubscribeInfo(const std::string& topic, std::vector<MQMessageQueue>& info);
+
   virtual ConsumeType getConsumeType();
   virtual ConsumeFromWhere getConsumeFromWhere();
   void setConsumeFromWhere(ConsumeFromWhere consumeFromWhere);
-  virtual void getSubscriptions(std::vector<SubscriptionData>&);
-  virtual void updateConsumeOffset(const MQMessageQueue& mq, int64 offset);
-  virtual void removeConsumeOffset(const MQMessageQueue& mq);
-  virtual PullResult pull(const MQMessageQueue& mq, const std::string& subExpression, int64 offset, int maxNums) {
-    return PullResult();
-  }
-  virtual void pull(const MQMessageQueue& mq,
-                    const std::string& subExpression,
-                    int64 offset,
-                    int maxNums,
-                    PullCallback* pPullCallback) {}
-  virtual ConsumerRunningInfo* getConsumerRunningInfo();
-  //<!end MQConsumer;
 
   void registerMessageListener(MQMessageListener* pMessageListener);
   MessageListenerType getMessageListenerType();
   void subscribe(const std::string& topic, const std::string& subExpression);
 
-  OffsetStore* getOffsetStore() const;
-  virtual Rebalance* getRebalance() const;
-  ConsumeMsgService* getConsumerMsgService() const;
-
-  virtual bool producePullMsgTask(boost::weak_ptr<PullRequest>);
-  virtual bool producePullMsgTaskLater(boost::weak_ptr<PullRequest>, int millis);
-  static void static_triggerNextPullRequest(void* context,
-                                            boost::asio::deadline_timer* t,
-                                            boost::weak_ptr<PullRequest>);
-  void triggerNextPullRequest(boost::asio::deadline_timer* t, boost::weak_ptr<PullRequest>);
-  void runPullMsgQueue(TaskQueue* pTaskQueue);
-  void pullMessage(boost::weak_ptr<PullRequest> pullrequest);
-  void pullMessageAsync(boost::weak_ptr<PullRequest> pullrequest);
-  void setAsyncPull(bool asyncFlag);
-  AsyncPullCallback* getAsyncPullCallBack(boost::weak_ptr<PullRequest>, MQMessageQueue msgQueue);
-  void shutdownAsyncPullCallBack();
-
   /*
     for orderly consume, set the pull num of message size by each pullMsg,
     default value is 1;
@@ -128,37 +75,66 @@ class ROCKETMQCLIENT_API DefaultMQPushConsumer : public MQConsumer {
   void setMaxCacheMsgSizePerQueue(int maxCacheSize);
   int getMaxCacheMsgSizePerQueue() const;
 
- private:
-  void checkConfig();
-  void copySubscription();
-  void updateTopicSubscribeInfoWhenSubscriptionChanged();
-  bool dealWithNameSpace();
-
- private:
-  uint64_t m_startTime;
-  ConsumeFromWhere m_consumeFromWhere;
-  std::map<std::string, std::string> m_subTopics;
-  int m_consumeThreadCount;
-  OffsetStore* m_pOffsetStore;
-  Rebalance* m_pRebalance;
-  PullAPIWrapper* m_pPullAPIWrapper;
-  ConsumeMsgService* m_consumerService;
-  MQMessageListener* m_pMessageListener;
-  int m_consumeMessageBatchMaxSize;
-  int m_maxMsgCacheSize;
-  int m_maxReconsumeTimes = -1;
-  boost::asio::io_service m_async_ioService;
-  boost::scoped_ptr<boost::thread> m_async_service_thread;
-
-  typedef std::map<MQMessageQueue, AsyncPullCallback*> PullMAP;
-  PullMAP m_PullCallback;
-  bool m_asyncPull;
-  int m_asyncPullTimeout;
-  int m_pullMsgThreadPoolNum;
+  MessageModel getMessageModel() const;
+  void setMessageModel(MessageModel messageModel);
+  const std::string& getNamesrvAddr() const;
+  void setNamesrvAddr(const std::string& namesrvAddr);
+  const std::string& getNamesrvDomain() const;
+  void setNamesrvDomain(const std::string& namesrvDomain);
+  const std::string& getInstanceName() const;
+  void setInstanceName(const std::string& instanceName);
+  // nameSpace
+  const std::string& getNameSpace() const;
+  void setNameSpace(const std::string& nameSpace);
+  const std::string& getGroupName() const;
+  void setGroupName(const std::string& groupname);
+
+  // log configuration interface, default LOG_LEVEL is LOG_LEVEL_INFO, default
+  // log file num is 3, each log size is 100M
+  void setLogLevel(elogLevel inputLevel);
+  elogLevel getLogLevel();
+  void setLogFileSizeAndNum(int fileNum, long perFileSize);  // perFileSize is MB unit
+
+  /** set TcpTransport pull thread num, which dermine the num of threads to
+   *  distribute network data,
+   *  1. its default value is CPU num, it must be setted before producer/consumer
+   *     start, minimum value is CPU num;
+   *  2. this pullThread num must be tested on your environment to find the best
+   *     value for RT of sendMsg or delay time of consume msg before you change it;
+   *  3. producer and consumer need different pullThread num, if set this num,
+   *     producer and consumer must set different instanceName.
+   **/
+  void setTcpTransportPullThreadNum(int num);
+  const int getTcpTransportPullThreadNum() const;
+
+  /** timeout of tcp connect, it is same meaning for both producer and consumer;
+   *    1. default value is 3000ms
+   *    2. input parameter could only be milliSecond, suggestion value is
+   *       1000-3000ms;
+   **/
+  void setTcpTransportConnectTimeout(uint64_t timeout);  // ms
+  const uint64_t getTcpTransportConnectTimeout() const;
+
+  /** timeout of tryLock tcpTransport before sendMsg/pullMsg, if timeout,
+   *  returns NULL
+   *    1. paremeter unit is ms, default value is 3000ms, the minimun value is 1000ms
+   *       suggestion value is 3000ms;
+   *    2. if configured with value smaller than 1000ms, the tryLockTimeout value
+   *       will be setted to 1000ms
+   **/
+  void setTcpTransportTryLockTimeout(uint64_t timeout);  // ms
+  const uint64_t getTcpTransportTryLockTimeout() const;
+
+  void setUnitName(std::string unitName);
+  const std::string& getUnitName() const;
+  void setAsyncPull(bool asyncFlag);
+  void setSessionCredentials(const std::string& accessKey,
+                             const std::string& secretKey,
+                             const std::string& accessChannel);
+  const SessionCredentials& getSessionCredentials() const;
 
  private:
-  TaskQueue* m_pullmsgQueue;
-  std::unique_ptr<boost::thread> m_pullmsgThread;
+  DefaultMQPushConsumerImpl* impl;
 };
 //<!***************************************************************************
 }  // namespace rocketmq
diff --git a/include/MQClient.h b/include/MQClient.h
index 0e23339..d449aab 100644
--- a/include/MQClient.h
+++ b/include/MQClient.h
@@ -1,202 +1,38 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef __MQADMIN_H__
-#define __MQADMIN_H__
-#include <boost/asio.hpp>
-#include <boost/asio/io_service.hpp>
-#include <boost/bind.hpp>
-#include <boost/date_time/posix_time/posix_time.hpp>
-#include <boost/thread/mutex.hpp>
-#include <boost/thread/thread.hpp>
-#include "MQMessageExt.h"
-#include "MQMessageQueue.h"
-#include "QueryResult.h"
-#include "RocketMQClient.h"
-#include "SessionCredentials.h"
-
-namespace rocketmq {
-class MQClientFactory;
-//<!***************************************************************************
-
-enum elogLevel {
-  eLOG_LEVEL_FATAL = 1,
-  eLOG_LEVEL_ERROR = 2,
-  eLOG_LEVEL_WARN = 3,
-  eLOG_LEVEL_INFO = 4,
-  eLOG_LEVEL_DEBUG = 5,
-  eLOG_LEVEL_TRACE = 6,
-  eLOG_LEVEL_LEVEL_NUM = 7
-};
-
-class ROCKETMQCLIENT_API MQClient {
- public:
-  MQClient();
-  virtual ~MQClient();
-
- public:
-  // clientid=processId-ipAddr@instanceName;
-  std::string getMQClientId() const;
-  const std::string& getNamesrvAddr() const;
-  void setNamesrvAddr(const std::string& namesrvAddr);
-  const std::string& getNamesrvDomain() const;
-  void setNamesrvDomain(const std::string& namesrvDomain);
-  const std::string& getInstanceName() const;
-  void setInstanceName(const std::string& instanceName);
-  // nameSpace
-  const std::string& getNameSpace() const;
-  void setNameSpace(const std::string& nameSpace);
-  const std::string& getGroupName() const;
-  void setGroupName(const std::string& groupname);
-
-  /**
-   * no realization
-   */
-  void createTopic(const std::string& key, const std::string& newTopic, int queueNum);
-  /**
-   * search earliest msg store time for specified queue
-   *
-   * @param mq
-   *            message queue
-   * @return earliest store time, ms
-   */
-  int64 earliestMsgStoreTime(const MQMessageQueue& mq);
-  /**
-   * search maxOffset of queue
-   *
-   * @param mq
-   *            message queue
-   * @return minOffset of queue
-   */
-  int64 minOffset(const MQMessageQueue& mq);
-  /**
-   * search maxOffset of queue
-   * Note: maxOffset-1 is max offset that could get msg
-   * @param mq
-   *            message queue
-   * @return maxOffset of queue
-   */
-  int64 maxOffset(const MQMessageQueue& mq);
-  /**
-   * get queue offset by timestamp
-   *
-   * @param mq
-   *            mq queue
-   * @param timestamp
-   *            timestamp with ms unit
-   * @return queue offset according to timestamp
-   */
-  int64 searchOffset(const MQMessageQueue& mq, uint64_t timestamp);
-  /**
-   * get whole msg info from broker by msgId
-   *
-   * @param msgId
-   * @return MQMessageExt
-   */
-  MQMessageExt* viewMessage(const std::string& msgId);
-  /**
-   * query message by topic and key
-   *
-   * @param topic
-   *            topic name
-   * @param key
-   *            topic key
-   * @param maxNum
-   *            query num
-   * @param begin
-   *            begin timestamp
-   * @param end
-   *            end timestamp
-   * @return
-   *            according to QueryResult
-   */
-  QueryResult queryMessage(const std::string& topic, const std::string& key, int maxNum, int64 begin, int64 end);
-
-  std::vector<MQMessageQueue> getTopicMessageQueueInfo(const std::string& topic);
-
-  // log configuration interface, default LOG_LEVEL is LOG_LEVEL_INFO, default
-  // log file num is 3, each log size is 100M
-  void setLogLevel(elogLevel inputLevel);
-  elogLevel getLogLevel();
-  void setLogFileSizeAndNum(int fileNum, long perFileSize);  // perFileSize is MB unit
-
-  /** set TcpTransport pull thread num, which dermine the num of threads to
- distribute network data,
-     1. its default value is CPU num, it must be setted before producer/consumer
- start, minimum value is CPU num;
-     2. this pullThread num must be tested on your environment to find the best
- value for RT of sendMsg or delay time of consume msg before you change it;
-     3. producer and consumer need different pullThread num, if set this num,
- producer and consumer must set different instanceName.
-     4. configuration suggestion:
-         1>. minimum RT of sendMsg:
-                 pullThreadNum = brokerNum*2
- **/
-  void setTcpTransportPullThreadNum(int num);
-  const int getTcpTransportPullThreadNum() const;
-
-  /** timeout of tcp connect, it is same meaning for both producer and consumer;
-      1. default value is 3000ms
-      2. input parameter could only be milliSecond, suggestion value is
-  1000-3000ms;
-  **/
-  void setTcpTransportConnectTimeout(uint64_t timeout);  // ms
-  const uint64_t getTcpTransportConnectTimeout() const;
-
-  /** timeout of tryLock tcpTransport before sendMsg/pullMsg, if timeout,
-  returns NULL
-      1. paremeter unit is ms, default value is 3000ms, the minimun value is
-  1000ms
-          suggestion value is 3000ms;
-      2. if configured with value smaller than 1000ms, the tryLockTimeout value
-  will be setted to 1000ms
-  **/
-  void setTcpTransportTryLockTimeout(uint64_t timeout);  // ms
-  const uint64_t getTcpTransportTryLockTimeout() const;
-
-  void setUnitName(std::string unitName);
-  const std::string& getUnitName();
-
-  void setSessionCredentials(const std::string& input_accessKey,
-                             const std::string& input_secretKey,
-                             const std::string& input_onsChannel);
-  const SessionCredentials& getSessionCredentials() const;
-
- protected:
-  virtual void start();
-  virtual void shutdown();
-  MQClientFactory* getFactory() const;
-  virtual bool isServiceStateOk();
-
- protected:
-  std::string m_namesrvAddr;
-  std::string m_namesrvDomain;
-  std::string m_instanceName;
-  std::string m_nameSpace;
-  std::string m_GroupName;
-  MQClientFactory* m_clientFactory;
-  int m_serviceState;
-  int m_pullThreadNum;
-  uint64_t m_tcpConnectTimeout;           // ms
-  uint64_t m_tcpTransportTryLockTimeout;  // s
-
-  std::string m_unitName;
-  SessionCredentials m_SessionCredentials;
-};
-//<!***************************************************************************
-}  // namespace rocketmq
-#endif
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __MQADMIN_H__
+#define __MQADMIN_H__
+#include "MQMessageExt.h"
+#include "MQMessageQueue.h"
+#include "RocketMQClient.h"
+#include "SessionCredentials.h"
+
+namespace rocketmq {
+
+enum elogLevel {
+  eLOG_LEVEL_FATAL = 1,
+  eLOG_LEVEL_ERROR = 2,
+  eLOG_LEVEL_WARN = 3,
+  eLOG_LEVEL_INFO = 4,
+  eLOG_LEVEL_DEBUG = 5,
+  eLOG_LEVEL_TRACE = 6,
+  eLOG_LEVEL_LEVEL_NUM = 7
+};
+
+}  // namespace rocketmq
+#endif
diff --git a/include/TransactionMQProducer.h b/include/TransactionMQProducer.h
index fcd9a7c..2ba34db 100644
--- a/include/TransactionMQProducer.h
+++ b/include/TransactionMQProducer.h
@@ -18,29 +18,84 @@
 #ifndef __TRANSACTIONMQPRODUCER_H__
 #define __TRANSACTIONMQPRODUCER_H__
 
-#include <boost/asio.hpp>
-#include <boost/asio/io_service.hpp>
-#include <boost/bind.hpp>
-#include <boost/date_time/posix_time/posix_time.hpp>
-#include <boost/weak_ptr.hpp>
 #include <memory>
 #include <string>
-#include "DefaultMQProducer.h"
+#include "MQClient.h"
+#include "MQMessage.h"
 #include "MQMessageExt.h"
 #include "TransactionListener.h"
 #include "TransactionSendResult.h"
 
 namespace rocketmq {
-
-class ROCKETMQCLIENT_API TransactionMQProducer : public DefaultMQProducer {
+class TransactionMQProducerImpl;
+class ROCKETMQCLIENT_API TransactionMQProducer {
  public:
-  TransactionMQProducer(const std::string& producerGroup)
-      : DefaultMQProducer(producerGroup), m_thread_num(1), m_ioServiceWork(m_ioService) {}
-  virtual ~TransactionMQProducer() {}
+  TransactionMQProducer(const std::string& producerGroup);
+  virtual ~TransactionMQProducer();
   void start();
   void shutdown();
-  std::shared_ptr<TransactionListener> getTransactionListener() { return m_transactionListener; }
-  void setTransactionListener(TransactionListener* listener) { m_transactionListener.reset(listener); }
+  const std::string& getNamesrvAddr() const;
+  void setNamesrvAddr(const std::string& namesrvAddr);
+  const std::string& getNamesrvDomain() const;
+  void setNamesrvDomain(const std::string& namesrvDomain);
+  const std::string& getInstanceName() const;
+  void setInstanceName(const std::string& instanceName);
+  // nameSpace
+  const std::string& getNameSpace() const;
+  void setNameSpace(const std::string& nameSpace);
+  const std::string& getGroupName() const;
+  void setGroupName(const std::string& groupname);
+  void setSessionCredentials(const std::string& accessKey,
+                             const std::string& secretKey,
+                             const std::string& accessChannel);
+  const SessionCredentials& getSessionCredentials() const;
+
+  void setUnitName(std::string unitName);
+  const std::string& getUnitName() const;
+
+  int getSendMsgTimeout() const;
+  void setSendMsgTimeout(int sendMsgTimeout);
+  void setTcpTransportPullThreadNum(int num);
+  const int getTcpTransportPullThreadNum() const;
+
+  /** timeout of tcp connect, it is same meaning for both producer and consumer;
+   *    1. default value is 3000ms
+   *    2. input parameter could only be milliSecond, suggestion value is
+   *       1000-3000ms;
+   **/
+  void setTcpTransportConnectTimeout(uint64_t timeout);  // ms
+  const uint64_t getTcpTransportConnectTimeout() const;
+
+  /** timeout of tryLock tcpTransport before sendMsg/pullMsg, if timeout,
+   *  returns NULL
+   *    1. paremeter unit is ms, default value is 3000ms, the minimun value is 1000ms
+   *       suggestion value is 3000ms;
+   *    2. if configured with value smaller than 1000ms, the tryLockTimeout value
+   *       will be setted to 1000ms
+   **/
+  void setTcpTransportTryLockTimeout(uint64_t timeout);  // ms
+  const uint64_t getTcpTransportTryLockTimeout() const;
+
+  /*
+   *  if msgBody size is large than m_compressMsgBodyOverHowmuch
+   *  rocketmq cpp will compress msgBody according to compressLevel
+   */
+  int getCompressMsgBodyOverHowmuch() const;
+  void setCompressMsgBodyOverHowmuch(int compressMsgBodyOverHowmuch);
+  int getCompressLevel() const;
+  void setCompressLevel(int compressLevel);
+
+  // if msgbody size larger than maxMsgBodySize, exception will be throwed
+  int getMaxMessageSize() const;
+  void setMaxMessageSize(int maxMessageSize);
+  // log configuration interface, default LOG_LEVEL is LOG_LEVEL_INFO, default
+  // log file num is 3, each log size is 100M
+  void setLogLevel(elogLevel inputLevel);
+  elogLevel getLogLevel();
+  void setLogFileSizeAndNum(int fileNum, long perFileSize);  // perFileSize is MB unit
+
+  std::shared_ptr<TransactionListener> getTransactionListener();
+  void setTransactionListener(TransactionListener* listener);
   TransactionSendResult sendMessageInTransaction(MQMessage& msg, void* arg);
   void checkTransactionState(const std::string& addr,
                              const MQMessageExt& message,
@@ -51,23 +106,7 @@ class ROCKETMQCLIENT_API TransactionMQProducer : public DefaultMQProducer {
                              const std::string& offsetMsgId);
 
  private:
-  void initTransactionEnv();
-  void destroyTransactionEnv();
-  void endTransaction(SendResult& sendResult, LocalTransactionState& localTransactionState);
-  void checkTransactionStateImpl(const std::string& addr,
-                                 const MQMessageExt& message,
-                                 long tranStateTableOffset,
-                                 long commitLogOffset,
-                                 const std::string& msgId,
-                                 const std::string& transactionId,
-                                 const std::string& offsetMsgId);
-
- private:
-  std::shared_ptr<TransactionListener> m_transactionListener;
-  int m_thread_num;
-  boost::thread_group m_threadpool;
-  boost::asio::io_service m_ioService;
-  boost::asio::io_service::work m_ioServiceWork;
+  TransactionMQProducerImpl* impl;
 };
 }  // namespace rocketmq
 
diff --git a/src/common/Arg_helper.cpp b/src/common/Arg_helper.cpp
index 61ac549..934954e 100644
--- a/src/common/Arg_helper.cpp
+++ b/src/common/Arg_helper.cpp
@@ -64,4 +64,4 @@ string Arg_helper::get_option_value(string opt_) const {
 }
 
 //<!***************************************************************************
-}  //<!end namespace;
+}  // namespace rocketmq
diff --git a/src/common/AsyncArg.h b/src/common/AsyncArg.h
index fc358cb..a683e6d 100644
--- a/src/common/AsyncArg.h
+++ b/src/common/AsyncArg.h
@@ -1,36 +1,36 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef _AsyncArg_H_
-#define _AsyncArg_H_
-
-#include "MQMessageQueue.h"
-#include "PullAPIWrapper.h"
-#include "SubscriptionData.h"
-
-namespace rocketmq {
-//<!***************************************************************************
-
-struct AsyncArg {
-  MQMessageQueue mq;
-  SubscriptionData subData;
-  PullAPIWrapper* pPullWrapper;
-};
-
-//<!***************************************************************************
-}
-#endif  //<! _AsyncArg_H_
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _AsyncArg_H_
+#define _AsyncArg_H_
+
+#include "MQMessageQueue.h"
+#include "PullAPIWrapper.h"
+#include "SubscriptionData.h"
+
+namespace rocketmq {
+//<!***************************************************************************
+
+struct AsyncArg {
+  MQMessageQueue mq;
+  SubscriptionData subData;
+  PullAPIWrapper* pPullWrapper;
+};
+
+//<!***************************************************************************
+}  // namespace rocketmq
+#endif  //<! _AsyncArg_H_
diff --git a/src/common/AsyncCallbackWrap.h b/src/common/AsyncCallbackWrap.h
index 8802fdb..32a752f 100644
--- a/src/common/AsyncCallbackWrap.h
+++ b/src/common/AsyncCallbackWrap.h
@@ -27,7 +27,7 @@ namespace rocketmq {
 
 class ResponseFuture;
 class MQClientAPIImpl;
-class DefaultMQProducer;
+// class DefaultMQProducer;
 //<!***************************************************************************
 enum asyncCallBackType { asyncCallbackWrap = 0, sendCallbackWrap = 1, pullCallbackWrap = 2 };
 
diff --git a/src/common/ByteOrder.h b/src/common/ByteOrder.h
index 2ecb6ab..16a5184 100644
--- a/src/common/ByteOrder.h
+++ b/src/common/ByteOrder.h
@@ -1,19 +1,19 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
-* contributor license agreements.  See the NOTICE file distributed with
-* this work for additional information regarding copyright ownership.
-* The ASF licenses this file to You under the Apache License, Version 2.0
-* (the "License"); you may not use this file except in compliance with
-* the License.  You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 #ifndef BYTEORDER_H_INCLUDED
 #define BYTEORDER_H_INCLUDED
 
@@ -213,5 +213,5 @@ inline void ByteOrder::bigEndian24BitToChars(const int value, void* const destBy
   static_cast<uint8*>(destBytes)[1] = (uint8)(value >> 8);
   static_cast<uint8*>(destBytes)[2] = (uint8)value;
 }
-}
+}  // namespace rocketmq
 #endif  // BYTEORDER_H_INCLUDED
diff --git a/src/common/ClientRPCHook.cpp b/src/common/ClientRPCHook.cpp
index cd216d1..fc013da 100644
--- a/src/common/ClientRPCHook.cpp
+++ b/src/common/ClientRPCHook.cpp
@@ -72,4 +72,4 @@ void ClientRPCHook::doBeforeRequest(const string& remoteAddr, RemotingCommand& r
     LOG_ERROR("signature for request failed");
   }
 }
-}
+}  // namespace rocketmq
diff --git a/src/common/ClientRPCHook.h b/src/common/ClientRPCHook.h
index 72e2f76..52fef30 100644
--- a/src/common/ClientRPCHook.h
+++ b/src/common/ClientRPCHook.h
@@ -41,5 +41,5 @@ class ClientRPCHook : public RPCHook {
 
   virtual void doAfterResponse(RemotingCommand& request, RemotingCommand& response) {}
 };
-}
+}  // namespace rocketmq
 #endif
diff --git a/src/common/CommunicationMode.h b/src/common/CommunicationMode.h
index 6ba947a..b2cb601 100644
--- a/src/common/CommunicationMode.h
+++ b/src/common/CommunicationMode.h
@@ -23,5 +23,5 @@ namespace rocketmq {
 enum CommunicationMode { ComMode_SYNC, ComMode_ASYNC, ComMode_ONEWAY };
 
 //<!***************************************************************************
-}  //<!end namespace;
+}  // namespace rocketmq
 #endif
diff --git a/src/common/MQClient.cpp b/src/common/DefaultMQClient.cpp
similarity index 64%
rename from src/common/MQClient.cpp
rename to src/common/DefaultMQClient.cpp
index f638f6f..aad0981 100644
--- a/src/common/MQClient.cpp
+++ b/src/common/DefaultMQClient.cpp
@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-#include "MQClient.h"
+#include "include/DefaultMQClient.h"
 #include "Logging.h"
 #include "MQClientFactory.h"
 #include "MQClientManager.h"
@@ -31,7 +31,7 @@ namespace rocketmq {
 const char* rocketmq_build_time = "VERSION: " ROCKETMQCPP_VERSION ", BUILD DATE: " BUILD_DATE " ";
 
 //<!************************************************************************
-MQClient::MQClient() {
+DefaultMQClient::DefaultMQClient() {
   string NAMESRV_ADDR_ENV = "NAMESRV_ADDR";
   if (const char* addr = getenv(NAMESRV_ADDR_ENV.c_str()))
     m_namesrvAddr = addr;
@@ -48,9 +48,9 @@ MQClient::MQClient() {
   m_unitName = "";
 }
 
-MQClient::~MQClient() {}
+DefaultMQClient::~DefaultMQClient() {}
 
-string MQClient::getMQClientId() const {
+string DefaultMQClient::getMQClientId() const {
   string clientIP = UtilAll::getLocalAddress();
   string processId = UtilAll::to_string(getpid());
   // return processId + "-" + clientIP + "@" + m_instanceName;
@@ -58,45 +58,45 @@ string MQClient::getMQClientId() const {
 }
 
 //<!groupName;
-const string& MQClient::getGroupName() const {
+const string& DefaultMQClient::getGroupName() const {
   return m_GroupName;
 }
 
-void MQClient::setGroupName(const string& groupname) {
+void DefaultMQClient::setGroupName(const string& groupname) {
   m_GroupName = groupname;
 }
 
-const string& MQClient::getNamesrvAddr() const {
+const string& DefaultMQClient::getNamesrvAddr() const {
   return m_namesrvAddr;
 }
 
-void MQClient::setNamesrvAddr(const string& namesrvAddr) {
+void DefaultMQClient::setNamesrvAddr(const string& namesrvAddr) {
   m_namesrvAddr = NameSpaceUtil::formatNameServerURL(namesrvAddr);
 }
 
-const string& MQClient::getNamesrvDomain() const {
+const string& DefaultMQClient::getNamesrvDomain() const {
   return m_namesrvDomain;
 }
 
-void MQClient::setNamesrvDomain(const string& namesrvDomain) {
+void DefaultMQClient::setNamesrvDomain(const string& namesrvDomain) {
   m_namesrvDomain = namesrvDomain;
 }
 
-const string& MQClient::getInstanceName() const {
+const string& DefaultMQClient::getInstanceName() const {
   return m_instanceName;
 }
 
-void MQClient::setInstanceName(const string& instanceName) {
+void DefaultMQClient::setInstanceName(const string& instanceName) {
   m_instanceName = instanceName;
 }
-const string& MQClient::getNameSpace() const {
+const string& DefaultMQClient::getNameSpace() const {
   return m_nameSpace;
 }
 
-void MQClient::setNameSpace(const string& nameSpace) {
+void DefaultMQClient::setNameSpace(const string& nameSpace) {
   m_nameSpace = nameSpace;
 }
-void MQClient::createTopic(const string& key, const string& newTopic, int queueNum) {
+void DefaultMQClient::createTopic(const string& key, const string& newTopic, int queueNum) {
   try {
     getFactory()->createTopic(key, newTopic, queueNum, m_SessionCredentials);
   } catch (MQException& e) {
@@ -104,31 +104,31 @@ void MQClient::createTopic(const string& key, const string& newTopic, int queueN
   }
 }
 
-int64 MQClient::earliestMsgStoreTime(const MQMessageQueue& mq) {
+int64 DefaultMQClient::earliestMsgStoreTime(const MQMessageQueue& mq) {
   return getFactory()->earliestMsgStoreTime(mq, m_SessionCredentials);
 }
 
-QueryResult MQClient::queryMessage(const string& topic, const string& key, int maxNum, int64 begin, int64 end) {
+QueryResult DefaultMQClient::queryMessage(const string& topic, const string& key, int maxNum, int64 begin, int64 end) {
   return getFactory()->queryMessage(topic, key, maxNum, begin, end, m_SessionCredentials);
 }
 
-int64 MQClient::minOffset(const MQMessageQueue& mq) {
+int64 DefaultMQClient::minOffset(const MQMessageQueue& mq) {
   return getFactory()->minOffset(mq, m_SessionCredentials);
 }
 
-int64 MQClient::maxOffset(const MQMessageQueue& mq) {
+int64 DefaultMQClient::maxOffset(const MQMessageQueue& mq) {
   return getFactory()->maxOffset(mq, m_SessionCredentials);
 }
 
-int64 MQClient::searchOffset(const MQMessageQueue& mq, uint64_t timestamp) {
+int64 DefaultMQClient::searchOffset(const MQMessageQueue& mq, uint64_t timestamp) {
   return getFactory()->searchOffset(mq, timestamp, m_SessionCredentials);
 }
 
-MQMessageExt* MQClient::viewMessage(const string& msgId) {
+MQMessageExt* DefaultMQClient::viewMessage(const string& msgId) {
   return getFactory()->viewMessage(msgId, m_SessionCredentials);
 }
 
-vector<MQMessageQueue> MQClient::getTopicMessageQueueInfo(const string& topic) {
+vector<MQMessageQueue> DefaultMQClient::getTopicMessageQueueInfo(const string& topic) {
   boost::weak_ptr<TopicPublishInfo> weak_topicPublishInfo(
       getFactory()->tryToFindTopicPublishInfo(topic, m_SessionCredentials));
   boost::shared_ptr<TopicPublishInfo> topicPublishInfo(weak_topicPublishInfo.lock());
@@ -138,7 +138,7 @@ vector<MQMessageQueue> MQClient::getTopicMessageQueueInfo(const string& topic) {
   THROW_MQEXCEPTION(MQClientException, "could not find MessageQueue Info of topic: [" + topic + "].", -1);
 }
 
-void MQClient::start() {
+void DefaultMQClient::start() {
   if (getFactory() == NULL) {
     m_clientFactory = MQClientManager::getInstance()->getMQClientFactory(
         getMQClientId(), m_pullThreadNum, m_tcpConnectTimeout, m_tcpTransportTryLockTimeout, m_unitName);
@@ -149,74 +149,74 @@ void MQClient::start() {
       getGroupName().c_str(), getMQClientId().c_str(), getInstanceName().c_str(), getNamesrvAddr().c_str());
 }
 
-void MQClient::shutdown() {
+void DefaultMQClient::shutdown() {
   m_clientFactory->shutdown();
   m_clientFactory = NULL;
 }
 
-MQClientFactory* MQClient::getFactory() const {
+MQClientFactory* DefaultMQClient::getFactory() const {
   return m_clientFactory;
 }
 
-bool MQClient::isServiceStateOk() {
+bool DefaultMQClient::isServiceStateOk() {
   return m_serviceState == RUNNING;
 }
 
-void MQClient::setLogLevel(elogLevel inputLevel) {
+void DefaultMQClient::setLogLevel(elogLevel inputLevel) {
   ALOG_ADAPTER->setLogLevel(inputLevel);
 }
 
-elogLevel MQClient::getLogLevel() {
+elogLevel DefaultMQClient::getLogLevel() {
   return ALOG_ADAPTER->getLogLevel();
 }
 
-void MQClient::setLogFileSizeAndNum(int fileNum, long perFileSize) {
+void DefaultMQClient::setLogFileSizeAndNum(int fileNum, long perFileSize) {
   ALOG_ADAPTER->setLogFileNumAndSize(fileNum, perFileSize);
 }
 
-void MQClient::setTcpTransportPullThreadNum(int num) {
+void DefaultMQClient::setTcpTransportPullThreadNum(int num) {
   if (num > m_pullThreadNum) {
     m_pullThreadNum = num;
   }
 }
 
-const int MQClient::getTcpTransportPullThreadNum() const {
+const int DefaultMQClient::getTcpTransportPullThreadNum() const {
   return m_pullThreadNum;
 }
 
-void MQClient::setTcpTransportConnectTimeout(uint64_t timeout) {
+void DefaultMQClient::setTcpTransportConnectTimeout(uint64_t timeout) {
   m_tcpConnectTimeout = timeout;
 }
-const uint64_t MQClient::getTcpTransportConnectTimeout() const {
+const uint64_t DefaultMQClient::getTcpTransportConnectTimeout() const {
   return m_tcpConnectTimeout;
 }
 
-void MQClient::setTcpTransportTryLockTimeout(uint64_t timeout) {
+void DefaultMQClient::setTcpTransportTryLockTimeout(uint64_t timeout) {
   if (timeout < 1000) {
     timeout = 1000;
   }
   m_tcpTransportTryLockTimeout = timeout / 1000;
 }
-const uint64_t MQClient::getTcpTransportTryLockTimeout() const {
+const uint64_t DefaultMQClient::getTcpTransportTryLockTimeout() const {
   return m_tcpTransportTryLockTimeout;
 }
 
-void MQClient::setUnitName(string unitName) {
+void DefaultMQClient::setUnitName(string unitName) {
   m_unitName = unitName;
 }
-const string& MQClient::getUnitName() {
+const string& DefaultMQClient::getUnitName() const {
   return m_unitName;
 }
 
-void MQClient::setSessionCredentials(const string& input_accessKey,
-                                     const string& input_secretKey,
-                                     const string& input_onsChannel) {
+void DefaultMQClient::setSessionCredentials(const string& input_accessKey,
+                                            const string& input_secretKey,
+                                            const string& input_onsChannel) {
   m_SessionCredentials.setAccessKey(input_accessKey);
   m_SessionCredentials.setSecretKey(input_secretKey);
   m_SessionCredentials.setAuthChannel(input_onsChannel);
 }
 
-const SessionCredentials& MQClient::getSessionCredentials() const {
+const SessionCredentials& DefaultMQClient::getSessionCredentials() const {
   return m_SessionCredentials;
 }
 
diff --git a/src/common/FilterAPI.h b/src/common/FilterAPI.h
index d632bc2..77255ba 100644
--- a/src/common/FilterAPI.h
+++ b/src/common/FilterAPI.h
@@ -57,5 +57,5 @@ class FilterAPI {
 };
 
 //<!***************************************************************************
-}  //<!end namespace;
+}  // namespace rocketmq
 #endif
diff --git a/src/common/InputStream.cpp b/src/common/InputStream.cpp
index f807d6b..dbd011a 100644
--- a/src/common/InputStream.cpp
+++ b/src/common/InputStream.cpp
@@ -1,19 +1,19 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
-* contributor license agreements.  See the NOTICE file distributed with
-* this work for additional information regarding copyright ownership.
-* The ASF licenses this file to You under the Apache License, Version 2.0
-* (the "License"); you may not use this file except in compliance with
-* the License.  You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 #include "InputStream.h"
 #include <algorithm>
 #include "MemoryOutputStream.h"
@@ -108,4 +108,4 @@ void InputStream::skipNextBytes(int64 numBytesToSkip) {
     std::free(temp);
   }
 }
-}
+}  // namespace rocketmq
diff --git a/src/common/InputStream.h b/src/common/InputStream.h
index 8c6ddb5..8cf1b84 100644
--- a/src/common/InputStream.h
+++ b/src/common/InputStream.h
@@ -1,19 +1,19 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
-* contributor license agreements.  See the NOTICE file distributed with
-* this work for additional information regarding copyright ownership.
-* The ASF licenses this file to You under the Apache License, Version 2.0
-* (the "License"); you may not use this file except in compliance with
-* the License.  You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 #ifndef INPUTSTREAM_H_INCLUDED
 #define INPUTSTREAM_H_INCLUDED
@@ -190,5 +190,5 @@ class ROCKETMQCLIENT_API InputStream {
   //==============================================================================
   InputStream() {}
 };
-}
+}  // namespace rocketmq
 #endif  // INPUTSTREAM_H_INCLUDED
diff --git a/src/common/MemoryInputStream.cpp b/src/common/MemoryInputStream.cpp
index 3d65992..b857c44 100644
--- a/src/common/MemoryInputStream.cpp
+++ b/src/common/MemoryInputStream.cpp
@@ -1,19 +1,19 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
-* contributor license agreements.  See the NOTICE file distributed with
-* this work for additional information regarding copyright ownership.
-* The ASF licenses this file to You under the Apache License, Version 2.0
-* (the "License"); you may not use this file except in compliance with
-* the License.  You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 #include "MemoryInputStream.h"
 
 namespace rocketmq {
@@ -72,4 +72,4 @@ bool MemoryInputStream::setPosition(const int64 pos) {
 int64 MemoryInputStream::getPosition() {
   return (int64)position;
 }
-}
+}  // namespace rocketmq
diff --git a/src/common/MemoryInputStream.h b/src/common/MemoryInputStream.h
index 53584b9..2d3a365 100644
--- a/src/common/MemoryInputStream.h
+++ b/src/common/MemoryInputStream.h
@@ -1,19 +1,19 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
-* contributor license agreements.  See the NOTICE file distributed with
-* this work for additional information regarding copyright ownership.
-* The ASF licenses this file to You under the Apache License, Version 2.0
-* (the "License"); you may not use this file except in compliance with
-* the License.  You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 #ifndef MEMORYINPUTSTREAM_H_INCLUDED
 #define MEMORYINPUTSTREAM_H_INCLUDED
@@ -92,5 +92,5 @@ class ROCKETMQCLIENT_API MemoryInputStream : public InputStream {
 
   void createInternalCopy();
 };
-}
+}  // namespace rocketmq
 #endif
diff --git a/src/common/MemoryOutputStream.cpp b/src/common/MemoryOutputStream.cpp
index 9578c8a..d7366f5 100644
--- a/src/common/MemoryOutputStream.cpp
+++ b/src/common/MemoryOutputStream.cpp
@@ -1,19 +1,19 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
-* contributor license agreements.  See the NOTICE file distributed with
-* this work for additional information regarding copyright ownership.
-* The ASF licenses this file to You under the Apache License, Version 2.0
-* (the "License"); you may not use this file except in compliance with
-* the License.  You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 #include "MemoryOutputStream.h"
 
 namespace rocketmq {
@@ -153,4 +153,4 @@ OutputStream& operator<<(OutputStream& stream, const MemoryOutputStream& streamT
 
   return stream;
 }
-}
+}  // namespace rocketmq
diff --git a/src/common/MemoryOutputStream.h b/src/common/MemoryOutputStream.h
index 4b39879..cc3245a 100644
--- a/src/common/MemoryOutputStream.h
+++ b/src/common/MemoryOutputStream.h
@@ -1,19 +1,19 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
-* contributor license agreements.  See the NOTICE file distributed with
-* this work for additional information regarding copyright ownership.
-* The ASF licenses this file to You under the Apache License, Version 2.0
-* (the "License"); you may not use this file except in compliance with
-* the License.  You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 #ifndef MEMORYOUTPUTSTREAM_H_INCLUDED
 #define MEMORYOUTPUTSTREAM_H_INCLUDED
@@ -126,5 +126,5 @@ class ROCKETMQCLIENT_API MemoryOutputStream : public OutputStream {
 /** Copies all the data that has been written to a MemoryOutputStream into
  * another stream. */
 OutputStream& operator<<(OutputStream& stream, const MemoryOutputStream& streamToRead);
-}
+}  // namespace rocketmq
 #endif  // MEMORYOUTPUTSTREAM_H_INCLUDED
diff --git a/src/common/MessageSysFlag.cpp b/src/common/MessageSysFlag.cpp
index 50a28b4..732f1d5 100644
--- a/src/common/MessageSysFlag.cpp
+++ b/src/common/MessageSysFlag.cpp
@@ -34,4 +34,4 @@ int MessageSysFlag::resetTransactionValue(int flag, int type) {
 }
 
 //<!***************************************************************************
-}  //<!end namespace;
+}  // namespace rocketmq
diff --git a/src/common/MessageSysFlag.h b/src/common/MessageSysFlag.h
index d7f7993..3652d23 100644
--- a/src/common/MessageSysFlag.h
+++ b/src/common/MessageSysFlag.h
@@ -34,5 +34,5 @@ class MessageSysFlag {
 };
 
 //<!***************************************************************************
-}  //<!end namespace;
+}  // namespace rocketmq
 #endif
diff --git a/src/common/OutputStream.cpp b/src/common/OutputStream.cpp
index 2a056d3..78b60c4 100644
--- a/src/common/OutputStream.cpp
+++ b/src/common/OutputStream.cpp
@@ -1,19 +1,19 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
-* contributor license agreements.  See the NOTICE file distributed with
-* this work for additional information regarding copyright ownership.
-* The ASF licenses this file to You under the Apache License, Version 2.0
-* (the "License"); you may not use this file except in compliance with
-* the License.  You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 #include "OutputStream.h"
 #include <limits>
 #include "big_endian.h"
@@ -101,4 +101,4 @@ int64 OutputStream::writeFromInputStream(InputStream& source, int64 numBytesToWr
 
   return numWritten;
 }
-}
+}  // namespace rocketmq
diff --git a/src/common/OutputStream.h b/src/common/OutputStream.h
index 3792169..6dd459d 100644
--- a/src/common/OutputStream.h
+++ b/src/common/OutputStream.h
@@ -1,19 +1,19 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
-* contributor license agreements.  See the NOTICE file distributed with
-* this work for additional information regarding copyright ownership.
-* The ASF licenses this file to You under the Apache License, Version 2.0
-* (the "License"); you may not use this file except in compliance with
-* the License.  You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 #ifndef OUTPUTSTREAM_H_INCLUDED
 #define OUTPUTSTREAM_H_INCLUDED
@@ -143,6 +143,6 @@ class ROCKETMQCLIENT_API OutputStream {
   */
   virtual int64 writeFromInputStream(InputStream& source, int64 maxNumBytesToWrite);
 };
-}
+}  // namespace rocketmq
 
 #endif  // OUTPUTSTREAM_H_INCLUDED
diff --git a/src/common/PermName.cpp b/src/common/PermName.cpp
index bd36bfc..7484cc6 100644
--- a/src/common/PermName.cpp
+++ b/src/common/PermName.cpp
@@ -54,4 +54,4 @@ string PermName::perm2String(int perm) {
 }
 
 //<!***************************************************************************
-}  //<!end namespace;
+}  // namespace rocketmq
diff --git a/src/common/PermName.h b/src/common/PermName.h
index 6556382..8b6f23b 100644
--- a/src/common/PermName.h
+++ b/src/common/PermName.h
@@ -35,5 +35,5 @@ class PermName {
 };
 
 //<!***************************************************************************
-}  //<!end namespace;
+}  // namespace rocketmq
 #endif
diff --git a/src/common/PullSysFlag.cpp b/src/common/PullSysFlag.cpp
index a4af97a..cb26dac 100644
--- a/src/common/PullSysFlag.cpp
+++ b/src/common/PullSysFlag.cpp
@@ -66,4 +66,4 @@ bool PullSysFlag::hasClassFilterFlag(int sysFlag) {
 }
 
 //<!***************************************************************************
-}  //<!end namespace;
+}  // namespace rocketmq
diff --git a/src/common/PullSysFlag.h b/src/common/PullSysFlag.h
index 37fcd89..d439d7d 100644
--- a/src/common/PullSysFlag.h
+++ b/src/common/PullSysFlag.h
@@ -36,5 +36,5 @@ class PullSysFlag {
 };
 
 //<!***************************************************************************
-}  //<!end namespace;
+}  // namespace rocketmq
 #endif
diff --git a/src/common/ServiceState.h b/src/common/ServiceState.h
index a8ae792..cfa7bc6 100644
--- a/src/common/ServiceState.h
+++ b/src/common/ServiceState.h
@@ -21,5 +21,5 @@ namespace rocketmq {
 enum ServiceState { CREATE_JUST, RUNNING, SHUTDOWN_ALREADY, START_FAILED };
 
 //<!***************************************************************************
-}  //<!end namespace;
+}  // namespace rocketmq
 #endif
diff --git a/src/common/SubscriptionGroupConfig.h b/src/common/SubscriptionGroupConfig.h
index 9a54140..964b64c 100644
--- a/src/common/SubscriptionGroupConfig.h
+++ b/src/common/SubscriptionGroupConfig.h
@@ -45,5 +45,5 @@ class SubscriptionGroupConfig {
 };
 
 //<!***************************************************************************
-}  //<!end namespace;
+}  // namespace rocketmq
 #endif
diff --git a/src/common/TopAddressing.cpp b/src/common/TopAddressing.cpp
index 41f7b72..9d94c43 100644
--- a/src/common/TopAddressing.cpp
+++ b/src/common/TopAddressing.cpp
@@ -102,4 +102,4 @@ string TopAddressing::clearNewLine(const string& str) {
 
   return newString;
 }
-}  //<!end namespace;
+}  // namespace rocketmq
diff --git a/src/common/TopicConfig.cpp b/src/common/TopicConfig.cpp
index 9f01199..38ea138 100644
--- a/src/common/TopicConfig.cpp
+++ b/src/common/TopicConfig.cpp
@@ -111,4 +111,4 @@ void TopicConfig::setTopicFilterType(TopicFilterType topicFilterType) {
   m_topicFilterType = topicFilterType;
 }
 //<!***************************************************************************
-}  //<!end namespace;
+}  // namespace rocketmq
diff --git a/src/common/TopicConfig.h b/src/common/TopicConfig.h
index 32178c9..cfdc785 100644
--- a/src/common/TopicConfig.h
+++ b/src/common/TopicConfig.h
@@ -56,5 +56,5 @@ class TopicConfig {
   TopicFilterType m_topicFilterType;
 };
 //<!***************************************************************************
-}  //<!end namespace;
+}  // namespace rocketmq
 #endif
diff --git a/src/common/TopicFilterType.h b/src/common/TopicFilterType.h
index 9055003..055d112 100644
--- a/src/common/TopicFilterType.h
+++ b/src/common/TopicFilterType.h
@@ -30,5 +30,5 @@ enum TopicFilterType {
   MULTI_TAG
 };
 //<!***************************************************************************
-}  //<!end namespace;
+}  // namespace rocketmq
 #endif
diff --git a/src/common/UtilAll.cpp b/src/common/UtilAll.cpp
index df3ec0b..c2f9563 100644
--- a/src/common/UtilAll.cpp
+++ b/src/common/UtilAll.cpp
@@ -353,4 +353,4 @@ bool UtilAll::ReplaceFile(const std::string& from_path, const std::string& to_pa
   return false;
 #endif
 }
-}
+}  // namespace rocketmq
diff --git a/src/common/UtilAll.h b/src/common/UtilAll.h
index 98fc906..a2993cf 100644
--- a/src/common/UtilAll.h
+++ b/src/common/UtilAll.h
@@ -139,5 +139,5 @@ class UtilAll {
   static std::string s_localIpAddress;
 };
 //<!***************************************************************************
-}  //<!end namespace;
+}  // namespace rocketmq
 #endif
diff --git a/src/common/Validators.cpp b/src/common/Validators.cpp
index 8743a20..5a7594b 100644
--- a/src/common/Validators.cpp
+++ b/src/common/Validators.cpp
@@ -101,4 +101,4 @@ void Validators::checkMessage(const MQMessage& msg, int maxMessageSize) {
 }
 
 //<!***************************************************************************
-}  //<!end namespace;
+}  // namespace rocketmq
diff --git a/src/common/Validators.h b/src/common/Validators.h
index cc03fb5..c59f1bf 100644
--- a/src/common/Validators.h
+++ b/src/common/Validators.h
@@ -37,5 +37,5 @@ class Validators {
 };
 
 //<!***************************************************************************
-}  //<!end namespace;
+}  // namespace rocketmq
 #endif
diff --git a/src/common/VirtualEnvUtil.h b/src/common/VirtualEnvUtil.h
index 7edc4eb..26ae898 100644
--- a/src/common/VirtualEnvUtil.h
+++ b/src/common/VirtualEnvUtil.h
@@ -30,5 +30,5 @@ class VirtualEnvUtil {
 };
 
 //<!***************************************************************************
-}  //<!end namespace;
+}  // namespace rocketmq
 #endif
diff --git a/src/common/big_endian.cpp b/src/common/big_endian.cpp
index abb4a97..52c48c0 100644
--- a/src/common/big_endian.cpp
+++ b/src/common/big_endian.cpp
@@ -93,4 +93,4 @@ bool BigEndianWriter::WriteU64(uint64_t value) {
   return Write(value);
 }
 
-}  // namespace base
+}  // namespace rocketmq
diff --git a/src/common/big_endian.h b/src/common/big_endian.h
index b7729e5..57077ee 100644
--- a/src/common/big_endian.h
+++ b/src/common/big_endian.h
@@ -97,6 +97,6 @@ class BigEndianWriter {
   char* end_;
 };
 
-}  // namespace base
+}  // namespace rocketmq
 
 #endif  // BASE_BIG_ENDIAN_H_
diff --git a/src/common/dataBlock.cpp b/src/common/dataBlock.cpp
index daca4e4..87e98af 100644
--- a/src/common/dataBlock.cpp
+++ b/src/common/dataBlock.cpp
@@ -1,19 +1,19 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
-* contributor license agreements.  See the NOTICE file distributed with
-* this work for additional information regarding copyright ownership.
-* The ASF licenses this file to You under the Apache License, Version 2.0
-* (the "License"); you may not use this file except in compliance with
-* the License.  You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 #include "dataBlock.h"
 #include <algorithm>
 
@@ -204,4 +204,4 @@ void MemoryBlock::copyTo(void* const dst, int offset, int num) const {
   if (num > 0)
     memcpy(d, data + offset, num);
 }
-}
+}  // namespace rocketmq
diff --git a/src/common/dataBlock.h b/src/common/dataBlock.h
index 4419af3..7472927 100644
--- a/src/common/dataBlock.h
+++ b/src/common/dataBlock.h
@@ -1,19 +1,19 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
-* contributor license agreements.  See the NOTICE file distributed with
-* this work for additional information regarding copyright ownership.
-* The ASF licenses this file to You under the Apache License, Version 2.0
-* (the "License"); you may not use this file except in compliance with
-* the License.  You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 #ifndef __DATABLOCK_H__
 #define __DATABLOCK_H__
 
@@ -203,6 +203,6 @@ class ROCKETMQCLIENT_API MemoryBlock {
   int size;
   char* data;
 };
-}
+}  // namespace rocketmq
 
 #endif
diff --git a/src/common/sync_http_client.cpp b/src/common/sync_http_client.cpp
index 78f0292..52137b3 100644
--- a/src/common/sync_http_client.cpp
+++ b/src/common/sync_http_client.cpp
@@ -26,9 +26,9 @@
 #include "Logging.h"
 #include "url.h"
 
-using boost::lambda::var;
-using boost::asio::ip::tcp;
 using boost::asio::deadline_timer;
+using boost::asio::ip::tcp;
+using boost::lambda::var;
 
 namespace {
 void check_deadline(deadline_timer* deadline, tcp::socket* socket, const boost::system::error_code& ec) {
@@ -148,4 +148,4 @@ bool SyncfetchNsAddr(const Url& url_s, std::string& body) {
 
   return ret;
 }
-}  // end of namespace ons
+}  // namespace rocketmq
diff --git a/src/common/sync_http_client.h b/src/common/sync_http_client.h
index 9836605..1bf55fa 100644
--- a/src/common/sync_http_client.h
+++ b/src/common/sync_http_client.h
@@ -24,6 +24,6 @@ class Url;
 
 extern bool SyncfetchNsAddr(const Url& url_s, std::string& body);
 
-}  // namespace ons
+}  // namespace rocketmq
 
 #endif  // ROCKETMQ_CLIENT4CPP__SYNC_HTTP_CLIENT_H_
diff --git a/src/common/url.cpp b/src/common/url.cpp
index f8d9155..d632037 100644
--- a/src/common/url.cpp
+++ b/src/common/url.cpp
@@ -62,4 +62,4 @@ void Url::parse(const std::string& url_s) {
   query_.assign(query_i, url_s.end());
 }
 
-}  // namespace ons
+}  // namespace rocketmq
diff --git a/src/common/url.h b/src/common/url.h
index 0fbcb85..62d86a2 100644
--- a/src/common/url.h
+++ b/src/common/url.h
@@ -34,5 +34,5 @@ class Url {
   std::string path_;
   std::string query_;
 };
-}
+}  // namespace rocketmq
 #endif  // ROCKETMQ_CLIENT4CPP_URL_HH_
diff --git a/src/consumer/ConsumeMsgService.h b/src/consumer/ConsumeMsgService.h
index a6c7206..8745bae 100644
--- a/src/consumer/ConsumeMsgService.h
+++ b/src/consumer/ConsumeMsgService.h
@@ -24,12 +24,13 @@
 #include <boost/date_time/posix_time/posix_time.hpp>
 #include <boost/scoped_ptr.hpp>
 #include <boost/thread/thread.hpp>
+#include "DefaultMQPushConsumerImpl.h"
 #include "Logging.h"
+#include "MQConsumer.h"
 #include "MQMessageListener.h"
 #include "PullRequest.h"
-
 namespace rocketmq {
-class MQConsumer;
+// class MQConsumer;
 //<!***************************************************************************
 class ConsumeMsgService {
  public:
diff --git a/src/consumer/DefaultMQPullConsumer.cpp b/src/consumer/DefaultMQPullConsumer.cpp
index 1f58e86..b6998f3 100644
--- a/src/consumer/DefaultMQPullConsumer.cpp
+++ b/src/consumer/DefaultMQPullConsumer.cpp
@@ -16,404 +16,161 @@
  */
 
 #include "DefaultMQPullConsumer.h"
-#include "AsyncArg.h"
-#include "CommunicationMode.h"
-#include "FilterAPI.h"
-#include "Logging.h"
-#include "MQClientFactory.h"
-#include "MessageAccessor.h"
-#include "NameSpaceUtil.h"
-#include "OffsetStore.h"
-#include "PullAPIWrapper.h"
-#include "PullSysFlag.h"
-#include "Rebalance.h"
-#include "Validators.h"
+#include "DefaultMQPullConsumerImpl.h"
 
 namespace rocketmq {
-//<!***************************************************************************
-DefaultMQPullConsumer::DefaultMQPullConsumer(const string& groupname)
-    : m_pMessageQueueListener(NULL),
-      m_pOffsetStore(NULL),
-      m_pRebalance(NULL),
-      m_pPullAPIWrapper(NULL)
 
-{
-  //<!set default group name;
-  string gname = groupname.empty() ? DEFAULT_CONSUMER_GROUP : groupname;
-  setGroupName(gname);
-
-  setMessageModel(CLUSTERING);
+DefaultMQPullConsumer::DefaultMQPullConsumer(const std::string& groupName) {
+  impl = new DefaultMQPullConsumerImpl(groupName);
 }
 
 DefaultMQPullConsumer::~DefaultMQPullConsumer() {
-  m_pMessageQueueListener = NULL;
-  deleteAndZero(m_pRebalance);
-  deleteAndZero(m_pOffsetStore);
-  deleteAndZero(m_pPullAPIWrapper);
+  delete impl;
 }
-
-// MQConsumer
-//<!************************************************************************
 void DefaultMQPullConsumer::start() {
-#ifndef WIN32
-  /* Ignore the SIGPIPE */
-  struct sigaction sa;
-  memset(&sa, 0, sizeof(struct sigaction));
-  sa.sa_handler = SIG_IGN;
-  sa.sa_flags = 0;
-  sigaction(SIGPIPE, &sa, 0);
-#endif
-  dealWithNameSpace();
-  switch (m_serviceState) {
-    case CREATE_JUST: {
-      m_serviceState = START_FAILED;
-      MQClient::start();
-      LOG_INFO("DefaultMQPullConsumer:%s start", m_GroupName.c_str());
-
-      //<!create rebalance;
-      m_pRebalance = new RebalancePull(this, getFactory());
-
-      string groupname = getGroupName();
-      m_pPullAPIWrapper = new PullAPIWrapper(getFactory(), groupname);
-
-      //<!data;
-      checkConfig();
-      copySubscription();
-
-      //<! registe;
-      bool registerOK = getFactory()->registerConsumer(this);
-      if (!registerOK) {
-        m_serviceState = CREATE_JUST;
-        THROW_MQEXCEPTION(
-            MQClientException,
-            "The cousumer group[" + getGroupName() + "] has been created before, specify another name please.", -1);
-      }
-
-      //<!msg model;
-      switch (getMessageModel()) {
-        case BROADCASTING:
-          m_pOffsetStore = new LocalFileOffsetStore(groupname, getFactory());
-          break;
-        case CLUSTERING:
-          m_pOffsetStore = new RemoteBrokerOffsetStore(groupname, getFactory());
-          break;
-      }
-      bool bStartFailed = false;
-      string errorMsg;
-      try {
-        m_pOffsetStore->load();
-      } catch (MQClientException& e) {
-        bStartFailed = true;
-        errorMsg = std::string(e.what());
-      }
-
-      getFactory()->start();
-      m_serviceState = RUNNING;
-      if (bStartFailed) {
-        shutdown();
-        THROW_MQEXCEPTION(MQClientException, errorMsg, -1);
-      }
-      break;
-    }
-    case RUNNING:
-    case START_FAILED:
-    case SHUTDOWN_ALREADY:
-      break;
-    default:
-      break;
-  }
+  impl->start();
 }
 
 void DefaultMQPullConsumer::shutdown() {
-  switch (m_serviceState) {
-    case RUNNING: {
-      LOG_INFO("DefaultMQPullConsumer:%s shutdown", m_GroupName.c_str());
-      persistConsumerOffset();
-      getFactory()->unregisterConsumer(this);
-      getFactory()->shutdown();
-      m_serviceState = SHUTDOWN_ALREADY;
-      break;
-    }
-    case SHUTDOWN_ALREADY:
-    case CREATE_JUST:
-      break;
-    default:
-      break;
-  }
+  impl->shutdown();
 }
 
-bool DefaultMQPullConsumer::sendMessageBack(MQMessageExt& msg, int delayLevel, string& brokerName) {
-  return true;
+// start mqclient set
+const std::string& DefaultMQPullConsumer::getNamesrvAddr() const {
+  return impl->getNamesrvAddr();
 }
 
-void DefaultMQPullConsumer::fetchSubscribeMessageQueues(const string& topic, vector<MQMessageQueue>& mqs) {
-  mqs.clear();
-  try {
-    const string localTopic = NameSpaceUtil::withNameSpace(topic, getNameSpace());
-    getFactory()->fetchSubscribeMessageQueues(localTopic, mqs, getSessionCredentials());
-  } catch (MQException& e) {
-    LOG_ERROR(e.what());
-  }
+void DefaultMQPullConsumer::setNamesrvAddr(const std::string& namesrvAddr) {
+  impl->setNamesrvAddr(namesrvAddr);
 }
 
-void DefaultMQPullConsumer::updateTopicSubscribeInfo(const string& topic, vector<MQMessageQueue>& info) {}
-
-void DefaultMQPullConsumer::registerMessageQueueListener(const string& topic, MQueueListener* pListener) {
-  m_registerTopics.insert(topic);
-  if (pListener) {
-    m_pMessageQueueListener = pListener;
-  }
+const std::string& DefaultMQPullConsumer::getNamesrvDomain() const {
+  return impl->getNamesrvDomain();
 }
 
-PullResult DefaultMQPullConsumer::pull(const MQMessageQueue& mq,
-                                       const string& subExpression,
-                                       int64 offset,
-                                       int maxNums) {
-  return pullSyncImpl(mq, subExpression, offset, maxNums, false);
+void DefaultMQPullConsumer::setNamesrvDomain(const std::string& namesrvDomain) {
+  impl->setNamesrvDomain(namesrvDomain);
 }
-
-void DefaultMQPullConsumer::pull(const MQMessageQueue& mq,
-                                 const string& subExpression,
-                                 int64 offset,
-                                 int maxNums,
-                                 PullCallback* pPullCallback) {
-  pullAsyncImpl(mq, subExpression, offset, maxNums, false, pPullCallback);
+void DefaultMQPullConsumer::setSessionCredentials(const std::string& accessKey,
+                                                  const std::string& secretKey,
+                                                  const std::string& accessChannel) {
+  impl->setSessionCredentials(accessKey, secretKey, accessChannel);
 }
 
-PullResult DefaultMQPullConsumer::pullBlockIfNotFound(const MQMessageQueue& mq,
-                                                      const string& subExpression,
-                                                      int64 offset,
-                                                      int maxNums) {
-  return pullSyncImpl(mq, subExpression, offset, maxNums, true);
+const SessionCredentials& DefaultMQPullConsumer::getSessionCredentials() const {
+  return impl->getSessionCredentials();
 }
-
-void DefaultMQPullConsumer::pullBlockIfNotFound(const MQMessageQueue& mq,
-                                                const string& subExpression,
-                                                int64 offset,
-                                                int maxNums,
-                                                PullCallback* pPullCallback) {
-  pullAsyncImpl(mq, subExpression, offset, maxNums, true, pPullCallback);
+const std::string& DefaultMQPullConsumer::getInstanceName() const {
+  return impl->getInstanceName();
 }
 
-PullResult DefaultMQPullConsumer::pullSyncImpl(const MQMessageQueue& mq,
-                                               const string& subExpression,
-                                               int64 offset,
-                                               int maxNums,
-                                               bool block) {
-  if (offset < 0)
-    THROW_MQEXCEPTION(MQClientException, "offset < 0", -1);
-
-  if (maxNums <= 0)
-    THROW_MQEXCEPTION(MQClientException, "maxNums <= 0", -1);
-
-  //<!auto subscript,all sub;
-  subscriptionAutomatically(mq.getTopic());
-
-  int sysFlag = PullSysFlag::buildSysFlag(false, block, true, false);
-
-  //<!this sub;
-  unique_ptr<SubscriptionData> pSData(FilterAPI::buildSubscriptionData(mq.getTopic(), subExpression));
-
-  int timeoutMillis = block ? 1000 * 30 : 1000 * 10;
-
-  try {
-    unique_ptr<PullResult> pullResult(m_pPullAPIWrapper->pullKernelImpl(mq,                      // 1
-                                                                        pSData->getSubString(),  // 2
-                                                                        0L,                      // 3
-                                                                        offset,                  // 4
-                                                                        maxNums,                 // 5
-                                                                        sysFlag,                 // 6
-                                                                        0,                       // 7
-                                                                        1000 * 20,               // 8
-                                                                        timeoutMillis,           // 9
-                                                                        ComMode_SYNC,            // 10
-                                                                        NULL,                    //<!callback;
-                                                                        getSessionCredentials(), NULL));
-    PullResult pr = m_pPullAPIWrapper->processPullResult(mq, pullResult.get(), pSData.get());
-    if (m_useNameSpaceMode) {
-      MessageAccessor::withoutNameSpace(pr.msgFoundList, m_nameSpace);
-    }
-    return pr;
-  } catch (MQException& e) {
-    LOG_ERROR(e.what());
-  }
-  return PullResult(BROKER_TIMEOUT);
+void DefaultMQPullConsumer::setInstanceName(const std::string& instanceName) {
+  impl->setInstanceName(instanceName);
 }
 
-void DefaultMQPullConsumer::pullAsyncImpl(const MQMessageQueue& mq,
-                                          const string& subExpression,
-                                          int64 offset,
-                                          int maxNums,
-                                          bool block,
-                                          PullCallback* pPullCallback) {
-  if (offset < 0)
-    THROW_MQEXCEPTION(MQClientException, "offset < 0", -1);
-
-  if (maxNums <= 0)
-    THROW_MQEXCEPTION(MQClientException, "maxNums <= 0", -1);
-
-  if (!pPullCallback)
-    THROW_MQEXCEPTION(MQClientException, "pPullCallback is null", -1);
-
-  //<!auto subscript,all sub;
-  subscriptionAutomatically(mq.getTopic());
-
-  int sysFlag = PullSysFlag::buildSysFlag(false, block, true, false);
-
-  //<!this sub;
-  unique_ptr<SubscriptionData> pSData(FilterAPI::buildSubscriptionData(mq.getTopic(), subExpression));
-
-  int timeoutMillis = block ? 1000 * 30 : 1000 * 10;
-
-  //<!�첽����;
-  AsyncArg arg;
-  arg.mq = mq;
-  arg.subData = *pSData;
-  arg.pPullWrapper = m_pPullAPIWrapper;
-
-  try {
-    // not support name space
-    unique_ptr<PullResult> pullResult(m_pPullAPIWrapper->pullKernelImpl(mq,                      // 1
-                                                                        pSData->getSubString(),  // 2
-                                                                        0L,                      // 3
-                                                                        offset,                  // 4
-                                                                        maxNums,                 // 5
-                                                                        sysFlag,                 // 6
-                                                                        0,                       // 7
-                                                                        1000 * 20,               // 8
-                                                                        timeoutMillis,           // 9
-                                                                        ComMode_ASYNC,           // 10
-                                                                        pPullCallback, getSessionCredentials(), &arg));
-  } catch (MQException& e) {
-    LOG_ERROR(e.what());
-  }
+const std::string& DefaultMQPullConsumer::getNameSpace() const {
+  return impl->getNameSpace();
 }
 
-void DefaultMQPullConsumer::subscriptionAutomatically(const string& topic) {
-  SubscriptionData* pSdata = m_pRebalance->getSubscriptionData(topic);
-  if (pSdata == NULL) {
-    unique_ptr<SubscriptionData> subscriptionData(FilterAPI::buildSubscriptionData(topic, SUB_ALL));
-    m_pRebalance->setSubscriptionData(topic, subscriptionData.release());
-  }
+void DefaultMQPullConsumer::setNameSpace(const std::string& nameSpace) {
+  impl->setNameSpace(nameSpace);
 }
-
-void DefaultMQPullConsumer::updateConsumeOffset(const MQMessageQueue& mq, int64 offset) {
-  m_pOffsetStore->updateOffset(mq, offset);
+const std::string& DefaultMQPullConsumer::getGroupName() const {
+  return impl->getGroupName();
 }
 
-void DefaultMQPullConsumer::removeConsumeOffset(const MQMessageQueue& mq) {
-  m_pOffsetStore->removeOffset(mq);
+void DefaultMQPullConsumer::setGroupName(const std::string& groupName) {
+  impl->setGroupName(groupName);
 }
 
-int64 DefaultMQPullConsumer::fetchConsumeOffset(const MQMessageQueue& mq, bool fromStore) {
-  return m_pOffsetStore->readOffset(mq, fromStore ? READ_FROM_STORE : MEMORY_FIRST_THEN_STORE, getSessionCredentials());
+void DefaultMQPullConsumer::setLogLevel(elogLevel inputLevel) {
+  impl->setLogLevel(inputLevel);
 }
 
-void DefaultMQPullConsumer::persistConsumerOffset() {
-  /*As do not execute rebalance for pullConsumer now, requestTable is always
-  empty
-  map<MQMessageQueue, PullRequest*> requestTable =
-  m_pRebalance->getPullRequestTable();
-  map<MQMessageQueue, PullRequest*>::iterator it = requestTable.begin();
-  vector<MQMessageQueue> mqs;
-  for (; it != requestTable.end(); ++it)
-  {
-      if (it->second)
-      {
-          mqs.push_back(it->first);
-      }
-  }
-  m_pOffsetStore->persistAll(mqs);*/
+elogLevel DefaultMQPullConsumer::getLogLevel() {
+  return impl->getLogLevel();
 }
-
-void DefaultMQPullConsumer::persistConsumerOffsetByResetOffset() {}
-
-void DefaultMQPullConsumer::persistConsumerOffset4PullConsumer(const MQMessageQueue& mq) {
-  if (isServiceStateOk()) {
-    m_pOffsetStore->persist(mq, getSessionCredentials());
-  }
+void DefaultMQPullConsumer::setLogFileSizeAndNum(int fileNum, long perFileSize) {
+  impl->setLogFileSizeAndNum(fileNum, perFileSize);
 }
 
-void DefaultMQPullConsumer::fetchMessageQueuesInBalance(const string& topic, vector<MQMessageQueue> mqs) {}
+//    void DefaultMQPullConsumer::setUnitName(std::string unitName) {
+//        impl->setUnitName(unitName);
+//    }
+//    const std::string& DefaultMQPullConsumer::getUnitName() const {
+//        return impl->getUnitName();
+//    }
 
-void DefaultMQPullConsumer::checkConfig() {
-  string groupname = getGroupName();
-  // check consumerGroup
-  Validators::checkGroup(groupname);
-
-  // consumerGroup
-  if (!groupname.compare(DEFAULT_CONSUMER_GROUP)) {
-    THROW_MQEXCEPTION(MQClientException, "consumerGroup can not equal DEFAULT_CONSUMER", -1);
-  }
-
-  if (getMessageModel() != BROADCASTING && getMessageModel() != CLUSTERING) {
-    THROW_MQEXCEPTION(MQClientException, "messageModel is valid ", -1);
-  }
+void DefaultMQPullConsumer::fetchSubscribeMessageQueues(const std::string& topic, std::vector<MQMessageQueue>& mqs) {
+  impl->fetchSubscribeMessageQueues(topic, mqs);
 }
 
-void DefaultMQPullConsumer::doRebalance() {}
-
-void DefaultMQPullConsumer::copySubscription() {
-  set<string>::iterator it = m_registerTopics.begin();
-  for (; it != m_registerTopics.end(); ++it) {
-    unique_ptr<SubscriptionData> subscriptionData(FilterAPI::buildSubscriptionData((*it), SUB_ALL));
-    m_pRebalance->setSubscriptionData((*it), subscriptionData.release());
-  }
+void DefaultMQPullConsumer::persistConsumerOffset() {
+  impl->persistConsumerOffset();
+}
+void DefaultMQPullConsumer::persistConsumerOffsetByResetOffset() {
+  impl->persistConsumerOffsetByResetOffset();
+}
+void DefaultMQPullConsumer::updateTopicSubscribeInfo(const std::string& topic, std::vector<MQMessageQueue>& info) {
+  impl->updateTopicSubscribeInfo(topic, info);
 }
-
 ConsumeType DefaultMQPullConsumer::getConsumeType() {
-  return CONSUME_ACTIVELY;
+  return impl->getConsumeType();
 }
-
 ConsumeFromWhere DefaultMQPullConsumer::getConsumeFromWhere() {
-  return CONSUME_FROM_LAST_OFFSET;
+  return impl->getConsumeFromWhere();
+}
+void DefaultMQPullConsumer::getSubscriptions(std::vector<SubscriptionData>& subData) {
+  impl->getSubscriptions(subData);
+}
+void DefaultMQPullConsumer::updateConsumeOffset(const MQMessageQueue& mq, int64 offset) {
+  impl->updateConsumeOffset(mq, offset);
+}
+void DefaultMQPullConsumer::removeConsumeOffset(const MQMessageQueue& mq) {
+  impl->removeConsumeOffset(mq);
+}
+
+void DefaultMQPullConsumer::registerMessageQueueListener(const std::string& topic, MQueueListener* pListener) {
+  impl->registerMessageQueueListener(topic, pListener);
+}
+PullResult DefaultMQPullConsumer::pull(const MQMessageQueue& mq,
+                                       const std::string& subExpression,
+                                       int64 offset,
+                                       int maxNums) {
+  return impl->pull(mq, subExpression, offset, maxNums);
+}
+void DefaultMQPullConsumer::pull(const MQMessageQueue& mq,
+                                 const std::string& subExpression,
+                                 int64 offset,
+                                 int maxNums,
+                                 PullCallback* pPullCallback) {
+  impl->pull(mq, subExpression, offset, maxNums, pPullCallback);
 }
 
-void DefaultMQPullConsumer::getSubscriptions(vector<SubscriptionData>& result) {
-  set<string>::iterator it = m_registerTopics.begin();
-  for (; it != m_registerTopics.end(); ++it) {
-    SubscriptionData ms(*it, SUB_ALL);
-    result.push_back(ms);
-  }
+PullResult DefaultMQPullConsumer::pullBlockIfNotFound(const MQMessageQueue& mq,
+                                                      const std::string& subExpression,
+                                                      int64 offset,
+                                                      int maxNums) {
+  return impl->pullBlockIfNotFound(mq, subExpression, offset, maxNums);
+}
+void DefaultMQPullConsumer::pullBlockIfNotFound(const MQMessageQueue& mq,
+                                                const std::string& subExpression,
+                                                int64 offset,
+                                                int maxNums,
+                                                PullCallback* pPullCallback) {
+  impl->pullBlockIfNotFound(mq, subExpression, offset, maxNums, pPullCallback);
 }
 
-bool DefaultMQPullConsumer::producePullMsgTask(boost::weak_ptr<PullRequest> pullRequest) {
-  return true;
+int64 DefaultMQPullConsumer::fetchConsumeOffset(const MQMessageQueue& mq, bool fromStore) {
+  return impl->fetchConsumeOffset(mq, fromStore);
 }
 
-Rebalance* DefaultMQPullConsumer::getRebalance() const {
-  return NULL;
-}
-// we should deal with name space before producer start.
-bool DefaultMQPullConsumer::dealWithNameSpace() {
-  string ns = getNameSpace();
-  if (ns.empty()) {
-    string nsAddr = getNamesrvAddr();
-    if (!NameSpaceUtil::checkNameSpaceExistInNameServer(nsAddr)) {
-      return true;
-    }
-    ns = NameSpaceUtil::getNameSpaceFromNsURL(nsAddr);
-    // reset namespace
-    setNameSpace(ns);
-  }
-  // reset group name
-  if (!NameSpaceUtil::hasNameSpace(getGroupName(), ns)) {
-    string fullGID = NameSpaceUtil::withNameSpace(getGroupName(), ns);
-    setGroupName(fullGID);
-  }
-  set<string> tmpTopics;
-  for (auto iter = m_registerTopics.begin(); iter != m_registerTopics.end(); iter++) {
-    string topic = *iter;
-    if (!NameSpaceUtil::hasNameSpace(topic, ns)) {
-      LOG_INFO("Update Subscribe Topic[%s] with NameSpace:%s", topic.c_str(), ns.c_str());
-      topic = NameSpaceUtil::withNameSpace(topic, ns);
-      // let other mode to known, the name space model opened.
-      m_useNameSpaceMode = true;
-    }
-    tmpTopics.insert(topic);
-  }
-  m_registerTopics.swap(tmpTopics);
-  return true;
+void DefaultMQPullConsumer::fetchMessageQueuesInBalance(const std::string& topic, std::vector<MQMessageQueue> mqs) {
+  impl->fetchMessageQueuesInBalance(topic, mqs);
 }
+void DefaultMQPullConsumer::persistConsumerOffset4PullConsumer(const MQMessageQueue& mq) {
+  // impl->persistConsumerOffsetByResetOffset(mq);
+}
+
 //<!************************************************************************
 }  // namespace rocketmq
diff --git a/src/consumer/DefaultMQPullConsumer.cpp b/src/consumer/DefaultMQPullConsumerImpl.cpp
similarity index 73%
copy from src/consumer/DefaultMQPullConsumer.cpp
copy to src/consumer/DefaultMQPullConsumerImpl.cpp
index 1f58e86..6408842 100644
--- a/src/consumer/DefaultMQPullConsumer.cpp
+++ b/src/consumer/DefaultMQPullConsumerImpl.cpp
@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-#include "DefaultMQPullConsumer.h"
+#include "DefaultMQPullConsumerImpl.h"
 #include "AsyncArg.h"
 #include "CommunicationMode.h"
 #include "FilterAPI.h"
@@ -31,7 +31,7 @@
 
 namespace rocketmq {
 //<!***************************************************************************
-DefaultMQPullConsumer::DefaultMQPullConsumer(const string& groupname)
+DefaultMQPullConsumerImpl::DefaultMQPullConsumerImpl(const string& groupname)
     : m_pMessageQueueListener(NULL),
       m_pOffsetStore(NULL),
       m_pRebalance(NULL),
@@ -45,7 +45,7 @@ DefaultMQPullConsumer::DefaultMQPullConsumer(const string& groupname)
   setMessageModel(CLUSTERING);
 }
 
-DefaultMQPullConsumer::~DefaultMQPullConsumer() {
+DefaultMQPullConsumerImpl::~DefaultMQPullConsumerImpl() {
   m_pMessageQueueListener = NULL;
   deleteAndZero(m_pRebalance);
   deleteAndZero(m_pOffsetStore);
@@ -54,7 +54,7 @@ DefaultMQPullConsumer::~DefaultMQPullConsumer() {
 
 // MQConsumer
 //<!************************************************************************
-void DefaultMQPullConsumer::start() {
+void DefaultMQPullConsumerImpl::start() {
 #ifndef WIN32
   /* Ignore the SIGPIPE */
   struct sigaction sa;
@@ -67,8 +67,8 @@ void DefaultMQPullConsumer::start() {
   switch (m_serviceState) {
     case CREATE_JUST: {
       m_serviceState = START_FAILED;
-      MQClient::start();
-      LOG_INFO("DefaultMQPullConsumer:%s start", m_GroupName.c_str());
+      DefaultMQClient::start();
+      LOG_INFO("DefaultMQPullConsumerImpl:%s start", m_GroupName.c_str());
 
       //<!create rebalance;
       m_pRebalance = new RebalancePull(this, getFactory());
@@ -124,10 +124,10 @@ void DefaultMQPullConsumer::start() {
   }
 }
 
-void DefaultMQPullConsumer::shutdown() {
+void DefaultMQPullConsumerImpl::shutdown() {
   switch (m_serviceState) {
     case RUNNING: {
-      LOG_INFO("DefaultMQPullConsumer:%s shutdown", m_GroupName.c_str());
+      LOG_INFO("DefaultMQPullConsumerImpl:%s shutdown", m_GroupName.c_str());
       persistConsumerOffset();
       getFactory()->unregisterConsumer(this);
       getFactory()->shutdown();
@@ -142,11 +142,11 @@ void DefaultMQPullConsumer::shutdown() {
   }
 }
 
-bool DefaultMQPullConsumer::sendMessageBack(MQMessageExt& msg, int delayLevel, string& brokerName) {
+bool DefaultMQPullConsumerImpl::sendMessageBack(MQMessageExt& msg, int delayLevel, string& brokerName) {
   return true;
 }
 
-void DefaultMQPullConsumer::fetchSubscribeMessageQueues(const string& topic, vector<MQMessageQueue>& mqs) {
+void DefaultMQPullConsumerImpl::fetchSubscribeMessageQueues(const string& topic, vector<MQMessageQueue>& mqs) {
   mqs.clear();
   try {
     const string localTopic = NameSpaceUtil::withNameSpace(topic, getNameSpace());
@@ -156,50 +156,50 @@ void DefaultMQPullConsumer::fetchSubscribeMessageQueues(const string& topic, vec
   }
 }
 
-void DefaultMQPullConsumer::updateTopicSubscribeInfo(const string& topic, vector<MQMessageQueue>& info) {}
+void DefaultMQPullConsumerImpl::updateTopicSubscribeInfo(const string& topic, vector<MQMessageQueue>& info) {}
 
-void DefaultMQPullConsumer::registerMessageQueueListener(const string& topic, MQueueListener* pListener) {
+void DefaultMQPullConsumerImpl::registerMessageQueueListener(const string& topic, MQueueListener* pListener) {
   m_registerTopics.insert(topic);
   if (pListener) {
     m_pMessageQueueListener = pListener;
   }
 }
 
-PullResult DefaultMQPullConsumer::pull(const MQMessageQueue& mq,
-                                       const string& subExpression,
-                                       int64 offset,
-                                       int maxNums) {
+PullResult DefaultMQPullConsumerImpl::pull(const MQMessageQueue& mq,
+                                           const string& subExpression,
+                                           int64 offset,
+                                           int maxNums) {
   return pullSyncImpl(mq, subExpression, offset, maxNums, false);
 }
 
-void DefaultMQPullConsumer::pull(const MQMessageQueue& mq,
-                                 const string& subExpression,
-                                 int64 offset,
-                                 int maxNums,
-                                 PullCallback* pPullCallback) {
+void DefaultMQPullConsumerImpl::pull(const MQMessageQueue& mq,
+                                     const string& subExpression,
+                                     int64 offset,
+                                     int maxNums,
+                                     PullCallback* pPullCallback) {
   pullAsyncImpl(mq, subExpression, offset, maxNums, false, pPullCallback);
 }
 
-PullResult DefaultMQPullConsumer::pullBlockIfNotFound(const MQMessageQueue& mq,
-                                                      const string& subExpression,
-                                                      int64 offset,
-                                                      int maxNums) {
+PullResult DefaultMQPullConsumerImpl::pullBlockIfNotFound(const MQMessageQueue& mq,
+                                                          const string& subExpression,
+                                                          int64 offset,
+                                                          int maxNums) {
   return pullSyncImpl(mq, subExpression, offset, maxNums, true);
 }
 
-void DefaultMQPullConsumer::pullBlockIfNotFound(const MQMessageQueue& mq,
-                                                const string& subExpression,
-                                                int64 offset,
-                                                int maxNums,
-                                                PullCallback* pPullCallback) {
+void DefaultMQPullConsumerImpl::pullBlockIfNotFound(const MQMessageQueue& mq,
+                                                    const string& subExpression,
+                                                    int64 offset,
+                                                    int maxNums,
+                                                    PullCallback* pPullCallback) {
   pullAsyncImpl(mq, subExpression, offset, maxNums, true, pPullCallback);
 }
 
-PullResult DefaultMQPullConsumer::pullSyncImpl(const MQMessageQueue& mq,
-                                               const string& subExpression,
-                                               int64 offset,
-                                               int maxNums,
-                                               bool block) {
+PullResult DefaultMQPullConsumerImpl::pullSyncImpl(const MQMessageQueue& mq,
+                                                   const string& subExpression,
+                                                   int64 offset,
+                                                   int maxNums,
+                                                   bool block) {
   if (offset < 0)
     THROW_MQEXCEPTION(MQClientException, "offset < 0", -1);
 
@@ -240,12 +240,12 @@ PullResult DefaultMQPullConsumer::pullSyncImpl(const MQMessageQueue& mq,
   return PullResult(BROKER_TIMEOUT);
 }
 
-void DefaultMQPullConsumer::pullAsyncImpl(const MQMessageQueue& mq,
-                                          const string& subExpression,
-                                          int64 offset,
-                                          int maxNums,
-                                          bool block,
-                                          PullCallback* pPullCallback) {
+void DefaultMQPullConsumerImpl::pullAsyncImpl(const MQMessageQueue& mq,
+                                              const string& subExpression,
+                                              int64 offset,
+                                              int maxNums,
+                                              bool block,
+                                              PullCallback* pPullCallback) {
   if (offset < 0)
     THROW_MQEXCEPTION(MQClientException, "offset < 0", -1);
 
@@ -289,7 +289,7 @@ void DefaultMQPullConsumer::pullAsyncImpl(const MQMessageQueue& mq,
   }
 }
 
-void DefaultMQPullConsumer::subscriptionAutomatically(const string& topic) {
+void DefaultMQPullConsumerImpl::subscriptionAutomatically(const string& topic) {
   SubscriptionData* pSdata = m_pRebalance->getSubscriptionData(topic);
   if (pSdata == NULL) {
     unique_ptr<SubscriptionData> subscriptionData(FilterAPI::buildSubscriptionData(topic, SUB_ALL));
@@ -297,19 +297,19 @@ void DefaultMQPullConsumer::subscriptionAutomatically(const string& topic) {
   }
 }
 
-void DefaultMQPullConsumer::updateConsumeOffset(const MQMessageQueue& mq, int64 offset) {
+void DefaultMQPullConsumerImpl::updateConsumeOffset(const MQMessageQueue& mq, int64 offset) {
   m_pOffsetStore->updateOffset(mq, offset);
 }
 
-void DefaultMQPullConsumer::removeConsumeOffset(const MQMessageQueue& mq) {
+void DefaultMQPullConsumerImpl::removeConsumeOffset(const MQMessageQueue& mq) {
   m_pOffsetStore->removeOffset(mq);
 }
 
-int64 DefaultMQPullConsumer::fetchConsumeOffset(const MQMessageQueue& mq, bool fromStore) {
+int64 DefaultMQPullConsumerImpl::fetchConsumeOffset(const MQMessageQueue& mq, bool fromStore) {
   return m_pOffsetStore->readOffset(mq, fromStore ? READ_FROM_STORE : MEMORY_FIRST_THEN_STORE, getSessionCredentials());
 }
 
-void DefaultMQPullConsumer::persistConsumerOffset() {
+void DefaultMQPullConsumerImpl::persistConsumerOffset() {
   /*As do not execute rebalance for pullConsumer now, requestTable is always
   empty
   map<MQMessageQueue, PullRequest*> requestTable =
@@ -326,17 +326,17 @@ void DefaultMQPullConsumer::persistConsumerOffset() {
   m_pOffsetStore->persistAll(mqs);*/
 }
 
-void DefaultMQPullConsumer::persistConsumerOffsetByResetOffset() {}
+void DefaultMQPullConsumerImpl::persistConsumerOffsetByResetOffset() {}
 
-void DefaultMQPullConsumer::persistConsumerOffset4PullConsumer(const MQMessageQueue& mq) {
+void DefaultMQPullConsumerImpl::persistConsumerOffset4PullConsumer(const MQMessageQueue& mq) {
   if (isServiceStateOk()) {
     m_pOffsetStore->persist(mq, getSessionCredentials());
   }
 }
 
-void DefaultMQPullConsumer::fetchMessageQueuesInBalance(const string& topic, vector<MQMessageQueue> mqs) {}
+void DefaultMQPullConsumerImpl::fetchMessageQueuesInBalance(const string& topic, vector<MQMessageQueue> mqs) {}
 
-void DefaultMQPullConsumer::checkConfig() {
+void DefaultMQPullConsumerImpl::checkConfig() {
   string groupname = getGroupName();
   // check consumerGroup
   Validators::checkGroup(groupname);
@@ -351,9 +351,9 @@ void DefaultMQPullConsumer::checkConfig() {
   }
 }
 
-void DefaultMQPullConsumer::doRebalance() {}
+void DefaultMQPullConsumerImpl::doRebalance() {}
 
-void DefaultMQPullConsumer::copySubscription() {
+void DefaultMQPullConsumerImpl::copySubscription() {
   set<string>::iterator it = m_registerTopics.begin();
   for (; it != m_registerTopics.end(); ++it) {
     unique_ptr<SubscriptionData> subscriptionData(FilterAPI::buildSubscriptionData((*it), SUB_ALL));
@@ -361,15 +361,15 @@ void DefaultMQPullConsumer::copySubscription() {
   }
 }
 
-ConsumeType DefaultMQPullConsumer::getConsumeType() {
+ConsumeType DefaultMQPullConsumerImpl::getConsumeType() {
   return CONSUME_ACTIVELY;
 }
 
-ConsumeFromWhere DefaultMQPullConsumer::getConsumeFromWhere() {
+ConsumeFromWhere DefaultMQPullConsumerImpl::getConsumeFromWhere() {
   return CONSUME_FROM_LAST_OFFSET;
 }
 
-void DefaultMQPullConsumer::getSubscriptions(vector<SubscriptionData>& result) {
+void DefaultMQPullConsumerImpl::getSubscriptions(vector<SubscriptionData>& result) {
   set<string>::iterator it = m_registerTopics.begin();
   for (; it != m_registerTopics.end(); ++it) {
     SubscriptionData ms(*it, SUB_ALL);
@@ -377,15 +377,15 @@ void DefaultMQPullConsumer::getSubscriptions(vector<SubscriptionData>& result) {
   }
 }
 
-bool DefaultMQPullConsumer::producePullMsgTask(boost::weak_ptr<PullRequest> pullRequest) {
+bool DefaultMQPullConsumerImpl::producePullMsgTask(boost::weak_ptr<PullRequest> pullRequest) {
   return true;
 }
 
-Rebalance* DefaultMQPullConsumer::getRebalance() const {
+Rebalance* DefaultMQPullConsumerImpl::getRebalance() const {
   return NULL;
 }
 // we should deal with name space before producer start.
-bool DefaultMQPullConsumer::dealWithNameSpace() {
+bool DefaultMQPullConsumerImpl::dealWithNameSpace() {
   string ns = getNameSpace();
   if (ns.empty()) {
     string nsAddr = getNamesrvAddr();
diff --git a/include/DefaultMQPullConsumer.h b/src/consumer/DefaultMQPullConsumerImpl.h
similarity index 93%
copy from include/DefaultMQPullConsumer.h
copy to src/consumer/DefaultMQPullConsumerImpl.h
index 8e1612d..58d67e1 100644
--- a/include/DefaultMQPullConsumer.h
+++ b/src/consumer/DefaultMQPullConsumerImpl.h
@@ -1,148 +1,148 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef __DEFAULTMQPULLCONSUMER_H__
-#define __DEFAULTMQPULLCONSUMER_H__
-
-#include <set>
-#include <string>
-#include "MQConsumer.h"
-#include "MQMessageQueue.h"
-#include "MQueueListener.h"
-#include "RocketMQClient.h"
-
-namespace rocketmq {
-class Rebalance;
-class SubscriptionData;
-class OffsetStore;
-class PullAPIWrapper;
-class ConsumerRunningInfo;
-//<!***************************************************************************
-class ROCKETMQCLIENT_API DefaultMQPullConsumer : public MQConsumer {
- public:
-  DefaultMQPullConsumer(const std::string& groupname);
-  virtual ~DefaultMQPullConsumer();
-
-  //<!begin mqadmin;
-  virtual void start();
-  virtual void shutdown();
-  //<!end mqadmin;
-
-  //<!begin MQConsumer
-  virtual bool sendMessageBack(MQMessageExt& msg, int delayLevel, std::string& brokerName);
-  virtual void fetchSubscribeMessageQueues(const std::string& topic, std::vector<MQMessageQueue>& mqs);
-  virtual void doRebalance();
-  virtual void persistConsumerOffset();
-  virtual void persistConsumerOffsetByResetOffset();
-  virtual void updateTopicSubscribeInfo(const std::string& topic, std::vector<MQMessageQueue>& info);
-  virtual ConsumeType getConsumeType();
-  virtual ConsumeFromWhere getConsumeFromWhere();
-  virtual void getSubscriptions(std::vector<SubscriptionData>&);
-  virtual void updateConsumeOffset(const MQMessageQueue& mq, int64 offset);
-  virtual void removeConsumeOffset(const MQMessageQueue& mq);
-  virtual bool producePullMsgTask(boost::weak_ptr<PullRequest> pullRequest);
-  virtual Rebalance* getRebalance() const;
-  //<!end MQConsumer;
-
-  void registerMessageQueueListener(const std::string& topic, MQueueListener* pListener);
-  /**
-   * Pull message from specified queue, if no msg in queue, return directly
-   *
-   * @param mq
-   *            specify the pulled queue
-   * @param subExpression
-   *            set filter expression for pulled msg, broker will filter msg actively
-   *            Now only OR operation is supported, eg: "tag1 || tag2 || tag3"
-   *            if subExpression is setted to "null" or "*", all msg will be subscribed
-   * @param offset
-   *            specify the started pull offset
-   * @param maxNums
-   *            specify max msg num by per pull
-   * @return
-   *            PullResult
-   */
-  virtual PullResult pull(const MQMessageQueue& mq, const std::string& subExpression, int64 offset, int maxNums);
-  virtual void pull(const MQMessageQueue& mq,
-                    const std::string& subExpression,
-                    int64 offset,
-                    int maxNums,
-                    PullCallback* pPullCallback);
-
-  /**
-   * pull msg from specified queue, if no msg, broker will suspend the pull request 20s
-   *
-   * @param mq
-   *            specify the pulled queue
-   * @param subExpression
-   *            set filter expression for pulled msg, broker will filter msg actively
-   *            Now only OR operation is supported, eg: "tag1 || tag2 || tag3"
-   *            if subExpression is setted to "null" or "*", all msg will be subscribed
-   * @param offset
-   *            specify the started pull offset
-   * @param maxNums
-   *            specify max msg num by per pull
-   * @return
-   *            accroding to PullResult
-   */
-  PullResult pullBlockIfNotFound(const MQMessageQueue& mq, const std::string& subExpression, int64 offset, int maxNums);
-  void pullBlockIfNotFound(const MQMessageQueue& mq,
-                           const std::string& subExpression,
-                           int64 offset,
-                           int maxNums,
-                           PullCallback* pPullCallback);
-
-  virtual ConsumerRunningInfo* getConsumerRunningInfo() { return NULL; }
-
-  int64 fetchConsumeOffset(const MQMessageQueue& mq, bool fromStore);
-
-  void fetchMessageQueuesInBalance(const std::string& topic, std::vector<MQMessageQueue> mqs);
-
-  // temp persist consumer offset interface, only valid with
-  // RemoteBrokerOffsetStore, updateConsumeOffset should be called before.
-  void persistConsumerOffset4PullConsumer(const MQMessageQueue& mq);
-
- private:
-  void checkConfig();
-  void copySubscription();
-  bool dealWithNameSpace();
-
-  PullResult pullSyncImpl(const MQMessageQueue& mq,
-                          const std::string& subExpression,
-                          int64 offset,
-                          int maxNums,
-                          bool block);
-
-  void pullAsyncImpl(const MQMessageQueue& mq,
-                     const std::string& subExpression,
-                     int64 offset,
-                     int maxNums,
-                     bool block,
-                     PullCallback* pPullCallback);
-
-  void subscriptionAutomatically(const std::string& topic);
-
- private:
-  std::set<std::string> m_registerTopics;
-
-  MQueueListener* m_pMessageQueueListener;
-  OffsetStore* m_pOffsetStore;
-  Rebalance* m_pRebalance;
-  PullAPIWrapper* m_pPullAPIWrapper;
-};
-//<!***************************************************************************
-}  // namespace rocketmq
-#endif
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __DEFAULTMQPULLCONSUMERIMPL_H__
+#define __DEFAULTMQPULLCONSUMERIMPL_H__
+
+#include <set>
+#include <string>
+#include "MQConsumer.h"
+#include "MQMessageQueue.h"
+#include "MQueueListener.h"
+#include "RocketMQClient.h"
+
+namespace rocketmq {
+class Rebalance;
+class SubscriptionData;
+class OffsetStore;
+class PullAPIWrapper;
+class ConsumerRunningInfo;
+//<!***************************************************************************
+class DefaultMQPullConsumerImpl : public MQConsumer {
+ public:
+  DefaultMQPullConsumerImpl(const std::string& groupname);
+  virtual ~DefaultMQPullConsumerImpl();
+
+  //<!begin mqadmin;
+  virtual void start();
+  virtual void shutdown();
+  //<!end mqadmin;
+
+  //<!begin MQConsumer
+  virtual bool sendMessageBack(MQMessageExt& msg, int delayLevel, std::string& brokerName);
+  virtual void fetchSubscribeMessageQueues(const std::string& topic, std::vector<MQMessageQueue>& mqs);
+  virtual void doRebalance();
+  virtual void persistConsumerOffset();
+  virtual void persistConsumerOffsetByResetOffset();
+  virtual void updateTopicSubscribeInfo(const std::string& topic, std::vector<MQMessageQueue>& info);
+  virtual ConsumeType getConsumeType();
+  virtual ConsumeFromWhere getConsumeFromWhere();
+  virtual void getSubscriptions(std::vector<SubscriptionData>&);
+  virtual void updateConsumeOffset(const MQMessageQueue& mq, int64 offset);
+  virtual void removeConsumeOffset(const MQMessageQueue& mq);
+  virtual bool producePullMsgTask(boost::weak_ptr<PullRequest> pullRequest);
+  virtual Rebalance* getRebalance() const;
+  //<!end MQConsumer;
+
+  void registerMessageQueueListener(const std::string& topic, MQueueListener* pListener);
+  /**
+   * Pull message from specified queue, if no msg in queue, return directly
+   *
+   * @param mq
+   *            specify the pulled queue
+   * @param subExpression
+   *            set filter expression for pulled msg, broker will filter msg actively
+   *            Now only OR operation is supported, eg: "tag1 || tag2 || tag3"
+   *            if subExpression is setted to "null" or "*", all msg will be subscribed
+   * @param offset
+   *            specify the started pull offset
+   * @param maxNums
+   *            specify max msg num by per pull
+   * @return
+   *            PullResult
+   */
+  virtual PullResult pull(const MQMessageQueue& mq, const std::string& subExpression, int64 offset, int maxNums);
+  virtual void pull(const MQMessageQueue& mq,
+                    const std::string& subExpression,
+                    int64 offset,
+                    int maxNums,
+                    PullCallback* pPullCallback);
+
+  /**
+   * pull msg from specified queue, if no msg, broker will suspend the pull request 20s
+   *
+   * @param mq
+   *            specify the pulled queue
+   * @param subExpression
+   *            set filter expression for pulled msg, broker will filter msg actively
+   *            Now only OR operation is supported, eg: "tag1 || tag2 || tag3"
+   *            if subExpression is setted to "null" or "*", all msg will be subscribed
+   * @param offset
+   *            specify the started pull offset
+   * @param maxNums
+   *            specify max msg num by per pull
+   * @return
+   *            accroding to PullResult
+   */
+  PullResult pullBlockIfNotFound(const MQMessageQueue& mq, const std::string& subExpression, int64 offset, int maxNums);
+  void pullBlockIfNotFound(const MQMessageQueue& mq,
+                           const std::string& subExpression,
+                           int64 offset,
+                           int maxNums,
+                           PullCallback* pPullCallback);
+
+  virtual ConsumerRunningInfo* getConsumerRunningInfo() { return NULL; }
+
+  int64 fetchConsumeOffset(const MQMessageQueue& mq, bool fromStore);
+
+  void fetchMessageQueuesInBalance(const std::string& topic, std::vector<MQMessageQueue> mqs);
+
+  // temp persist consumer offset interface, only valid with
+  // RemoteBrokerOffsetStore, updateConsumeOffset should be called before.
+  void persistConsumerOffset4PullConsumer(const MQMessageQueue& mq);
+
+ private:
+  void checkConfig();
+  void copySubscription();
+  bool dealWithNameSpace();
+
+  PullResult pullSyncImpl(const MQMessageQueue& mq,
+                          const std::string& subExpression,
+                          int64 offset,
+                          int maxNums,
+                          bool block);
+
+  void pullAsyncImpl(const MQMessageQueue& mq,
+                     const std::string& subExpression,
+                     int64 offset,
+                     int maxNums,
+                     bool block,
+                     PullCallback* pPullCallback);
+
+  void subscriptionAutomatically(const std::string& topic);
+
+ private:
+  std::set<std::string> m_registerTopics;
+
+  MQueueListener* m_pMessageQueueListener;
+  OffsetStore* m_pOffsetStore;
+  Rebalance* m_pRebalance;
+  PullAPIWrapper* m_pPullAPIWrapper;
+};
+//<!***************************************************************************
+}  // namespace rocketmq
+#endif
diff --git a/src/consumer/DefaultMQPushConsumer.cpp b/src/consumer/DefaultMQPushConsumer.cpp
index 9da0ca8..cede0c9 100644
--- a/src/consumer/DefaultMQPushConsumer.cpp
+++ b/src/consumer/DefaultMQPushConsumer.cpp
@@ -16,1027 +16,183 @@
  */
 
 #include "DefaultMQPushConsumer.h"
-#include "CommunicationMode.h"
-#include "ConsumeMsgService.h"
-#include "ConsumerRunningInfo.h"
-#include "FilterAPI.h"
-#include "Logging.h"
-#include "MQClientAPIImpl.h"
-#include "MQClientFactory.h"
-#include "NameSpaceUtil.h"
-#include "OffsetStore.h"
-#include "PullAPIWrapper.h"
-#include "PullSysFlag.h"
-#include "Rebalance.h"
-#include "UtilAll.h"
-#include "Validators.h"
-#include "task_queue.h"
+#include "DefaultMQPushConsumerImpl.h"
 
 namespace rocketmq {
 
-class AsyncPullCallback : public PullCallback {
- public:
-  AsyncPullCallback(DefaultMQPushConsumer* pushConsumer, boost::weak_ptr<PullRequest> request)
-      : m_callbackOwner(pushConsumer), m_pullRequest(request), m_bShutdown(false) {}
-
-  virtual ~AsyncPullCallback() { m_callbackOwner = NULL; }
-
-  virtual void onSuccess(MQMessageQueue& mq, PullResult& result, bool bProducePullRequest) {
-    boost::shared_ptr<PullRequest> pullRequest = m_pullRequest.lock();
-    if (!pullRequest) {
-      LOG_WARN("Pull request for[%s] has been released", mq.toString().c_str());
-      return;
-    }
-
-    if (m_bShutdown) {
-      LOG_INFO("pullrequest for:%s in shutdown, return", (pullRequest->m_messageQueue).toString().c_str());
-      return;
-    }
-    if (pullRequest->isDropped()) {
-      LOG_INFO("Pull request for queue[%s] has been set as dropped. Will NOT pull this queue any more",
-               pullRequest->m_messageQueue.toString().c_str());
-      return;
-    }
-    switch (result.pullStatus) {
-      case FOUND: {
-        if (pullRequest->isDropped()) {
-          LOG_INFO("[Dropped]Remove pullmsg event of mq:%s", (pullRequest->m_messageQueue).toString().c_str());
-          break;
-        }
-        pullRequest->setNextOffset(result.nextBeginOffset);
-        pullRequest->putMessage(result.msgFoundList);
-
-        m_callbackOwner->getConsumerMsgService()->submitConsumeRequest(pullRequest, result.msgFoundList);
-
-        if (bProducePullRequest) {
-          m_callbackOwner->producePullMsgTask(pullRequest);
-        } else {
-          LOG_INFO("[bProducePullRequest = false]Stop pullmsg event of mq:%s",
-                   (pullRequest->m_messageQueue).toString().c_str());
-        }
-
-        LOG_DEBUG("FOUND:%s with size:" SIZET_FMT ", nextBeginOffset:%lld",
-                  (pullRequest->m_messageQueue).toString().c_str(), result.msgFoundList.size(), result.nextBeginOffset);
-
-        break;
-      }
-      case NO_NEW_MSG: {
-        if (pullRequest->isDropped()) {
-          LOG_INFO("[Dropped]Remove pullmsg event of mq:%s", (pullRequest->m_messageQueue).toString().c_str());
-          break;
-        }
-        pullRequest->setNextOffset(result.nextBeginOffset);
-
-        vector<MQMessageExt> msgs;
-        pullRequest->getMessage(msgs);
-        if ((msgs.size() == 0) && (result.nextBeginOffset > 0)) {
-          m_callbackOwner->updateConsumeOffset(pullRequest->m_messageQueue, result.nextBeginOffset);
-        }
-        if (bProducePullRequest) {
-          m_callbackOwner->producePullMsgTask(pullRequest);
-        } else {
-          LOG_INFO("[bProducePullRequest = false]Stop pullmsg event of mq:%s",
-                   (pullRequest->m_messageQueue).toString().c_str());
-        }
-        LOG_DEBUG("NO_NEW_MSG:%s,nextBeginOffset:%lld", pullRequest->m_messageQueue.toString().c_str(),
-                  result.nextBeginOffset);
-        break;
-      }
-      case NO_MATCHED_MSG: {
-        if (pullRequest->isDropped()) {
-          LOG_INFO("[Dropped]Remove pullmsg event of mq:%s", (pullRequest->m_messageQueue).toString().c_str());
-          break;
-        }
-        pullRequest->setNextOffset(result.nextBeginOffset);
-
-        vector<MQMessageExt> msgs;
-        pullRequest->getMessage(msgs);
-        if ((msgs.size() == 0) && (result.nextBeginOffset > 0)) {
-          m_callbackOwner->updateConsumeOffset(pullRequest->m_messageQueue, result.nextBeginOffset);
-        }
-        if (bProducePullRequest) {
-          m_callbackOwner->producePullMsgTask(pullRequest);
-        } else {
-          LOG_INFO("[bProducePullRequest = false]Stop pullmsg event of mq:%s",
-                   (pullRequest->m_messageQueue).toString().c_str());
-        }
-        LOG_DEBUG("NO_MATCHED_MSG:%s,nextBeginOffset:%lld", pullRequest->m_messageQueue.toString().c_str(),
-                  result.nextBeginOffset);
-        break;
-      }
-      case OFFSET_ILLEGAL: {
-        if (pullRequest->isDropped()) {
-          LOG_INFO("[Dropped]Remove pullmsg event of mq:%s", (pullRequest->m_messageQueue).toString().c_str());
-          break;
-        }
-        pullRequest->setNextOffset(result.nextBeginOffset);
-        if (bProducePullRequest) {
-          m_callbackOwner->producePullMsgTask(pullRequest);
-        } else {
-          LOG_INFO("[bProducePullRequest = false]Stop pullmsg event of mq:%s",
-                   (pullRequest->m_messageQueue).toString().c_str());
-        }
-
-        LOG_DEBUG("OFFSET_ILLEGAL:%s,nextBeginOffset:%lld", pullRequest->m_messageQueue.toString().c_str(),
-                  result.nextBeginOffset);
-        break;
-      }
-      case BROKER_TIMEOUT: {
-        if (pullRequest->isDropped()) {
-          LOG_INFO("[Dropped]Remove pullmsg event of mq:%s", (pullRequest->m_messageQueue).toString().c_str());
-          break;
-        }
-        LOG_ERROR("impossible BROKER_TIMEOUT Occurs");
-        pullRequest->setNextOffset(result.nextBeginOffset);
-        if (bProducePullRequest) {
-          m_callbackOwner->producePullMsgTask(pullRequest);
-        } else {
-          LOG_INFO("[bProducePullRequest = false]Stop pullmsg event of mq:%s",
-                   (pullRequest->m_messageQueue).toString().c_str());
-        }
-        break;
-      }
-    }
-  }
-
-  virtual void onException(MQException& e) {
-    boost::shared_ptr<PullRequest> pullRequest = m_pullRequest.lock();
-    if (!pullRequest) {
-      LOG_WARN("Pull request has been released.");
-      return;
-    }
-    std::string queueName = pullRequest->m_messageQueue.toString();
-    if (m_bShutdown) {
-      LOG_INFO("pullrequest for:%s in shutdown, return", queueName.c_str());
-      return;
-    }
-    if (pullRequest->isDropped()) {
-      LOG_INFO("[Dropped]Remove pullmsg event of mq:%s", queueName.c_str());
-      return;
-    }
-    LOG_WARN("Pullrequest for:%s occurs exception, reproduce it after 1s.", queueName.c_str());
-    m_callbackOwner->producePullMsgTaskLater(pullRequest, 1000);
-  }
-
-  void setShutdownStatus() { m_bShutdown = true; }
-
-  const boost::weak_ptr<PullRequest>& getPullRequest() const { return m_pullRequest; }
-
-  void setPullRequest(boost::weak_ptr<PullRequest>& pullRequest) { m_pullRequest = pullRequest; }
-
- private:
-  DefaultMQPushConsumer* m_callbackOwner;
-  boost::weak_ptr<PullRequest> m_pullRequest;
-  bool m_bShutdown;
-};
-
-//<!***************************************************************************
-static boost::mutex m_asyncCallbackLock;
-
-DefaultMQPushConsumer::DefaultMQPushConsumer(const string& groupname)
-    : m_consumeFromWhere(CONSUME_FROM_LAST_OFFSET),
-      m_pOffsetStore(NULL),
-      m_pRebalance(NULL),
-      m_pPullAPIWrapper(NULL),
-      m_consumerService(NULL),
-      m_pMessageListener(NULL),
-      m_consumeMessageBatchMaxSize(1),
-      m_maxMsgCacheSize(1000),
-      m_pullmsgQueue(NULL) {
-  //<!set default group name;
-  string gname = groupname.empty() ? DEFAULT_CONSUMER_GROUP : groupname;
-  setGroupName(gname);
-  m_asyncPull = true;
-  m_useNameSpaceMode = false;
-  m_asyncPullTimeout = 30 * 1000;
-  setMessageModel(CLUSTERING);
-
-  m_startTime = UtilAll::currentTimeMillis();
-  m_consumeThreadCount = std::thread::hardware_concurrency();
-  m_pullMsgThreadPoolNum = std::thread::hardware_concurrency();
-  m_async_service_thread.reset(new boost::thread(boost::bind(&DefaultMQPushConsumer::boost_asio_work, this)));
-}
-
-void DefaultMQPushConsumer::boost_asio_work() {
-  LOG_INFO("DefaultMQPushConsumer::boost asio async service runing");
-  boost::asio::io_service::work work(m_async_ioService);  // avoid async io
-  // service stops after
-  // first timer timeout
-  // callback
-  m_async_ioService.run();
+DefaultMQPushConsumer::DefaultMQPushConsumer(const std::string& groupName) {
+  impl = new DefaultMQPushConsumerImpl(groupName);
 }
 
 DefaultMQPushConsumer::~DefaultMQPushConsumer() {
-  m_pMessageListener = NULL;
-  if (m_pullmsgQueue != NULL) {
-    deleteAndZero(m_pullmsgQueue);
-  }
-  if (m_pRebalance != NULL) {
-    deleteAndZero(m_pRebalance);
-  }
-  if (m_pOffsetStore != NULL) {
-    deleteAndZero(m_pOffsetStore);
-  }
-  if (m_pPullAPIWrapper != NULL) {
-    deleteAndZero(m_pPullAPIWrapper);
-  }
-  if (m_consumerService != NULL) {
-    deleteAndZero(m_consumerService);
-  }
-  PullMAP::iterator it = m_PullCallback.begin();
-  for (; it != m_PullCallback.end(); ++it) {
-    deleteAndZero(it->second);
-  }
-  m_PullCallback.clear();
-  m_subTopics.clear();
-}
-
-bool DefaultMQPushConsumer::sendMessageBack(MQMessageExt& msg, int delayLevel, string& brokerName) {
-  string brokerAddr;
-  if (!brokerName.empty())
-    brokerAddr = getFactory()->findBrokerAddressInPublish(brokerName);
-  else
-    brokerAddr = socketAddress2IPPort(msg.getStoreHost());
-  try {
-    getFactory()->getMQClientAPIImpl()->consumerSendMessageBack(brokerAddr, msg, getGroupName(), delayLevel,
-                                                                getMaxReconsumeTimes(), 3000, getSessionCredentials());
-  } catch (MQException& e) {
-    LOG_ERROR(e.what());
-    return false;
-  }
-  return true;
+  delete impl;
 }
-
-void DefaultMQPushConsumer::fetchSubscribeMessageQueues(const string& topic, vector<MQMessageQueue>& mqs) {
-  mqs.clear();
-  try {
-    getFactory()->fetchSubscribeMessageQueues(topic, mqs, getSessionCredentials());
-  } catch (MQException& e) {
-    LOG_ERROR(e.what());
-  }
-}
-
-void DefaultMQPushConsumer::doRebalance() {
-  if (isServiceStateOk()) {
-    try {
-      m_pRebalance->doRebalance();
-    } catch (MQException& e) {
-      LOG_ERROR(e.what());
-    }
-  }
+void DefaultMQPushConsumer::start() {
+  impl->start();
 }
 
-void DefaultMQPushConsumer::persistConsumerOffset() {
-  if (isServiceStateOk()) {
-    m_pRebalance->persistConsumerOffset();
-  }
+void DefaultMQPushConsumer::shutdown() {
+  impl->shutdown();
 }
 
-void DefaultMQPushConsumer::persistConsumerOffsetByResetOffset() {
-  if (isServiceStateOk()) {
-    m_pRebalance->persistConsumerOffsetByResetOffset();
-  }
+ConsumeType DefaultMQPushConsumer::getConsumeType() {
+  return impl->getConsumeType();
 }
-
-void DefaultMQPushConsumer::start() {
-#ifndef WIN32
-  /* Ignore the SIGPIPE */
-  struct sigaction sa;
-  memset(&sa, 0, sizeof(struct sigaction));
-  sa.sa_handler = SIG_IGN;
-  sa.sa_flags = 0;
-  sigaction(SIGPIPE, &sa, 0);
-#endif
-  // deal with name space before start
-  dealWithNameSpace();
-  switch (m_serviceState) {
-    case CREATE_JUST: {
-      m_serviceState = START_FAILED;
-      MQClient::start();
-      LOG_INFO("DefaultMQPushConsumer:%s start", m_GroupName.c_str());
-
-      //<!data;
-      checkConfig();
-
-      //<!create rebalance;
-      m_pRebalance = new RebalancePush(this, getFactory());
-
-      string groupname = getGroupName();
-      m_pPullAPIWrapper = new PullAPIWrapper(getFactory(), groupname);
-
-      if (m_pMessageListener) {
-        if (m_pMessageListener->getMessageListenerType() == messageListenerOrderly) {
-          LOG_INFO("start orderly consume service:%s", getGroupName().c_str());
-          m_consumerService = new ConsumeMessageOrderlyService(this, m_consumeThreadCount, m_pMessageListener);
-        } else  // for backward compatible, defaultly and concurrently listeners
-                // are allocating ConsumeMessageConcurrentlyService
-        {
-          LOG_INFO("start concurrently consume service:%s", getGroupName().c_str());
-          m_consumerService = new ConsumeMessageConcurrentlyService(this, m_consumeThreadCount, m_pMessageListener);
-        }
-      }
-
-      m_pullmsgQueue = new TaskQueue(m_pullMsgThreadPoolNum);
-      m_pullmsgThread.reset(
-          new boost::thread(boost::bind(&DefaultMQPushConsumer::runPullMsgQueue, this, m_pullmsgQueue)));
-
-      copySubscription();
-
-      //<! registe;
-      bool registerOK = getFactory()->registerConsumer(this);
-      if (!registerOK) {
-        m_serviceState = CREATE_JUST;
-        THROW_MQEXCEPTION(
-            MQClientException,
-            "The cousumer group[" + getGroupName() + "] has been created before, specify another name please.", -1);
-      }
-
-      //<!msg model;
-      switch (getMessageModel()) {
-        case BROADCASTING:
-          m_pOffsetStore = new LocalFileOffsetStore(groupname, getFactory());
-          break;
-        case CLUSTERING:
-          m_pOffsetStore = new RemoteBrokerOffsetStore(groupname, getFactory());
-          break;
-      }
-      bool bStartFailed = false;
-      string errorMsg;
-      try {
-        m_pOffsetStore->load();
-      } catch (MQClientException& e) {
-        bStartFailed = true;
-        errorMsg = std::string(e.what());
-      }
-      m_consumerService->start();
-
-      getFactory()->start();
-
-      updateTopicSubscribeInfoWhenSubscriptionChanged();
-      getFactory()->sendHeartbeatToAllBroker();
-
-      m_serviceState = RUNNING;
-      if (bStartFailed) {
-        shutdown();
-        THROW_MQEXCEPTION(MQClientException, errorMsg, -1);
-      }
-      break;
-    }
-    case RUNNING:
-    case START_FAILED:
-    case SHUTDOWN_ALREADY:
-      break;
-    default:
-      break;
-  }
-
-  getFactory()->rebalanceImmediately();
+ConsumeFromWhere DefaultMQPushConsumer::getConsumeFromWhere() {
+  return impl->getConsumeFromWhere();
 }
-
-void DefaultMQPushConsumer::shutdown() {
-  switch (m_serviceState) {
-    case RUNNING: {
-      LOG_INFO("DefaultMQPushConsumer shutdown");
-      m_async_ioService.stop();
-      m_async_service_thread->interrupt();
-      m_async_service_thread->join();
-      m_pullmsgQueue->close();
-      m_pullmsgThread->interrupt();
-      m_pullmsgThread->join();
-      m_consumerService->shutdown();
-      persistConsumerOffset();
-      shutdownAsyncPullCallBack();  // delete aync pullMsg resources
-      getFactory()->unregisterConsumer(this);
-      getFactory()->shutdown();
-      m_serviceState = SHUTDOWN_ALREADY;
-      break;
-    }
-    case CREATE_JUST:
-    case SHUTDOWN_ALREADY:
-      break;
-    default:
-      break;
-  }
+void DefaultMQPushConsumer::setConsumeFromWhere(ConsumeFromWhere consumeFromWhere) {
+  impl->setConsumeFromWhere(consumeFromWhere);
 }
 
 void DefaultMQPushConsumer::registerMessageListener(MQMessageListener* pMessageListener) {
-  if (NULL != pMessageListener) {
-    m_pMessageListener = pMessageListener;
-  }
+  impl->registerMessageListener(pMessageListener);
 }
-
 MessageListenerType DefaultMQPushConsumer::getMessageListenerType() {
-  if (NULL != m_pMessageListener) {
-    return m_pMessageListener->getMessageListenerType();
-  }
-  return messageListenerDefaultly;
+  return impl->getMessageListenerType();
 }
-
-ConsumeMsgService* DefaultMQPushConsumer::getConsumerMsgService() const {
-  return m_consumerService;
+void DefaultMQPushConsumer::subscribe(const std::string& topic, const std::string& subExpression) {
+  impl->subscribe(topic, subExpression);
 }
 
-OffsetStore* DefaultMQPushConsumer::getOffsetStore() const {
-  return m_pOffsetStore;
+void DefaultMQPushConsumer::setConsumeMessageBatchMaxSize(int consumeMessageBatchMaxSize) {
+  impl->setConsumeMessageBatchMaxSize(consumeMessageBatchMaxSize);
 }
-
-Rebalance* DefaultMQPushConsumer::getRebalance() const {
-  return m_pRebalance;
+int DefaultMQPushConsumer::getConsumeMessageBatchMaxSize() const {
+  return impl->getConsumeMessageBatchMaxSize();
 }
 
-void DefaultMQPushConsumer::subscribe(const string& topic, const string& subExpression) {
-  m_subTopics[topic] = subExpression;
+/*
+  set consuming thread count, default value is cpu cores
+*/
+void DefaultMQPushConsumer::setConsumeThreadCount(int threadCount) {
+  impl->setConsumeThreadCount(threadCount);
 }
-
-void DefaultMQPushConsumer::checkConfig() {
-  string groupname = getGroupName();
-  // check consumerGroup
-  Validators::checkGroup(groupname);
-
-  // consumerGroup
-  if (!groupname.compare(DEFAULT_CONSUMER_GROUP)) {
-    THROW_MQEXCEPTION(MQClientException, "consumerGroup can not equal DEFAULT_CONSUMER", -1);
-  }
-
-  if (getMessageModel() != BROADCASTING && getMessageModel() != CLUSTERING) {
-    THROW_MQEXCEPTION(MQClientException, "messageModel is valid ", -1);
-  }
-
-  if (m_pMessageListener == NULL) {
-    THROW_MQEXCEPTION(MQClientException, "messageListener is null ", -1);
-  }
+int DefaultMQPushConsumer::getConsumeThreadCount() const {
+  return impl->getConsumeThreadCount();
 }
-
-void DefaultMQPushConsumer::copySubscription() {
-  map<string, string>::iterator it = m_subTopics.begin();
-  for (; it != m_subTopics.end(); ++it) {
-    LOG_INFO("buildSubscriptionData,:%s,%s", it->first.c_str(), it->second.c_str());
-    unique_ptr<SubscriptionData> pSData(FilterAPI::buildSubscriptionData(it->first, it->second));
-
-    m_pRebalance->setSubscriptionData(it->first, pSData.release());
-  }
-
-  switch (getMessageModel()) {
-    case BROADCASTING:
-      break;
-    case CLUSTERING: {
-      string retryTopic = UtilAll::getRetryTopic(getGroupName());
-
-      //<!this sub;
-      unique_ptr<SubscriptionData> pSData(FilterAPI::buildSubscriptionData(retryTopic, SUB_ALL));
-
-      m_pRebalance->setSubscriptionData(retryTopic, pSData.release());
-      break;
-    }
-    default:
-      break;
-  }
+void DefaultMQPushConsumer::setMaxReconsumeTimes(int maxReconsumeTimes) {
+  impl->setMaxReconsumeTimes(maxReconsumeTimes);
 }
-
-void DefaultMQPushConsumer::updateTopicSubscribeInfo(const string& topic, vector<MQMessageQueue>& info) {
-  m_pRebalance->setTopicSubscribeInfo(topic, info);
+int DefaultMQPushConsumer::getMaxReconsumeTimes() const {
+  return impl->getMaxReconsumeTimes();
 }
 
-void DefaultMQPushConsumer::updateTopicSubscribeInfoWhenSubscriptionChanged() {
-  map<string, SubscriptionData*>& subTable = m_pRebalance->getSubscriptionInner();
-  map<string, SubscriptionData*>::iterator it = subTable.begin();
-  for (; it != subTable.end(); ++it) {
-    bool btopic = getFactory()->updateTopicRouteInfoFromNameServer(it->first, getSessionCredentials());
-    if (btopic == false) {
-      LOG_WARN("The topic:[%s] not exist", it->first.c_str());
-    }
-  }
+/*
+  set pullMsg thread count, default value is cpu cores
+*/
+void DefaultMQPushConsumer::setPullMsgThreadPoolCount(int threadCount) {
+  impl->setPullMsgThreadPoolCount(threadCount);
 }
-
-ConsumeType DefaultMQPushConsumer::getConsumeType() {
-  return CONSUME_PASSIVELY;
+int DefaultMQPushConsumer::getPullMsgThreadPoolCount() const {
+  return impl->getPullMsgThreadPoolCount();
 }
 
-ConsumeFromWhere DefaultMQPushConsumer::getConsumeFromWhere() {
-  return m_consumeFromWhere;
+/*
+  set max cache msg size perQueue in memory if consumer could not consume msgs
+  immediately
+  default maxCacheMsgSize perQueue is 1000, set range is:1~65535
+*/
+void DefaultMQPushConsumer::setMaxCacheMsgSizePerQueue(int maxCacheSize) {
+  impl->setMaxCacheMsgSizePerQueue(maxCacheSize);
 }
-
-void DefaultMQPushConsumer::setConsumeFromWhere(ConsumeFromWhere consumeFromWhere) {
-  m_consumeFromWhere = consumeFromWhere;
+int DefaultMQPushConsumer::getMaxCacheMsgSizePerQueue() const {
+  return impl->getMaxCacheMsgSizePerQueue();
 }
 
-void DefaultMQPushConsumer::getSubscriptions(vector<SubscriptionData>& result) {
-  map<string, SubscriptionData*>& subTable = m_pRebalance->getSubscriptionInner();
-  map<string, SubscriptionData*>::iterator it = subTable.begin();
-  for (; it != subTable.end(); ++it) {
-    result.push_back(*(it->second));
-  }
+MessageModel DefaultMQPushConsumer::getMessageModel() const {
+  return impl->getMessageModel();
 }
-
-void DefaultMQPushConsumer::updateConsumeOffset(const MQMessageQueue& mq, int64 offset) {
-  if (offset >= 0) {
-    m_pOffsetStore->updateOffset(mq, offset);
-  } else {
-    LOG_ERROR("updateConsumeOffset of mq:%s error", mq.toString().c_str());
-  }
+void DefaultMQPushConsumer::setMessageModel(MessageModel messageModel) {
+  impl->setMessageModel(messageModel);
 }
 
-void DefaultMQPushConsumer::removeConsumeOffset(const MQMessageQueue& mq) {
-  m_pOffsetStore->removeOffset(mq);
+const std::string& DefaultMQPushConsumer::getNamesrvAddr() const {
+  return impl->getNamesrvAddr();
 }
 
-void DefaultMQPushConsumer::static_triggerNextPullRequest(void* context,
-                                                          boost::asio::deadline_timer* t,
-                                                          boost::weak_ptr<PullRequest> pullRequest) {
-  if (pullRequest.expired()) {
-    LOG_WARN("Pull request has been released before.");
-    return;
-  }
-  DefaultMQPushConsumer* pDefaultMQPushConsumer = (DefaultMQPushConsumer*)context;
-  if (pDefaultMQPushConsumer) {
-    pDefaultMQPushConsumer->triggerNextPullRequest(t, pullRequest);
-  }
+void DefaultMQPushConsumer::setNamesrvAddr(const std::string& namesrvAddr) {
+  impl->setNamesrvAddr(namesrvAddr);
 }
 
-void DefaultMQPushConsumer::triggerNextPullRequest(boost::asio::deadline_timer* t,
-                                                   boost::weak_ptr<PullRequest> pullRequest) {
-  // delete first to avoild memleak
-  deleteAndZero(t);
-  boost::shared_ptr<PullRequest> request = pullRequest.lock();
-  if (!request) {
-    LOG_WARN("Pull request has been released before.");
-    return;
-  }
-  producePullMsgTask(request);
+const std::string& DefaultMQPushConsumer::getNamesrvDomain() const {
+  return impl->getNamesrvDomain();
 }
 
-bool DefaultMQPushConsumer::producePullMsgTaskLater(boost::weak_ptr<PullRequest> pullRequest, int millis) {
-  boost::shared_ptr<PullRequest> request = pullRequest.lock();
-  if (!request) {
-    LOG_INFO("Pull request is invalid. Maybe it is dropped before.");
-    return false;
-  }
-  if (request->isDropped()) {
-    LOG_INFO("[Dropped]Remove pullmsg event of mq:%s", request->m_messageQueue.toString().c_str());
-    return false;
-  }
-  if (m_pullmsgQueue->bTaskQueueStatusOK() && isServiceStateOk()) {
-    boost::asio::deadline_timer* t =
-        new boost::asio::deadline_timer(m_async_ioService, boost::posix_time::milliseconds(millis));
-    t->async_wait(boost::bind(&(DefaultMQPushConsumer::static_triggerNextPullRequest), this, t, request));
-    LOG_INFO("Produce Pull request [%s] Later and Sleep [%d]ms.", (request->m_messageQueue).toString().c_str(), millis);
-    return true;
-  } else {
-    LOG_WARN("Service or TaskQueue shutdown, produce PullRequest of mq:%s failed",
-             request->m_messageQueue.toString().c_str());
-    return false;
-  }
+void DefaultMQPushConsumer::setNamesrvDomain(const std::string& namesrvDomain) {
+  impl->setNamesrvDomain(namesrvDomain);
 }
-
-bool DefaultMQPushConsumer::producePullMsgTask(boost::weak_ptr<PullRequest> pullRequest) {
-  boost::shared_ptr<PullRequest> request = pullRequest.lock();
-  if (!request) {
-    LOG_WARN("Pull request has been released.");
-    return false;
-  }
-  if (request->isDropped()) {
-    LOG_INFO("[Dropped]Remove pullmsg event of mq:%s", request->m_messageQueue.toString().c_str());
-    return false;
-  }
-  if (m_pullmsgQueue->bTaskQueueStatusOK() && isServiceStateOk()) {
-    if (m_asyncPull) {
-      m_pullmsgQueue->produce(TaskBinder::gen(&DefaultMQPushConsumer::pullMessageAsync, this, request));
-    } else {
-      m_pullmsgQueue->produce(TaskBinder::gen(&DefaultMQPushConsumer::pullMessage, this, request));
-    }
-  } else {
-    LOG_WARN("produce PullRequest of mq:%s failed", request->m_messageQueue.toString().c_str());
-    return false;
-  }
-  return true;
+void DefaultMQPushConsumer::setSessionCredentials(const std::string& accessKey,
+                                                  const std::string& secretKey,
+                                                  const std::string& accessChannel) {
+  impl->setSessionCredentials(accessKey, secretKey, accessChannel);
 }
 
-void DefaultMQPushConsumer::runPullMsgQueue(TaskQueue* pTaskQueue) {
-  pTaskQueue->run();
+const SessionCredentials& DefaultMQPushConsumer::getSessionCredentials() const {
+  return impl->getSessionCredentials();
 }
-
-void DefaultMQPushConsumer::pullMessage(boost::weak_ptr<PullRequest> pullRequest) {
-  boost::shared_ptr<PullRequest> request = pullRequest.lock();
-  if (!request) {
-    LOG_ERROR("Pull request is released, return");
-    return;
-  }
-  if (request->isDropped()) {
-    LOG_WARN("Pull request is set drop with mq:%s, return", (request->m_messageQueue).toString().c_str());
-    // request->removePullMsgEvent();
-    return;
-  }
-
-  MQMessageQueue& messageQueue = request->m_messageQueue;
-  if (m_consumerService->getConsumeMsgSerivceListenerType() == messageListenerOrderly) {
-    if (!request->isLocked() || request->isLockExpired()) {
-      if (!m_pRebalance->lock(messageQueue)) {
-        request->setLastPullTimestamp(UtilAll::currentTimeMillis());
-        producePullMsgTaskLater(request, 1000);
-        return;
-      }
-    }
-  }
-
-  if (request->getCacheMsgCount() > m_maxMsgCacheSize) {
-    LOG_INFO("Sync Pull request for %s has Cached with %d Messages and The Max size is %d, Sleep 1s.",
-             (request->m_messageQueue).toString().c_str(), request->getCacheMsgCount(), m_maxMsgCacheSize);
-    request->setLastPullTimestamp(UtilAll::currentTimeMillis());
-    // Retry 1s,
-    producePullMsgTaskLater(request, 1000);
-    return;
-  }
-
-  bool commitOffsetEnable = false;
-  int64 commitOffsetValue = 0;
-  if (CLUSTERING == getMessageModel()) {
-    commitOffsetValue = m_pOffsetStore->readOffset(messageQueue, READ_FROM_MEMORY, getSessionCredentials());
-    if (commitOffsetValue > 0) {
-      commitOffsetEnable = true;
-    }
-  }
-
-  string subExpression;
-  SubscriptionData* pSdata = m_pRebalance->getSubscriptionData(messageQueue.getTopic());
-  if (pSdata == NULL) {
-    LOG_INFO("Can not get SubscriptionData of Pull request for [%s], Sleep 1s.",
-             (request->m_messageQueue).toString().c_str());
-    producePullMsgTaskLater(request, 1000);
-    return;
-  }
-  subExpression = pSdata->getSubString();
-
-  int sysFlag = PullSysFlag::buildSysFlag(commitOffsetEnable,      // commitOffset
-                                          false,                   // suspend
-                                          !subExpression.empty(),  // subscription
-                                          false);                  // class filter
-  if (request->isDropped()) {
-    LOG_WARN("Pull request is set as dropped with mq:%s, return", (request->m_messageQueue).toString().c_str());
-    return;
-  }
-  try {
-    request->setLastPullTimestamp(UtilAll::currentTimeMillis());
-    unique_ptr<PullResult> result(m_pPullAPIWrapper->pullKernelImpl(messageQueue,              // 1
-                                                                    subExpression,             // 2
-                                                                    pSdata->getSubVersion(),   // 3
-                                                                    request->getNextOffset(),  // 4
-                                                                    32,                        // 5
-                                                                    sysFlag,                   // 6
-                                                                    commitOffsetValue,         // 7
-                                                                    1000 * 15,                 // 8
-                                                                    1000 * 30,                 // 9
-                                                                    ComMode_SYNC,              // 10
-                                                                    NULL, getSessionCredentials()));
-
-    PullResult pullResult = m_pPullAPIWrapper->processPullResult(messageQueue, result.get(), pSdata);
-    switch (pullResult.pullStatus) {
-      case FOUND: {
-        if (request->isDropped()) {
-          LOG_INFO("Get pull result but the queue has been marked as dropped. Queue: %s",
-                   messageQueue.toString().c_str());
-          break;
-        }
-        // and this request is dropped, and then received pulled msgs.
-        request->setNextOffset(pullResult.nextBeginOffset);
-        request->putMessage(pullResult.msgFoundList);
-
-        m_consumerService->submitConsumeRequest(request, pullResult.msgFoundList);
-        producePullMsgTask(request);
-
-        LOG_DEBUG("FOUND:%s with size:" SIZET_FMT ",nextBeginOffset:%lld", messageQueue.toString().c_str(),
-                  pullResult.msgFoundList.size(), pullResult.nextBeginOffset);
-
-        break;
-      }
-      case NO_NEW_MSG: {
-        if (request->isDropped()) {
-          LOG_INFO("Get pull result but the queue has been marked as dropped. Queue: %s",
-                   messageQueue.toString().c_str());
-          break;
-        }
-        request->setNextOffset(pullResult.nextBeginOffset);
-        vector<MQMessageExt> msgs;
-        request->getMessage(msgs);
-        if ((msgs.size() == 0) && (pullResult.nextBeginOffset > 0)) {
-          updateConsumeOffset(messageQueue, pullResult.nextBeginOffset);
-        }
-        producePullMsgTask(request);
-        LOG_DEBUG("NO_NEW_MSG:%s,nextBeginOffset:%lld", messageQueue.toString().c_str(), pullResult.nextBeginOffset);
-        break;
-      }
-      case NO_MATCHED_MSG: {
-        if (request->isDropped()) {
-          LOG_INFO("Get pull result but the queue has been marked as dropped. Queue: %s",
-                   messageQueue.toString().c_str());
-          break;
-        }
-        request->setNextOffset(pullResult.nextBeginOffset);
-        vector<MQMessageExt> msgs;
-        request->getMessage(msgs);
-        if ((msgs.size() == 0) && (pullResult.nextBeginOffset > 0)) {
-          updateConsumeOffset(messageQueue, pullResult.nextBeginOffset);
-        }
-        producePullMsgTask(request);
-
-        LOG_DEBUG("NO_MATCHED_MSG:%s,nextBeginOffset:%lld", messageQueue.toString().c_str(),
-                  pullResult.nextBeginOffset);
-        break;
-      }
-      case OFFSET_ILLEGAL: {
-        if (request->isDropped()) {
-          LOG_INFO("Get pull result but the queue has been marked as dropped. Queue: %s",
-                   messageQueue.toString().c_str());
-          break;
-        }
-        request->setNextOffset(pullResult.nextBeginOffset);
-        producePullMsgTask(request);
-
-        LOG_DEBUG("OFFSET_ILLEGAL:%s,nextBeginOffset:%lld", messageQueue.toString().c_str(),
-                  pullResult.nextBeginOffset);
-        break;
-      }
-      case BROKER_TIMEOUT: {  // as BROKER_TIMEOUT is defined by client, broker
-        // will not returns this status, so this case
-        // could not be entered.
-        LOG_ERROR("impossible BROKER_TIMEOUT Occurs");
-        request->setNextOffset(pullResult.nextBeginOffset);
-        producePullMsgTask(request);
-        break;
-      }
-    }
-  } catch (MQException& e) {
-    LOG_ERROR(e.what());
-    LOG_WARN("Pull %s occur exception, restart 1s  later.", messageQueue.toString().c_str());
-    producePullMsgTaskLater(request, 1000);
-  }
+const std::string& DefaultMQPushConsumer::getInstanceName() const {
+  return impl->getInstanceName();
 }
 
-AsyncPullCallback* DefaultMQPushConsumer::getAsyncPullCallBack(boost::weak_ptr<PullRequest> pullRequest,
-                                                               MQMessageQueue msgQueue) {
-  boost::shared_ptr<PullRequest> request = pullRequest.lock();
-  if (!request) {
-    return NULL;
-  }
-  boost::lock_guard<boost::mutex> lock(m_asyncCallbackLock);
-  if (m_asyncPull && request) {
-    PullMAP::iterator it = m_PullCallback.find(msgQueue);
-    if (it == m_PullCallback.end()) {
-      LOG_INFO("new pull callback for mq:%s", msgQueue.toString().c_str());
-      m_PullCallback[msgQueue] = new AsyncPullCallback(this, request);
-    }
-    AsyncPullCallback* asyncPullCallback = m_PullCallback[msgQueue];
-    if (asyncPullCallback && asyncPullCallback->getPullRequest().expired()) {
-      asyncPullCallback->setPullRequest(pullRequest);
-    }
-    return asyncPullCallback;
-  }
-
-  return NULL;
+void DefaultMQPushConsumer::setInstanceName(const std::string& instanceName) {
+  impl->setInstanceName(instanceName);
 }
 
-void DefaultMQPushConsumer::shutdownAsyncPullCallBack() {
-  boost::lock_guard<boost::mutex> lock(m_asyncCallbackLock);
-  if (m_asyncPull) {
-    PullMAP::iterator it = m_PullCallback.begin();
-    for (; it != m_PullCallback.end(); ++it) {
-      if (it->second) {
-        it->second->setShutdownStatus();
-      } else {
-        LOG_ERROR("could not find asyncPullCallback for:%s", it->first.toString().c_str());
-      }
-    }
-  }
+const std::string& DefaultMQPushConsumer::getNameSpace() const {
+  return impl->getNameSpace();
 }
 
-void DefaultMQPushConsumer::pullMessageAsync(boost::weak_ptr<PullRequest> pullRequest) {
-  boost::shared_ptr<PullRequest> request = pullRequest.lock();
-  if (!request) {
-    LOG_ERROR("Pull request is released, return");
-    return;
-  }
-  if (request->isDropped()) {
-    LOG_WARN("Pull request is set drop with mq:%s, return", (request->m_messageQueue).toString().c_str());
-    return;
-  }
-  MQMessageQueue& messageQueue = request->m_messageQueue;
-  if (m_consumerService->getConsumeMsgSerivceListenerType() == messageListenerOrderly) {
-    if (!request->isLocked() || request->isLockExpired()) {
-      if (!m_pRebalance->lock(messageQueue)) {
-        request->setLastPullTimestamp(UtilAll::currentTimeMillis());
-        // Retry later.
-        producePullMsgTaskLater(request, 1000);
-        return;
-      }
-    }
-  }
-
-  if (request->getCacheMsgCount() > m_maxMsgCacheSize) {
-    LOG_INFO("Pull request for [%s] has Cached with %d Messages and The Max size is %d, Sleep 3s.",
-             (request->m_messageQueue).toString().c_str(), request->getCacheMsgCount(), m_maxMsgCacheSize);
-    request->setLastPullTimestamp(UtilAll::currentTimeMillis());
-    // Retry 3s,
-    producePullMsgTaskLater(request, 3000);
-    return;
-  }
-
-  bool commitOffsetEnable = false;
-  int64 commitOffsetValue = 0;
-  if (CLUSTERING == getMessageModel()) {
-    commitOffsetValue = m_pOffsetStore->readOffset(messageQueue, READ_FROM_MEMORY, getSessionCredentials());
-    if (commitOffsetValue > 0) {
-      commitOffsetEnable = true;
-    }
-  }
-
-  string subExpression;
-  SubscriptionData* pSdata = (m_pRebalance->getSubscriptionData(messageQueue.getTopic()));
-  if (pSdata == NULL) {
-    LOG_INFO("Can not get SubscriptionData of Pull request for [%s], Sleep 1s.",
-             (request->m_messageQueue).toString().c_str());
-    // Subscribe data error, retry later.
-    producePullMsgTaskLater(request, 1000);
-    return;
-  }
-  subExpression = pSdata->getSubString();
-
-  int sysFlag = PullSysFlag::buildSysFlag(commitOffsetEnable,      // commitOffset
-                                          true,                    // suspend
-                                          !subExpression.empty(),  // subscription
-                                          false);                  // class filter
-
-  AsyncArg arg;
-  arg.mq = messageQueue;
-  arg.subData = *pSdata;
-  arg.pPullWrapper = m_pPullAPIWrapper;
-  if (request->isDropped()) {
-    LOG_WARN("Pull request is set as dropped with mq:%s, return", request->m_messageQueue.toString().c_str());
-    return;
-  }
-  try {
-    request->setLastPullTimestamp(UtilAll::currentTimeMillis());
-    AsyncPullCallback* pullCallback = getAsyncPullCallBack(request, messageQueue);
-    if (pullCallback == NULL) {
-      LOG_WARN("Can not get pull callback for:%s, Maybe this pull request has been released.",
-               request->m_messageQueue.toString().c_str());
-      return;
-    }
-    m_pPullAPIWrapper->pullKernelImpl(messageQueue,              // 1
-                                      subExpression,             // 2
-                                      pSdata->getSubVersion(),   // 3
-                                      request->getNextOffset(),  // 4
-                                      32,                        // 5
-                                      sysFlag,                   // 6
-                                      commitOffsetValue,         // 7
-                                      1000 * 15,                 // 8
-                                      m_asyncPullTimeout,        // 9
-                                      ComMode_ASYNC,             // 10
-                                      pullCallback,              // 11
-                                      getSessionCredentials(),   // 12
-                                      &arg);                     // 13
-  } catch (MQException& e) {
-    LOG_ERROR(e.what());
-    if (request->isDropped()) {
-      LOG_WARN("Pull request is set as dropped with mq:%s, return", (request->m_messageQueue).toString().c_str());
-      return;
-    }
-    LOG_INFO("Pull %s occur exception, restart 1s  later.", (request->m_messageQueue).toString().c_str());
-    producePullMsgTaskLater(request, 1000);
-  }
+void DefaultMQPushConsumer::setNameSpace(const std::string& nameSpace) {
+  impl->setNameSpace(nameSpace);
+}
+const std::string& DefaultMQPushConsumer::getGroupName() const {
+  return impl->getGroupName();
 }
 
-void DefaultMQPushConsumer::setAsyncPull(bool asyncFlag) {
-  if (asyncFlag) {
-    LOG_INFO("set pushConsumer:%s to async default pull mode", getGroupName().c_str());
-  } else {
-    LOG_INFO("set pushConsumer:%s to sync pull mode", getGroupName().c_str());
-  }
-  m_asyncPull = asyncFlag;
+void DefaultMQPushConsumer::setGroupName(const std::string& groupName) {
+  impl->setGroupName(groupName);
 }
 
-void DefaultMQPushConsumer::setConsumeThreadCount(int threadCount) {
-  if (threadCount > 0) {
-    m_consumeThreadCount = threadCount;
-  } else {
-    LOG_ERROR("setConsumeThreadCount with invalid value");
-  }
+void DefaultMQPushConsumer::setLogLevel(elogLevel inputLevel) {
+  impl->setLogLevel(inputLevel);
 }
 
-int DefaultMQPushConsumer::getConsumeThreadCount() const {
-  return m_consumeThreadCount;
+elogLevel DefaultMQPushConsumer::getLogLevel() {
+  return impl->getLogLevel();
 }
-void DefaultMQPushConsumer::setMaxReconsumeTimes(int maxReconsumeTimes) {
-  if (maxReconsumeTimes > 0) {
-    m_maxReconsumeTimes = maxReconsumeTimes;
-  } else {
-    LOG_ERROR("set maxReconsumeTimes with invalid value");
-  }
+void DefaultMQPushConsumer::setLogFileSizeAndNum(int fileNum, long perFileSize) {
+  impl->setLogFileSizeAndNum(fileNum, perFileSize);
 }
 
-int DefaultMQPushConsumer::getMaxReconsumeTimes() const {
-  if (m_maxReconsumeTimes >= 0) {
-    return m_maxReconsumeTimes;
-  }
-  // return 16 as default;
-  return 16;
+void DefaultMQPushConsumer::setUnitName(std::string unitName) {
+  impl->setUnitName(unitName);
 }
-
-void DefaultMQPushConsumer::setPullMsgThreadPoolCount(int threadCount) {
-  m_pullMsgThreadPoolNum = threadCount;
+const std::string& DefaultMQPushConsumer::getUnitName() const {
+  return impl->getUnitName();
 }
 
-int DefaultMQPushConsumer::getPullMsgThreadPoolCount() const {
-  return m_pullMsgThreadPoolNum;
+void DefaultMQPushConsumer::setTcpTransportPullThreadNum(int num) {
+  impl->setTcpTransportPullThreadNum(num);
 }
-
-int DefaultMQPushConsumer::getConsumeMessageBatchMaxSize() const {
-  return m_consumeMessageBatchMaxSize;
+const int DefaultMQPushConsumer::getTcpTransportPullThreadNum() const {
+  return impl->getTcpTransportPullThreadNum();
 }
 
-void DefaultMQPushConsumer::setConsumeMessageBatchMaxSize(int consumeMessageBatchMaxSize) {
-  if (consumeMessageBatchMaxSize >= 1)
-    m_consumeMessageBatchMaxSize = consumeMessageBatchMaxSize;
+void DefaultMQPushConsumer::setTcpTransportConnectTimeout(uint64_t timeout) {
+  impl->setTcpTransportConnectTimeout(timeout);
 }
-
-void DefaultMQPushConsumer::setMaxCacheMsgSizePerQueue(int maxCacheSize) {
-  if (maxCacheSize > 0 && maxCacheSize < 65535) {
-    LOG_INFO("set maxCacheSize to:%d for consumer:%s", maxCacheSize, getGroupName().c_str());
-    m_maxMsgCacheSize = maxCacheSize;
-  }
+const uint64_t DefaultMQPushConsumer::getTcpTransportConnectTimeout() const {
+  return impl->getTcpTransportConnectTimeout();
 }
-
-int DefaultMQPushConsumer::getMaxCacheMsgSizePerQueue() const {
-  return m_maxMsgCacheSize;
+void DefaultMQPushConsumer::setTcpTransportTryLockTimeout(uint64_t timeout) {
+  impl->setTcpTransportTryLockTimeout(timeout);
 }
-
-ConsumerRunningInfo* DefaultMQPushConsumer::getConsumerRunningInfo() {
-  auto* info = new ConsumerRunningInfo();
-  if (m_consumerService->getConsumeMsgSerivceListenerType() == messageListenerOrderly) {
-    info->setProperty(ConsumerRunningInfo::PROP_CONSUME_ORDERLY, "true");
-  } else {
-    info->setProperty(ConsumerRunningInfo::PROP_CONSUME_ORDERLY, "false");
-  }
-  info->setProperty(ConsumerRunningInfo::PROP_THREADPOOL_CORE_SIZE, UtilAll::to_string(m_consumeThreadCount));
-  info->setProperty(ConsumerRunningInfo::PROP_CONSUMER_START_TIMESTAMP, UtilAll::to_string(m_startTime));
-
-  std::vector<SubscriptionData> result;
-  getSubscriptions(result);
-  info->setSubscriptionSet(result);
-
-  std::map<MQMessageQueue, boost::shared_ptr<PullRequest>> requestTable = m_pRebalance->getPullRequestTable();
-
-  for (const auto& it : requestTable) {
-    if (!it.second->isDropped()) {
-      MessageQueue queue((it.first).getTopic(), (it.first).getBrokerName(), (it.first).getQueueId());
-      ProcessQueueInfo processQueue;
-      processQueue.cachedMsgMinOffset = it.second->getCacheMinOffset();
-      processQueue.cachedMsgMaxOffset = it.second->getCacheMaxOffset();
-      processQueue.cachedMsgCount = it.second->getCacheMsgCount();
-      processQueue.setCommitOffset(
-          m_pOffsetStore->readOffset(it.first, MEMORY_FIRST_THEN_STORE, getSessionCredentials()));
-      processQueue.setDroped(it.second->isDropped());
-      processQueue.setLocked(it.second->isLocked());
-      processQueue.lastLockTimestamp = it.second->getLastLockTimestamp();
-      processQueue.lastPullTimestamp = it.second->getLastPullTimestamp();
-      processQueue.lastConsumeTimestamp = it.second->getLastConsumeTimestamp();
-      info->setMqTable(queue, processQueue);
-    }
-  }
-
-  return info;
+const uint64_t DefaultMQPushConsumer::getTcpTransportTryLockTimeout() const {
+  return impl->getTcpTransportTryLockTimeout();
 }
-// we should deal with name space before producer start.
-bool DefaultMQPushConsumer::dealWithNameSpace() {
-  string ns = getNameSpace();
-  if (ns.empty()) {
-    string nsAddr = getNamesrvAddr();
-    if (!NameSpaceUtil::checkNameSpaceExistInNameServer(nsAddr)) {
-      return true;
-    }
-    ns = NameSpaceUtil::getNameSpaceFromNsURL(nsAddr);
-    // reset namespace
-    setNameSpace(ns);
-  }
-  // reset group name
-  if (!NameSpaceUtil::hasNameSpace(getGroupName(), ns)) {
-    string fullGID = NameSpaceUtil::withNameSpace(getGroupName(), ns);
-    setGroupName(fullGID);
-  }
-  map<string, string> subTmp;
-  map<string, string>::iterator it = m_subTopics.begin();
-  for (; it != m_subTopics.end(); ++it) {
-    string topic = it->first;
-    string subs = it->second;
-    if (!NameSpaceUtil::hasNameSpace(topic, ns)) {
-      LOG_INFO("Update Subscribe[%s:%s] with NameSpace:%s", it->first.c_str(), it->second.c_str(), ns.c_str());
-      topic = NameSpaceUtil::withNameSpace(topic, ns);
-      // let other mode to known, the name space model opened.
-      m_useNameSpaceMode = true;
-    }
-    subTmp[topic] = subs;
-  }
-  m_subTopics.swap(subTmp);
-
-  return true;
+void DefaultMQPushConsumer::setAsyncPull(bool asyncFlag) {
+  impl->setAsyncPull(asyncFlag);
 }
 //<!************************************************************************
 }  // namespace rocketmq
diff --git a/src/consumer/DefaultMQPushConsumer.cpp b/src/consumer/DefaultMQPushConsumerImpl.cpp
similarity index 87%
copy from src/consumer/DefaultMQPushConsumer.cpp
copy to src/consumer/DefaultMQPushConsumerImpl.cpp
index 9da0ca8..54500bc 100644
--- a/src/consumer/DefaultMQPushConsumer.cpp
+++ b/src/consumer/DefaultMQPushConsumerImpl.cpp
@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-#include "DefaultMQPushConsumer.h"
+#include "DefaultMQPushConsumerImpl.h"
 #include "CommunicationMode.h"
 #include "ConsumeMsgService.h"
 #include "ConsumerRunningInfo.h"
@@ -36,7 +36,7 @@ namespace rocketmq {
 
 class AsyncPullCallback : public PullCallback {
  public:
-  AsyncPullCallback(DefaultMQPushConsumer* pushConsumer, boost::weak_ptr<PullRequest> request)
+  AsyncPullCallback(DefaultMQPushConsumerImpl* pushConsumer, boost::weak_ptr<PullRequest> request)
       : m_callbackOwner(pushConsumer), m_pullRequest(request), m_bShutdown(false) {}
 
   virtual ~AsyncPullCallback() { m_callbackOwner = NULL; }
@@ -185,7 +185,7 @@ class AsyncPullCallback : public PullCallback {
   void setPullRequest(boost::weak_ptr<PullRequest>& pullRequest) { m_pullRequest = pullRequest; }
 
  private:
-  DefaultMQPushConsumer* m_callbackOwner;
+  DefaultMQPushConsumerImpl* m_callbackOwner;
   boost::weak_ptr<PullRequest> m_pullRequest;
   bool m_bShutdown;
 };
@@ -193,7 +193,7 @@ class AsyncPullCallback : public PullCallback {
 //<!***************************************************************************
 static boost::mutex m_asyncCallbackLock;
 
-DefaultMQPushConsumer::DefaultMQPushConsumer(const string& groupname)
+DefaultMQPushConsumerImpl::DefaultMQPushConsumerImpl(const string& groupname)
     : m_consumeFromWhere(CONSUME_FROM_LAST_OFFSET),
       m_pOffsetStore(NULL),
       m_pRebalance(NULL),
@@ -214,11 +214,11 @@ DefaultMQPushConsumer::DefaultMQPushConsumer(const string& groupname)
   m_startTime = UtilAll::currentTimeMillis();
   m_consumeThreadCount = std::thread::hardware_concurrency();
   m_pullMsgThreadPoolNum = std::thread::hardware_concurrency();
-  m_async_service_thread.reset(new boost::thread(boost::bind(&DefaultMQPushConsumer::boost_asio_work, this)));
+  m_async_service_thread.reset(new boost::thread(boost::bind(&DefaultMQPushConsumerImpl::boost_asio_work, this)));
 }
 
-void DefaultMQPushConsumer::boost_asio_work() {
-  LOG_INFO("DefaultMQPushConsumer::boost asio async service runing");
+void DefaultMQPushConsumerImpl::boost_asio_work() {
+  LOG_INFO("DefaultMQPushConsumerImpl::boost asio async service runing");
   boost::asio::io_service::work work(m_async_ioService);  // avoid async io
   // service stops after
   // first timer timeout
@@ -226,7 +226,7 @@ void DefaultMQPushConsumer::boost_asio_work() {
   m_async_ioService.run();
 }
 
-DefaultMQPushConsumer::~DefaultMQPushConsumer() {
+DefaultMQPushConsumerImpl::~DefaultMQPushConsumerImpl() {
   m_pMessageListener = NULL;
   if (m_pullmsgQueue != NULL) {
     deleteAndZero(m_pullmsgQueue);
@@ -251,7 +251,7 @@ DefaultMQPushConsumer::~DefaultMQPushConsumer() {
   m_subTopics.clear();
 }
 
-bool DefaultMQPushConsumer::sendMessageBack(MQMessageExt& msg, int delayLevel, string& brokerName) {
+bool DefaultMQPushConsumerImpl::sendMessageBack(MQMessageExt& msg, int delayLevel, string& brokerName) {
   string brokerAddr;
   if (!brokerName.empty())
     brokerAddr = getFactory()->findBrokerAddressInPublish(brokerName);
@@ -267,7 +267,7 @@ bool DefaultMQPushConsumer::sendMessageBack(MQMessageExt& msg, int delayLevel, s
   return true;
 }
 
-void DefaultMQPushConsumer::fetchSubscribeMessageQueues(const string& topic, vector<MQMessageQueue>& mqs) {
+void DefaultMQPushConsumerImpl::fetchSubscribeMessageQueues(const string& topic, vector<MQMessageQueue>& mqs) {
   mqs.clear();
   try {
     getFactory()->fetchSubscribeMessageQueues(topic, mqs, getSessionCredentials());
@@ -276,7 +276,7 @@ void DefaultMQPushConsumer::fetchSubscribeMessageQueues(const string& topic, vec
   }
 }
 
-void DefaultMQPushConsumer::doRebalance() {
+void DefaultMQPushConsumerImpl::doRebalance() {
   if (isServiceStateOk()) {
     try {
       m_pRebalance->doRebalance();
@@ -286,19 +286,19 @@ void DefaultMQPushConsumer::doRebalance() {
   }
 }
 
-void DefaultMQPushConsumer::persistConsumerOffset() {
+void DefaultMQPushConsumerImpl::persistConsumerOffset() {
   if (isServiceStateOk()) {
     m_pRebalance->persistConsumerOffset();
   }
 }
 
-void DefaultMQPushConsumer::persistConsumerOffsetByResetOffset() {
+void DefaultMQPushConsumerImpl::persistConsumerOffsetByResetOffset() {
   if (isServiceStateOk()) {
     m_pRebalance->persistConsumerOffsetByResetOffset();
   }
 }
 
-void DefaultMQPushConsumer::start() {
+void DefaultMQPushConsumerImpl::start() {
 #ifndef WIN32
   /* Ignore the SIGPIPE */
   struct sigaction sa;
@@ -312,8 +312,8 @@ void DefaultMQPushConsumer::start() {
   switch (m_serviceState) {
     case CREATE_JUST: {
       m_serviceState = START_FAILED;
-      MQClient::start();
-      LOG_INFO("DefaultMQPushConsumer:%s start", m_GroupName.c_str());
+      DefaultMQClient::start();
+      LOG_INFO("DefaultMQPushConsumerImpl:%s start", m_GroupName.c_str());
 
       //<!data;
       checkConfig();
@@ -338,7 +338,7 @@ void DefaultMQPushConsumer::start() {
 
       m_pullmsgQueue = new TaskQueue(m_pullMsgThreadPoolNum);
       m_pullmsgThread.reset(
-          new boost::thread(boost::bind(&DefaultMQPushConsumer::runPullMsgQueue, this, m_pullmsgQueue)));
+          new boost::thread(boost::bind(&DefaultMQPushConsumerImpl::runPullMsgQueue, this, m_pullmsgQueue)));
 
       copySubscription();
 
@@ -393,10 +393,10 @@ void DefaultMQPushConsumer::start() {
   getFactory()->rebalanceImmediately();
 }
 
-void DefaultMQPushConsumer::shutdown() {
+void DefaultMQPushConsumerImpl::shutdown() {
   switch (m_serviceState) {
     case RUNNING: {
-      LOG_INFO("DefaultMQPushConsumer shutdown");
+      LOG_INFO("DefaultMQPushConsumerImpl shutdown");
       m_async_ioService.stop();
       m_async_service_thread->interrupt();
       m_async_service_thread->join();
@@ -419,36 +419,36 @@ void DefaultMQPushConsumer::shutdown() {
   }
 }
 
-void DefaultMQPushConsumer::registerMessageListener(MQMessageListener* pMessageListener) {
+void DefaultMQPushConsumerImpl::registerMessageListener(MQMessageListener* pMessageListener) {
   if (NULL != pMessageListener) {
     m_pMessageListener = pMessageListener;
   }
 }
 
-MessageListenerType DefaultMQPushConsumer::getMessageListenerType() {
+MessageListenerType DefaultMQPushConsumerImpl::getMessageListenerType() {
   if (NULL != m_pMessageListener) {
     return m_pMessageListener->getMessageListenerType();
   }
   return messageListenerDefaultly;
 }
 
-ConsumeMsgService* DefaultMQPushConsumer::getConsumerMsgService() const {
+ConsumeMsgService* DefaultMQPushConsumerImpl::getConsumerMsgService() const {
   return m_consumerService;
 }
 
-OffsetStore* DefaultMQPushConsumer::getOffsetStore() const {
+OffsetStore* DefaultMQPushConsumerImpl::getOffsetStore() const {
   return m_pOffsetStore;
 }
 
-Rebalance* DefaultMQPushConsumer::getRebalance() const {
+Rebalance* DefaultMQPushConsumerImpl::getRebalance() const {
   return m_pRebalance;
 }
 
-void DefaultMQPushConsumer::subscribe(const string& topic, const string& subExpression) {
+void DefaultMQPushConsumerImpl::subscribe(const string& topic, const string& subExpression) {
   m_subTopics[topic] = subExpression;
 }
 
-void DefaultMQPushConsumer::checkConfig() {
+void DefaultMQPushConsumerImpl::checkConfig() {
   string groupname = getGroupName();
   // check consumerGroup
   Validators::checkGroup(groupname);
@@ -467,7 +467,7 @@ void DefaultMQPushConsumer::checkConfig() {
   }
 }
 
-void DefaultMQPushConsumer::copySubscription() {
+void DefaultMQPushConsumerImpl::copySubscription() {
   map<string, string>::iterator it = m_subTopics.begin();
   for (; it != m_subTopics.end(); ++it) {
     LOG_INFO("buildSubscriptionData,:%s,%s", it->first.c_str(), it->second.c_str());
@@ -493,11 +493,11 @@ void DefaultMQPushConsumer::copySubscription() {
   }
 }
 
-void DefaultMQPushConsumer::updateTopicSubscribeInfo(const string& topic, vector<MQMessageQueue>& info) {
+void DefaultMQPushConsumerImpl::updateTopicSubscribeInfo(const string& topic, vector<MQMessageQueue>& info) {
   m_pRebalance->setTopicSubscribeInfo(topic, info);
 }
 
-void DefaultMQPushConsumer::updateTopicSubscribeInfoWhenSubscriptionChanged() {
+void DefaultMQPushConsumerImpl::updateTopicSubscribeInfoWhenSubscriptionChanged() {
   map<string, SubscriptionData*>& subTable = m_pRebalance->getSubscriptionInner();
   map<string, SubscriptionData*>::iterator it = subTable.begin();
   for (; it != subTable.end(); ++it) {
@@ -508,19 +508,19 @@ void DefaultMQPushConsumer::updateTopicSubscribeInfoWhenSubscriptionChanged() {
   }
 }
 
-ConsumeType DefaultMQPushConsumer::getConsumeType() {
+ConsumeType DefaultMQPushConsumerImpl::getConsumeType() {
   return CONSUME_PASSIVELY;
 }
 
-ConsumeFromWhere DefaultMQPushConsumer::getConsumeFromWhere() {
+ConsumeFromWhere DefaultMQPushConsumerImpl::getConsumeFromWhere() {
   return m_consumeFromWhere;
 }
 
-void DefaultMQPushConsumer::setConsumeFromWhere(ConsumeFromWhere consumeFromWhere) {
+void DefaultMQPushConsumerImpl::setConsumeFromWhere(ConsumeFromWhere consumeFromWhere) {
   m_consumeFromWhere = consumeFromWhere;
 }
 
-void DefaultMQPushConsumer::getSubscriptions(vector<SubscriptionData>& result) {
+void DefaultMQPushConsumerImpl::getSubscriptions(vector<SubscriptionData>& result) {
   map<string, SubscriptionData*>& subTable = m_pRebalance->getSubscriptionInner();
   map<string, SubscriptionData*>::iterator it = subTable.begin();
   for (; it != subTable.end(); ++it) {
@@ -528,7 +528,7 @@ void DefaultMQPushConsumer::getSubscriptions(vector<SubscriptionData>& result) {
   }
 }
 
-void DefaultMQPushConsumer::updateConsumeOffset(const MQMessageQueue& mq, int64 offset) {
+void DefaultMQPushConsumerImpl::updateConsumeOffset(const MQMessageQueue& mq, int64 offset) {
   if (offset >= 0) {
     m_pOffsetStore->updateOffset(mq, offset);
   } else {
@@ -536,25 +536,25 @@ void DefaultMQPushConsumer::updateConsumeOffset(const MQMessageQueue& mq, int64
   }
 }
 
-void DefaultMQPushConsumer::removeConsumeOffset(const MQMessageQueue& mq) {
+void DefaultMQPushConsumerImpl::removeConsumeOffset(const MQMessageQueue& mq) {
   m_pOffsetStore->removeOffset(mq);
 }
 
-void DefaultMQPushConsumer::static_triggerNextPullRequest(void* context,
-                                                          boost::asio::deadline_timer* t,
-                                                          boost::weak_ptr<PullRequest> pullRequest) {
+void DefaultMQPushConsumerImpl::static_triggerNextPullRequest(void* context,
+                                                              boost::asio::deadline_timer* t,
+                                                              boost::weak_ptr<PullRequest> pullRequest) {
   if (pullRequest.expired()) {
     LOG_WARN("Pull request has been released before.");
     return;
   }
-  DefaultMQPushConsumer* pDefaultMQPushConsumer = (DefaultMQPushConsumer*)context;
-  if (pDefaultMQPushConsumer) {
-    pDefaultMQPushConsumer->triggerNextPullRequest(t, pullRequest);
+  DefaultMQPushConsumerImpl* pDefaultMQPushConsumerImpl = (DefaultMQPushConsumerImpl*)context;
+  if (pDefaultMQPushConsumerImpl) {
+    pDefaultMQPushConsumerImpl->triggerNextPullRequest(t, pullRequest);
   }
 }
 
-void DefaultMQPushConsumer::triggerNextPullRequest(boost::asio::deadline_timer* t,
-                                                   boost::weak_ptr<PullRequest> pullRequest) {
+void DefaultMQPushConsumerImpl::triggerNextPullRequest(boost::asio::deadline_timer* t,
+                                                       boost::weak_ptr<PullRequest> pullRequest) {
   // delete first to avoild memleak
   deleteAndZero(t);
   boost::shared_ptr<PullRequest> request = pullRequest.lock();
@@ -565,7 +565,7 @@ void DefaultMQPushConsumer::triggerNextPullRequest(boost::asio::deadline_timer*
   producePullMsgTask(request);
 }
 
-bool DefaultMQPushConsumer::producePullMsgTaskLater(boost::weak_ptr<PullRequest> pullRequest, int millis) {
+bool DefaultMQPushConsumerImpl::producePullMsgTaskLater(boost::weak_ptr<PullRequest> pullRequest, int millis) {
   boost::shared_ptr<PullRequest> request = pullRequest.lock();
   if (!request) {
     LOG_INFO("Pull request is invalid. Maybe it is dropped before.");
@@ -578,7 +578,7 @@ bool DefaultMQPushConsumer::producePullMsgTaskLater(boost::weak_ptr<PullRequest>
   if (m_pullmsgQueue->bTaskQueueStatusOK() && isServiceStateOk()) {
     boost::asio::deadline_timer* t =
         new boost::asio::deadline_timer(m_async_ioService, boost::posix_time::milliseconds(millis));
-    t->async_wait(boost::bind(&(DefaultMQPushConsumer::static_triggerNextPullRequest), this, t, request));
+    t->async_wait(boost::bind(&(DefaultMQPushConsumerImpl::static_triggerNextPullRequest), this, t, request));
     LOG_INFO("Produce Pull request [%s] Later and Sleep [%d]ms.", (request->m_messageQueue).toString().c_str(), millis);
     return true;
   } else {
@@ -588,7 +588,7 @@ bool DefaultMQPushConsumer::producePullMsgTaskLater(boost::weak_ptr<PullRequest>
   }
 }
 
-bool DefaultMQPushConsumer::producePullMsgTask(boost::weak_ptr<PullRequest> pullRequest) {
+bool DefaultMQPushConsumerImpl::producePullMsgTask(boost::weak_ptr<PullRequest> pullRequest) {
   boost::shared_ptr<PullRequest> request = pullRequest.lock();
   if (!request) {
     LOG_WARN("Pull request has been released.");
@@ -600,9 +600,9 @@ bool DefaultMQPushConsumer::producePullMsgTask(boost::weak_ptr<PullRequest> pull
   }
   if (m_pullmsgQueue->bTaskQueueStatusOK() && isServiceStateOk()) {
     if (m_asyncPull) {
-      m_pullmsgQueue->produce(TaskBinder::gen(&DefaultMQPushConsumer::pullMessageAsync, this, request));
+      m_pullmsgQueue->produce(TaskBinder::gen(&DefaultMQPushConsumerImpl::pullMessageAsync, this, request));
     } else {
-      m_pullmsgQueue->produce(TaskBinder::gen(&DefaultMQPushConsumer::pullMessage, this, request));
+      m_pullmsgQueue->produce(TaskBinder::gen(&DefaultMQPushConsumerImpl::pullMessage, this, request));
     }
   } else {
     LOG_WARN("produce PullRequest of mq:%s failed", request->m_messageQueue.toString().c_str());
@@ -611,11 +611,11 @@ bool DefaultMQPushConsumer::producePullMsgTask(boost::weak_ptr<PullRequest> pull
   return true;
 }
 
-void DefaultMQPushConsumer::runPullMsgQueue(TaskQueue* pTaskQueue) {
+void DefaultMQPushConsumerImpl::runPullMsgQueue(TaskQueue* pTaskQueue) {
   pTaskQueue->run();
 }
 
-void DefaultMQPushConsumer::pullMessage(boost::weak_ptr<PullRequest> pullRequest) {
+void DefaultMQPushConsumerImpl::pullMessage(boost::weak_ptr<PullRequest> pullRequest) {
   boost::shared_ptr<PullRequest> request = pullRequest.lock();
   if (!request) {
     LOG_ERROR("Pull request is released, return");
@@ -771,8 +771,8 @@ void DefaultMQPushConsumer::pullMessage(boost::weak_ptr<PullRequest> pullRequest
   }
 }
 
-AsyncPullCallback* DefaultMQPushConsumer::getAsyncPullCallBack(boost::weak_ptr<PullRequest> pullRequest,
-                                                               MQMessageQueue msgQueue) {
+AsyncPullCallback* DefaultMQPushConsumerImpl::getAsyncPullCallBack(boost::weak_ptr<PullRequest> pullRequest,
+                                                                   MQMessageQueue msgQueue) {
   boost::shared_ptr<PullRequest> request = pullRequest.lock();
   if (!request) {
     return NULL;
@@ -794,7 +794,7 @@ AsyncPullCallback* DefaultMQPushConsumer::getAsyncPullCallBack(boost::weak_ptr<P
   return NULL;
 }
 
-void DefaultMQPushConsumer::shutdownAsyncPullCallBack() {
+void DefaultMQPushConsumerImpl::shutdownAsyncPullCallBack() {
   boost::lock_guard<boost::mutex> lock(m_asyncCallbackLock);
   if (m_asyncPull) {
     PullMAP::iterator it = m_PullCallback.begin();
@@ -808,7 +808,7 @@ void DefaultMQPushConsumer::shutdownAsyncPullCallBack() {
   }
 }
 
-void DefaultMQPushConsumer::pullMessageAsync(boost::weak_ptr<PullRequest> pullRequest) {
+void DefaultMQPushConsumerImpl::pullMessageAsync(boost::weak_ptr<PullRequest> pullRequest) {
   boost::shared_ptr<PullRequest> request = pullRequest.lock();
   if (!request) {
     LOG_ERROR("Pull request is released, return");
@@ -904,7 +904,7 @@ void DefaultMQPushConsumer::pullMessageAsync(boost::weak_ptr<PullRequest> pullRe
   }
 }
 
-void DefaultMQPushConsumer::setAsyncPull(bool asyncFlag) {
+void DefaultMQPushConsumerImpl::setAsyncPull(bool asyncFlag) {
   if (asyncFlag) {
     LOG_INFO("set pushConsumer:%s to async default pull mode", getGroupName().c_str());
   } else {
@@ -913,7 +913,7 @@ void DefaultMQPushConsumer::setAsyncPull(bool asyncFlag) {
   m_asyncPull = asyncFlag;
 }
 
-void DefaultMQPushConsumer::setConsumeThreadCount(int threadCount) {
+void DefaultMQPushConsumerImpl::setConsumeThreadCount(int threadCount) {
   if (threadCount > 0) {
     m_consumeThreadCount = threadCount;
   } else {
@@ -921,10 +921,10 @@ void DefaultMQPushConsumer::setConsumeThreadCount(int threadCount) {
   }
 }
 
-int DefaultMQPushConsumer::getConsumeThreadCount() const {
+int DefaultMQPushConsumerImpl::getConsumeThreadCount() const {
   return m_consumeThreadCount;
 }
-void DefaultMQPushConsumer::setMaxReconsumeTimes(int maxReconsumeTimes) {
+void DefaultMQPushConsumerImpl::setMaxReconsumeTimes(int maxReconsumeTimes) {
   if (maxReconsumeTimes > 0) {
     m_maxReconsumeTimes = maxReconsumeTimes;
   } else {
@@ -932,7 +932,7 @@ void DefaultMQPushConsumer::setMaxReconsumeTimes(int maxReconsumeTimes) {
   }
 }
 
-int DefaultMQPushConsumer::getMaxReconsumeTimes() const {
+int DefaultMQPushConsumerImpl::getMaxReconsumeTimes() const {
   if (m_maxReconsumeTimes >= 0) {
     return m_maxReconsumeTimes;
   }
@@ -940,35 +940,35 @@ int DefaultMQPushConsumer::getMaxReconsumeTimes() const {
   return 16;
 }
 
-void DefaultMQPushConsumer::setPullMsgThreadPoolCount(int threadCount) {
+void DefaultMQPushConsumerImpl::setPullMsgThreadPoolCount(int threadCount) {
   m_pullMsgThreadPoolNum = threadCount;
 }
 
-int DefaultMQPushConsumer::getPullMsgThreadPoolCount() const {
+int DefaultMQPushConsumerImpl::getPullMsgThreadPoolCount() const {
   return m_pullMsgThreadPoolNum;
 }
 
-int DefaultMQPushConsumer::getConsumeMessageBatchMaxSize() const {
+int DefaultMQPushConsumerImpl::getConsumeMessageBatchMaxSize() const {
   return m_consumeMessageBatchMaxSize;
 }
 
-void DefaultMQPushConsumer::setConsumeMessageBatchMaxSize(int consumeMessageBatchMaxSize) {
+void DefaultMQPushConsumerImpl::setConsumeMessageBatchMaxSize(int consumeMessageBatchMaxSize) {
   if (consumeMessageBatchMaxSize >= 1)
     m_consumeMessageBatchMaxSize = consumeMessageBatchMaxSize;
 }
 
-void DefaultMQPushConsumer::setMaxCacheMsgSizePerQueue(int maxCacheSize) {
+void DefaultMQPushConsumerImpl::setMaxCacheMsgSizePerQueue(int maxCacheSize) {
   if (maxCacheSize > 0 && maxCacheSize < 65535) {
     LOG_INFO("set maxCacheSize to:%d for consumer:%s", maxCacheSize, getGroupName().c_str());
     m_maxMsgCacheSize = maxCacheSize;
   }
 }
 
-int DefaultMQPushConsumer::getMaxCacheMsgSizePerQueue() const {
+int DefaultMQPushConsumerImpl::getMaxCacheMsgSizePerQueue() const {
   return m_maxMsgCacheSize;
 }
 
-ConsumerRunningInfo* DefaultMQPushConsumer::getConsumerRunningInfo() {
+ConsumerRunningInfo* DefaultMQPushConsumerImpl::getConsumerRunningInfo() {
   auto* info = new ConsumerRunningInfo();
   if (m_consumerService->getConsumeMsgSerivceListenerType() == messageListenerOrderly) {
     info->setProperty(ConsumerRunningInfo::PROP_CONSUME_ORDERLY, "true");
@@ -1005,7 +1005,7 @@ ConsumerRunningInfo* DefaultMQPushConsumer::getConsumerRunningInfo() {
   return info;
 }
 // we should deal with name space before producer start.
-bool DefaultMQPushConsumer::dealWithNameSpace() {
+bool DefaultMQPushConsumerImpl::dealWithNameSpace() {
   string ns = getNameSpace();
   if (ns.empty()) {
     string nsAddr = getNamesrvAddr();
diff --git a/include/DefaultMQPushConsumer.h b/src/consumer/DefaultMQPushConsumerImpl.h
similarity index 93%
copy from include/DefaultMQPushConsumer.h
copy to src/consumer/DefaultMQPushConsumerImpl.h
index 7f69258..f90b6cd 100644
--- a/include/DefaultMQPushConsumer.h
+++ b/src/consumer/DefaultMQPushConsumerImpl.h
@@ -1,165 +1,165 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef __DEFAULTMQPUSHCONSUMER_H__
-#define __DEFAULTMQPUSHCONSUMER_H__
-
-#include <boost/asio.hpp>
-#include <boost/asio/io_service.hpp>
-#include <boost/bind.hpp>
-#include <boost/date_time/posix_time/posix_time.hpp>
-#include <boost/scoped_ptr.hpp>
-#include <boost/thread/thread.hpp>
-#include <string>
-#include "AsyncCallback.h"
-#include "MQConsumer.h"
-#include "MQMessageListener.h"
-#include "MQMessageQueue.h"
-
-namespace rocketmq {
-
-class Rebalance;
-class SubscriptionData;
-class OffsetStore;
-class PullAPIWrapper;
-class PullRequest;
-class ConsumeMsgService;
-class TaskQueue;
-class TaskThread;
-class AsyncPullCallback;
-class ConsumerRunningInfo;
-//<!***************************************************************************
-class ROCKETMQCLIENT_API DefaultMQPushConsumer : public MQConsumer {
- public:
-  DefaultMQPushConsumer(const std::string& groupname);
-  void boost_asio_work();
-  virtual ~DefaultMQPushConsumer();
-
-  //<!begin mqadmin;
-  virtual void start();
-  virtual void shutdown();
-  //<!end mqadmin;
-
-  //<!begin MQConsumer
-  virtual bool sendMessageBack(MQMessageExt& msg, int delayLevel, std::string& brokerName);
-  virtual void fetchSubscribeMessageQueues(const std::string& topic, std::vector<MQMessageQueue>& mqs);
-  virtual void doRebalance();
-  virtual void persistConsumerOffset();
-  virtual void persistConsumerOffsetByResetOffset();
-  virtual void updateTopicSubscribeInfo(const std::string& topic, std::vector<MQMessageQueue>& info);
-  virtual ConsumeType getConsumeType();
-  virtual ConsumeFromWhere getConsumeFromWhere();
-  void setConsumeFromWhere(ConsumeFromWhere consumeFromWhere);
-  virtual void getSubscriptions(std::vector<SubscriptionData>&);
-  virtual void updateConsumeOffset(const MQMessageQueue& mq, int64 offset);
-  virtual void removeConsumeOffset(const MQMessageQueue& mq);
-  virtual PullResult pull(const MQMessageQueue& mq, const std::string& subExpression, int64 offset, int maxNums) {
-    return PullResult();
-  }
-  virtual void pull(const MQMessageQueue& mq,
-                    const std::string& subExpression,
-                    int64 offset,
-                    int maxNums,
-                    PullCallback* pPullCallback) {}
-  virtual ConsumerRunningInfo* getConsumerRunningInfo();
-  //<!end MQConsumer;
-
-  void registerMessageListener(MQMessageListener* pMessageListener);
-  MessageListenerType getMessageListenerType();
-  void subscribe(const std::string& topic, const std::string& subExpression);
-
-  OffsetStore* getOffsetStore() const;
-  virtual Rebalance* getRebalance() const;
-  ConsumeMsgService* getConsumerMsgService() const;
-
-  virtual bool producePullMsgTask(boost::weak_ptr<PullRequest>);
-  virtual bool producePullMsgTaskLater(boost::weak_ptr<PullRequest>, int millis);
-  static void static_triggerNextPullRequest(void* context,
-                                            boost::asio::deadline_timer* t,
-                                            boost::weak_ptr<PullRequest>);
-  void triggerNextPullRequest(boost::asio::deadline_timer* t, boost::weak_ptr<PullRequest>);
-  void runPullMsgQueue(TaskQueue* pTaskQueue);
-  void pullMessage(boost::weak_ptr<PullRequest> pullrequest);
-  void pullMessageAsync(boost::weak_ptr<PullRequest> pullrequest);
-  void setAsyncPull(bool asyncFlag);
-  AsyncPullCallback* getAsyncPullCallBack(boost::weak_ptr<PullRequest>, MQMessageQueue msgQueue);
-  void shutdownAsyncPullCallBack();
-
-  /*
-    for orderly consume, set the pull num of message size by each pullMsg,
-    default value is 1;
-  */
-  void setConsumeMessageBatchMaxSize(int consumeMessageBatchMaxSize);
-  int getConsumeMessageBatchMaxSize() const;
-
-  /*
-    set consuming thread count, default value is cpu cores
-  */
-  void setConsumeThreadCount(int threadCount);
-  int getConsumeThreadCount() const;
-  void setMaxReconsumeTimes(int maxReconsumeTimes);
-  int getMaxReconsumeTimes() const;
-
-  /*
-    set pullMsg thread count, default value is cpu cores
-  */
-  void setPullMsgThreadPoolCount(int threadCount);
-  int getPullMsgThreadPoolCount() const;
-
-  /*
-    set max cache msg size perQueue in memory if consumer could not consume msgs
-    immediately
-    default maxCacheMsgSize perQueue is 1000, set range is:1~65535
-  */
-  void setMaxCacheMsgSizePerQueue(int maxCacheSize);
-  int getMaxCacheMsgSizePerQueue() const;
-
- private:
-  void checkConfig();
-  void copySubscription();
-  void updateTopicSubscribeInfoWhenSubscriptionChanged();
-  bool dealWithNameSpace();
-
- private:
-  uint64_t m_startTime;
-  ConsumeFromWhere m_consumeFromWhere;
-  std::map<std::string, std::string> m_subTopics;
-  int m_consumeThreadCount;
-  OffsetStore* m_pOffsetStore;
-  Rebalance* m_pRebalance;
-  PullAPIWrapper* m_pPullAPIWrapper;
-  ConsumeMsgService* m_consumerService;
-  MQMessageListener* m_pMessageListener;
-  int m_consumeMessageBatchMaxSize;
-  int m_maxMsgCacheSize;
-  int m_maxReconsumeTimes = -1;
-  boost::asio::io_service m_async_ioService;
-  boost::scoped_ptr<boost::thread> m_async_service_thread;
-
-  typedef std::map<MQMessageQueue, AsyncPullCallback*> PullMAP;
-  PullMAP m_PullCallback;
-  bool m_asyncPull;
-  int m_asyncPullTimeout;
-  int m_pullMsgThreadPoolNum;
-
- private:
-  TaskQueue* m_pullmsgQueue;
-  std::unique_ptr<boost::thread> m_pullmsgThread;
-};
-//<!***************************************************************************
-}  // namespace rocketmq
-#endif
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __DEFAULTMQPUSHCONSUMERIMPL_H__
+#define __DEFAULTMQPUSHCONSUMERIMPL_H__
+
+#include <boost/asio.hpp>
+#include <boost/asio/io_service.hpp>
+#include <boost/bind.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+#include <boost/scoped_ptr.hpp>
+#include <boost/thread/thread.hpp>
+#include <string>
+#include "AsyncCallback.h"
+#include "MQConsumer.h"
+#include "MQMessageListener.h"
+#include "MQMessageQueue.h"
+
+namespace rocketmq {
+
+class Rebalance;
+class SubscriptionData;
+class OffsetStore;
+class PullAPIWrapper;
+class PullRequest;
+class ConsumeMsgService;
+class TaskQueue;
+class TaskThread;
+class AsyncPullCallback;
+class ConsumerRunningInfo;
+//<!***************************************************************************
+class DefaultMQPushConsumerImpl : public MQConsumer {
+ public:
+  DefaultMQPushConsumerImpl(const std::string& groupname);
+  void boost_asio_work();
+  virtual ~DefaultMQPushConsumerImpl();
+
+  //<!begin mqadmin;
+  virtual void start();
+  virtual void shutdown();
+  //<!end mqadmin;
+
+  //<!begin MQConsumer
+  virtual bool sendMessageBack(MQMessageExt& msg, int delayLevel, std::string& brokerName);
+  virtual void fetchSubscribeMessageQueues(const std::string& topic, std::vector<MQMessageQueue>& mqs);
+  virtual void doRebalance();
+  virtual void persistConsumerOffset();
+  virtual void persistConsumerOffsetByResetOffset();
+  virtual void updateTopicSubscribeInfo(const std::string& topic, std::vector<MQMessageQueue>& info);
+  virtual ConsumeType getConsumeType();
+  virtual ConsumeFromWhere getConsumeFromWhere();
+  void setConsumeFromWhere(ConsumeFromWhere consumeFromWhere);
+  virtual void getSubscriptions(std::vector<SubscriptionData>&);
+  virtual void updateConsumeOffset(const MQMessageQueue& mq, int64 offset);
+  virtual void removeConsumeOffset(const MQMessageQueue& mq);
+  virtual PullResult pull(const MQMessageQueue& mq, const std::string& subExpression, int64 offset, int maxNums) {
+    return PullResult();
+  }
+  virtual void pull(const MQMessageQueue& mq,
+                    const std::string& subExpression,
+                    int64 offset,
+                    int maxNums,
+                    PullCallback* pPullCallback) {}
+  virtual ConsumerRunningInfo* getConsumerRunningInfo();
+  //<!end MQConsumer;
+
+  void registerMessageListener(MQMessageListener* pMessageListener);
+  MessageListenerType getMessageListenerType();
+  void subscribe(const std::string& topic, const std::string& subExpression);
+
+  OffsetStore* getOffsetStore() const;
+  virtual Rebalance* getRebalance() const;
+  ConsumeMsgService* getConsumerMsgService() const;
+
+  virtual bool producePullMsgTask(boost::weak_ptr<PullRequest>);
+  virtual bool producePullMsgTaskLater(boost::weak_ptr<PullRequest>, int millis);
+  static void static_triggerNextPullRequest(void* context,
+                                            boost::asio::deadline_timer* t,
+                                            boost::weak_ptr<PullRequest>);
+  void triggerNextPullRequest(boost::asio::deadline_timer* t, boost::weak_ptr<PullRequest>);
+  void runPullMsgQueue(TaskQueue* pTaskQueue);
+  void pullMessage(boost::weak_ptr<PullRequest> pullrequest);
+  void pullMessageAsync(boost::weak_ptr<PullRequest> pullrequest);
+  void setAsyncPull(bool asyncFlag);
+  AsyncPullCallback* getAsyncPullCallBack(boost::weak_ptr<PullRequest>, MQMessageQueue msgQueue);
+  void shutdownAsyncPullCallBack();
+
+  /*
+    for orderly consume, set the pull num of message size by each pullMsg,
+    default value is 1;
+  */
+  void setConsumeMessageBatchMaxSize(int consumeMessageBatchMaxSize);
+  int getConsumeMessageBatchMaxSize() const;
+
+  /*
+    set consuming thread count, default value is cpu cores
+  */
+  void setConsumeThreadCount(int threadCount);
+  int getConsumeThreadCount() const;
+  void setMaxReconsumeTimes(int maxReconsumeTimes);
+  int getMaxReconsumeTimes() const;
+
+  /*
+    set pullMsg thread count, default value is cpu cores
+  */
+  void setPullMsgThreadPoolCount(int threadCount);
+  int getPullMsgThreadPoolCount() const;
+
+  /*
+    set max cache msg size perQueue in memory if consumer could not consume msgs
+    immediately
+    default maxCacheMsgSize perQueue is 1000, set range is:1~65535
+  */
+  void setMaxCacheMsgSizePerQueue(int maxCacheSize);
+  int getMaxCacheMsgSizePerQueue() const;
+
+ private:
+  void checkConfig();
+  void copySubscription();
+  void updateTopicSubscribeInfoWhenSubscriptionChanged();
+  bool dealWithNameSpace();
+
+ private:
+  uint64_t m_startTime;
+  ConsumeFromWhere m_consumeFromWhere;
+  std::map<std::string, std::string> m_subTopics;
+  int m_consumeThreadCount;
+  OffsetStore* m_pOffsetStore;
+  Rebalance* m_pRebalance;
+  PullAPIWrapper* m_pPullAPIWrapper;
+  ConsumeMsgService* m_consumerService;
+  MQMessageListener* m_pMessageListener;
+  int m_consumeMessageBatchMaxSize;
+  int m_maxMsgCacheSize;
+  int m_maxReconsumeTimes = -1;
+  boost::asio::io_service m_async_ioService;
+  boost::scoped_ptr<boost::thread> m_async_service_thread;
+
+  typedef std::map<MQMessageQueue, AsyncPullCallback*> PullMAP;
+  PullMAP m_PullCallback;
+  bool m_asyncPull;
+  int m_asyncPullTimeout;
+  int m_pullMsgThreadPoolNum;
+
+ private:
+  TaskQueue* m_pullmsgQueue;
+  std::unique_ptr<boost::thread> m_pullmsgThread;
+};
+//<!***************************************************************************
+}  // namespace rocketmq
+#endif
diff --git a/src/consumer/Rebalance.cpp b/src/consumer/Rebalance.cpp
index 5546b61..f930362 100644
--- a/src/consumer/Rebalance.cpp
+++ b/src/consumer/Rebalance.cpp
@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 #include "Rebalance.h"
-#include "DefaultMQPushConsumer.h"
+#include "DefaultMQPushConsumerImpl.h"
 #include "LockBatchBody.h"
 #include "Logging.h"
 #include "MQClientAPIImpl.h"
@@ -150,7 +150,7 @@ void Rebalance::doRebalance() {
 }
 
 void Rebalance::persistConsumerOffset() {
-  DefaultMQPushConsumer* pConsumer = static_cast<DefaultMQPushConsumer*>(m_pConsumer);
+  DefaultMQPushConsumerImpl* pConsumer = static_cast<DefaultMQPushConsumerImpl*>(m_pConsumer);
   OffsetStore* pOffsetStore = pConsumer->getOffsetStore();
   vector<MQMessageQueue> mqs;
   {
@@ -174,7 +174,7 @@ void Rebalance::persistConsumerOffset() {
 }
 
 void Rebalance::persistConsumerOffsetByResetOffset() {
-  DefaultMQPushConsumer* pConsumer = static_cast<DefaultMQPushConsumer*>(m_pConsumer);
+  DefaultMQPushConsumerImpl* pConsumer = static_cast<DefaultMQPushConsumerImpl*>(m_pConsumer);
   OffsetStore* pOffsetStore = pConsumer->getOffsetStore();
   vector<MQMessageQueue> mqs;
   {
@@ -552,7 +552,7 @@ bool RebalancePush::updateRequestTableInRebalance(const string& topic, vector<MQ
 
 int64 RebalancePush::computePullFromWhere(const MQMessageQueue& mq) {
   int64 result = -1;
-  DefaultMQPushConsumer* pConsumer = dynamic_cast<DefaultMQPushConsumer*>(m_pConsumer);
+  DefaultMQPushConsumerImpl* pConsumer = dynamic_cast<DefaultMQPushConsumerImpl*>(m_pConsumer);
   if (!pConsumer) {
     LOG_ERROR("Cast consumer pointer to DefaultMQPushConsumer pointer failed when computePullFromWhere %s",
               mq.toString().c_str());
@@ -639,7 +639,7 @@ void RebalancePush::messageQueueChanged(const string& topic,
 
 void RebalancePush::removeUnnecessaryMessageQueue(const MQMessageQueue& mq) {
   // DefaultMQPushConsumer *pConsumer = static_cast<DefaultMQPushConsumer *>(m_pConsumer);
-  DefaultMQPushConsumer* pConsumer = dynamic_cast<DefaultMQPushConsumer*>(m_pConsumer);
+  DefaultMQPushConsumerImpl* pConsumer = dynamic_cast<DefaultMQPushConsumerImpl*>(m_pConsumer);
   if (!pConsumer) {
     LOG_ERROR("Cast  MQConsumer* to DefaultMQPushConsumer* failed when remove %s", mq.toString().c_str());
     return;
diff --git a/src/extern/CMessageExt.cpp b/src/extern/CMessageExt.cpp
index 03a5e2d..a013b84 100644
--- a/src/extern/CMessageExt.cpp
+++ b/src/extern/CMessageExt.cpp
@@ -15,9 +15,9 @@
  * limitations under the License.
  */
 
-#include "MQMessageExt.h"
 #include "CMessageExt.h"
 #include "CCommon.h"
+#include "MQMessageExt.h"
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/src/extern/CProducer.cpp b/src/extern/CProducer.cpp
index 397d772..e230257 100644
--- a/src/extern/CProducer.cpp
+++ b/src/extern/CProducer.cpp
@@ -27,6 +27,7 @@
 #include "CMessage.h"
 #include "CSendResult.h"
 #include "DefaultMQProducer.h"
+#include "MQClient.h"
 #include "MQClientErrorContainer.h"
 #include "TransactionListener.h"
 #include "TransactionMQProducer.h"
diff --git a/include/BatchMessage.h b/src/include/BatchMessage.h
similarity index 100%
rename from include/BatchMessage.h
rename to src/include/BatchMessage.h
diff --git a/include/MQClient.h b/src/include/DefaultMQClient.h
similarity index 92%
copy from include/MQClient.h
copy to src/include/DefaultMQClient.h
index 0e23339..0ae4934 100644
--- a/include/MQClient.h
+++ b/src/include/DefaultMQClient.h
@@ -1,202 +1,193 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef __MQADMIN_H__
-#define __MQADMIN_H__
-#include <boost/asio.hpp>
-#include <boost/asio/io_service.hpp>
-#include <boost/bind.hpp>
-#include <boost/date_time/posix_time/posix_time.hpp>
-#include <boost/thread/mutex.hpp>
-#include <boost/thread/thread.hpp>
-#include "MQMessageExt.h"
-#include "MQMessageQueue.h"
-#include "QueryResult.h"
-#include "RocketMQClient.h"
-#include "SessionCredentials.h"
-
-namespace rocketmq {
-class MQClientFactory;
-//<!***************************************************************************
-
-enum elogLevel {
-  eLOG_LEVEL_FATAL = 1,
-  eLOG_LEVEL_ERROR = 2,
-  eLOG_LEVEL_WARN = 3,
-  eLOG_LEVEL_INFO = 4,
-  eLOG_LEVEL_DEBUG = 5,
-  eLOG_LEVEL_TRACE = 6,
-  eLOG_LEVEL_LEVEL_NUM = 7
-};
-
-class ROCKETMQCLIENT_API MQClient {
- public:
-  MQClient();
-  virtual ~MQClient();
-
- public:
-  // clientid=processId-ipAddr@instanceName;
-  std::string getMQClientId() const;
-  const std::string& getNamesrvAddr() const;
-  void setNamesrvAddr(const std::string& namesrvAddr);
-  const std::string& getNamesrvDomain() const;
-  void setNamesrvDomain(const std::string& namesrvDomain);
-  const std::string& getInstanceName() const;
-  void setInstanceName(const std::string& instanceName);
-  // nameSpace
-  const std::string& getNameSpace() const;
-  void setNameSpace(const std::string& nameSpace);
-  const std::string& getGroupName() const;
-  void setGroupName(const std::string& groupname);
-
-  /**
-   * no realization
-   */
-  void createTopic(const std::string& key, const std::string& newTopic, int queueNum);
-  /**
-   * search earliest msg store time for specified queue
-   *
-   * @param mq
-   *            message queue
-   * @return earliest store time, ms
-   */
-  int64 earliestMsgStoreTime(const MQMessageQueue& mq);
-  /**
-   * search maxOffset of queue
-   *
-   * @param mq
-   *            message queue
-   * @return minOffset of queue
-   */
-  int64 minOffset(const MQMessageQueue& mq);
-  /**
-   * search maxOffset of queue
-   * Note: maxOffset-1 is max offset that could get msg
-   * @param mq
-   *            message queue
-   * @return maxOffset of queue
-   */
-  int64 maxOffset(const MQMessageQueue& mq);
-  /**
-   * get queue offset by timestamp
-   *
-   * @param mq
-   *            mq queue
-   * @param timestamp
-   *            timestamp with ms unit
-   * @return queue offset according to timestamp
-   */
-  int64 searchOffset(const MQMessageQueue& mq, uint64_t timestamp);
-  /**
-   * get whole msg info from broker by msgId
-   *
-   * @param msgId
-   * @return MQMessageExt
-   */
-  MQMessageExt* viewMessage(const std::string& msgId);
-  /**
-   * query message by topic and key
-   *
-   * @param topic
-   *            topic name
-   * @param key
-   *            topic key
-   * @param maxNum
-   *            query num
-   * @param begin
-   *            begin timestamp
-   * @param end
-   *            end timestamp
-   * @return
-   *            according to QueryResult
-   */
-  QueryResult queryMessage(const std::string& topic, const std::string& key, int maxNum, int64 begin, int64 end);
-
-  std::vector<MQMessageQueue> getTopicMessageQueueInfo(const std::string& topic);
-
-  // log configuration interface, default LOG_LEVEL is LOG_LEVEL_INFO, default
-  // log file num is 3, each log size is 100M
-  void setLogLevel(elogLevel inputLevel);
-  elogLevel getLogLevel();
-  void setLogFileSizeAndNum(int fileNum, long perFileSize);  // perFileSize is MB unit
-
-  /** set TcpTransport pull thread num, which dermine the num of threads to
- distribute network data,
-     1. its default value is CPU num, it must be setted before producer/consumer
- start, minimum value is CPU num;
-     2. this pullThread num must be tested on your environment to find the best
- value for RT of sendMsg or delay time of consume msg before you change it;
-     3. producer and consumer need different pullThread num, if set this num,
- producer and consumer must set different instanceName.
-     4. configuration suggestion:
-         1>. minimum RT of sendMsg:
-                 pullThreadNum = brokerNum*2
- **/
-  void setTcpTransportPullThreadNum(int num);
-  const int getTcpTransportPullThreadNum() const;
-
-  /** timeout of tcp connect, it is same meaning for both producer and consumer;
-      1. default value is 3000ms
-      2. input parameter could only be milliSecond, suggestion value is
-  1000-3000ms;
-  **/
-  void setTcpTransportConnectTimeout(uint64_t timeout);  // ms
-  const uint64_t getTcpTransportConnectTimeout() const;
-
-  /** timeout of tryLock tcpTransport before sendMsg/pullMsg, if timeout,
-  returns NULL
-      1. paremeter unit is ms, default value is 3000ms, the minimun value is
-  1000ms
-          suggestion value is 3000ms;
-      2. if configured with value smaller than 1000ms, the tryLockTimeout value
-  will be setted to 1000ms
-  **/
-  void setTcpTransportTryLockTimeout(uint64_t timeout);  // ms
-  const uint64_t getTcpTransportTryLockTimeout() const;
-
-  void setUnitName(std::string unitName);
-  const std::string& getUnitName();
-
-  void setSessionCredentials(const std::string& input_accessKey,
-                             const std::string& input_secretKey,
-                             const std::string& input_onsChannel);
-  const SessionCredentials& getSessionCredentials() const;
-
- protected:
-  virtual void start();
-  virtual void shutdown();
-  MQClientFactory* getFactory() const;
-  virtual bool isServiceStateOk();
-
- protected:
-  std::string m_namesrvAddr;
-  std::string m_namesrvDomain;
-  std::string m_instanceName;
-  std::string m_nameSpace;
-  std::string m_GroupName;
-  MQClientFactory* m_clientFactory;
-  int m_serviceState;
-  int m_pullThreadNum;
-  uint64_t m_tcpConnectTimeout;           // ms
-  uint64_t m_tcpTransportTryLockTimeout;  // s
-
-  std::string m_unitName;
-  SessionCredentials m_SessionCredentials;
-};
-//<!***************************************************************************
-}  // namespace rocketmq
-#endif
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __DEFAULTMQADMIN_H__
+#define __DEFAULTMQADMIN_H__
+#include <boost/asio.hpp>
+#include <boost/asio/io_service.hpp>
+#include <boost/bind.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/thread.hpp>
+#include "MQClient.h"
+#include "MQMessageExt.h"
+#include "MQMessageQueue.h"
+#include "QueryResult.h"
+#include "RocketMQClient.h"
+#include "SessionCredentials.h"
+
+namespace rocketmq {
+class MQClientFactory;
+//<!***************************************************************************
+
+class DefaultMQClient {
+ public:
+  DefaultMQClient();
+  virtual ~DefaultMQClient();
+
+ public:
+  // clientid=processId-ipAddr@instanceName;
+  std::string getMQClientId() const;
+  const std::string& getNamesrvAddr() const;
+  void setNamesrvAddr(const std::string& namesrvAddr);
+  const std::string& getNamesrvDomain() const;
+  void setNamesrvDomain(const std::string& namesrvDomain);
+  const std::string& getInstanceName() const;
+  void setInstanceName(const std::string& instanceName);
+  // nameSpace
+  const std::string& getNameSpace() const;
+  void setNameSpace(const std::string& nameSpace);
+  const std::string& getGroupName() const;
+  void setGroupName(const std::string& groupname);
+
+  /**
+   * no realization
+   */
+  void createTopic(const std::string& key, const std::string& newTopic, int queueNum);
+  /**
+   * search earliest msg store time for specified queue
+   *
+   * @param mq
+   *            message queue
+   * @return earliest store time, ms
+   */
+  int64 earliestMsgStoreTime(const MQMessageQueue& mq);
+  /**
+   * search maxOffset of queue
+   *
+   * @param mq
+   *            message queue
+   * @return minOffset of queue
+   */
+  int64 minOffset(const MQMessageQueue& mq);
+  /**
+   * search maxOffset of queue
+   * Note: maxOffset-1 is max offset that could get msg
+   * @param mq
+   *            message queue
+   * @return maxOffset of queue
+   */
+  int64 maxOffset(const MQMessageQueue& mq);
+  /**
+   * get queue offset by timestamp
+   *
+   * @param mq
+   *            mq queue
+   * @param timestamp
+   *            timestamp with ms unit
+   * @return queue offset according to timestamp
+   */
+  int64 searchOffset(const MQMessageQueue& mq, uint64_t timestamp);
+  /**
+   * get whole msg info from broker by msgId
+   *
+   * @param msgId
+   * @return MQMessageExt
+   */
+  MQMessageExt* viewMessage(const std::string& msgId);
+  /**
+   * query message by topic and key
+   *
+   * @param topic
+   *            topic name
+   * @param key
+   *            topic key
+   * @param maxNum
+   *            query num
+   * @param begin
+   *            begin timestamp
+   * @param end
+   *            end timestamp
+   * @return
+   *            according to QueryResult
+   */
+  QueryResult queryMessage(const std::string& topic, const std::string& key, int maxNum, int64 begin, int64 end);
+
+  std::vector<MQMessageQueue> getTopicMessageQueueInfo(const std::string& topic);
+
+  // log configuration interface, default LOG_LEVEL is LOG_LEVEL_INFO, default
+  // log file num is 3, each log size is 100M
+  void setLogLevel(elogLevel inputLevel);
+  elogLevel getLogLevel();
+  void setLogFileSizeAndNum(int fileNum, long perFileSize);  // perFileSize is MB unit
+
+  /** set TcpTransport pull thread num, which dermine the num of threads to
+ distribute network data,
+     1. its default value is CPU num, it must be setted before producer/consumer
+ start, minimum value is CPU num;
+     2. this pullThread num must be tested on your environment to find the best
+ value for RT of sendMsg or delay time of consume msg before you change it;
+     3. producer and consumer need different pullThread num, if set this num,
+ producer and consumer must set different instanceName.
+     4. configuration suggestion:
+         1>. minimum RT of sendMsg:
+                 pullThreadNum = brokerNum*2
+ **/
+  void setTcpTransportPullThreadNum(int num);
+  const int getTcpTransportPullThreadNum() const;
+
+  /** timeout of tcp connect, it is same meaning for both producer and consumer;
+      1. default value is 3000ms
+      2. input parameter could only be milliSecond, suggestion value is
+  1000-3000ms;
+  **/
+  void setTcpTransportConnectTimeout(uint64_t timeout);  // ms
+  const uint64_t getTcpTransportConnectTimeout() const;
+
+  /** timeout of tryLock tcpTransport before sendMsg/pullMsg, if timeout,
+  returns NULL
+      1. paremeter unit is ms, default value is 3000ms, the minimun value is
+  1000ms
+          suggestion value is 3000ms;
+      2. if configured with value smaller than 1000ms, the tryLockTimeout value
+  will be setted to 1000ms
+  **/
+  void setTcpTransportTryLockTimeout(uint64_t timeout);  // ms
+  const uint64_t getTcpTransportTryLockTimeout() const;
+
+  void setUnitName(std::string unitName);
+  const std::string& getUnitName() const;
+
+  void setSessionCredentials(const std::string& input_accessKey,
+                             const std::string& input_secretKey,
+                             const std::string& input_onsChannel);
+  const SessionCredentials& getSessionCredentials() const;
+
+ protected:
+  virtual void start();
+  virtual void shutdown();
+  MQClientFactory* getFactory() const;
+  virtual bool isServiceStateOk();
+
+ protected:
+  std::string m_namesrvAddr;
+  std::string m_namesrvDomain;
+  std::string m_instanceName;
+  std::string m_nameSpace;
+  std::string m_GroupName;
+  MQClientFactory* m_clientFactory;
+  int m_serviceState;
+  int m_pullThreadNum;
+  uint64_t m_tcpConnectTimeout;           // ms
+  uint64_t m_tcpTransportTryLockTimeout;  // s
+
+  std::string m_unitName;
+  SessionCredentials m_SessionCredentials;
+};
+//<!***************************************************************************
+}  // namespace rocketmq
+#endif
diff --git a/include/MQConsumer.h b/src/include/MQConsumer.h
similarity index 95%
rename from include/MQConsumer.h
rename to src/include/MQConsumer.h
index 87e2c1b..a79e90f 100644
--- a/include/MQConsumer.h
+++ b/src/include/MQConsumer.h
@@ -1,68 +1,68 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#ifndef __MQCONSUMER_H__
-#define __MQCONSUMER_H__
-
-#include <string>
-#include "AsyncCallback.h"
-#include "ConsumeType.h"
-#include "MQClient.h"
-#include "RocketMQClient.h"
-
-namespace rocketmq {
-class SubscriptionData;
-class PullRequest;
-class Rebalance;
-class ConsumerRunningInfo;
-//<!************************************************************************
-class ROCKETMQCLIENT_API MQConsumer : public MQClient {
- public:
-  virtual ~MQConsumer() {}
-  virtual bool sendMessageBack(MQMessageExt& msg, int delayLevel, std::string& brokerName) = 0;
-  virtual void fetchSubscribeMessageQueues(const std::string& topic, std::vector<MQMessageQueue>& mqs) = 0;
-  virtual void doRebalance() = 0;
-  virtual void persistConsumerOffset() = 0;
-  virtual void persistConsumerOffsetByResetOffset() = 0;
-  virtual void updateTopicSubscribeInfo(const std::string& topic, std::vector<MQMessageQueue>& info) = 0;
-  virtual void updateConsumeOffset(const MQMessageQueue& mq, int64 offset) = 0;
-  virtual void removeConsumeOffset(const MQMessageQueue& mq) = 0;
-  virtual ConsumeType getConsumeType() = 0;
-  virtual ConsumeFromWhere getConsumeFromWhere() = 0;
-  virtual void getSubscriptions(std::vector<SubscriptionData>&) = 0;
-  virtual bool producePullMsgTask(boost::weak_ptr<PullRequest>) = 0;
-  virtual Rebalance* getRebalance() const = 0;
-  virtual PullResult pull(const MQMessageQueue& mq, const std::string& subExpression, int64 offset, int maxNums) = 0;
-  virtual void pull(const MQMessageQueue& mq,
-                    const std::string& subExpression,
-                    int64 offset,
-                    int maxNums,
-                    PullCallback* pPullCallback) = 0;
-  virtual ConsumerRunningInfo* getConsumerRunningInfo() = 0;
-
- public:
-  MessageModel getMessageModel() const { return m_messageModel; }
-  void setMessageModel(MessageModel messageModel) { m_messageModel = messageModel; }
-  bool isUseNameSpaceMode() const { return m_useNameSpaceMode; }
-
- protected:
-  MessageModel m_messageModel;
-  bool m_useNameSpaceMode = false;
-};
-
-//<!***************************************************************************
-}  // namespace rocketmq
-#endif
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef __MQCONSUMER_H__
+#define __MQCONSUMER_H__
+
+#include <string>
+#include "AsyncCallback.h"
+#include "ConsumeType.h"
+#include "DefaultMQClient.h"
+#include "RocketMQClient.h"
+
+namespace rocketmq {
+class SubscriptionData;
+class PullRequest;
+class Rebalance;
+class ConsumerRunningInfo;
+//<!************************************************************************
+class MQConsumer : public DefaultMQClient {
+ public:
+  virtual ~MQConsumer() {}
+  virtual bool sendMessageBack(MQMessageExt& msg, int delayLevel, std::string& brokerName) = 0;
+  virtual void fetchSubscribeMessageQueues(const std::string& topic, std::vector<MQMessageQueue>& mqs) = 0;
+  virtual void doRebalance() = 0;
+  virtual void persistConsumerOffset() = 0;
+  virtual void persistConsumerOffsetByResetOffset() = 0;
+  virtual void updateTopicSubscribeInfo(const std::string& topic, std::vector<MQMessageQueue>& info) = 0;
+  virtual void updateConsumeOffset(const MQMessageQueue& mq, int64 offset) = 0;
+  virtual void removeConsumeOffset(const MQMessageQueue& mq) = 0;
+  virtual ConsumeType getConsumeType() = 0;
+  virtual ConsumeFromWhere getConsumeFromWhere() = 0;
+  virtual void getSubscriptions(std::vector<SubscriptionData>&) = 0;
+  virtual bool producePullMsgTask(boost::weak_ptr<PullRequest>) = 0;
+  virtual Rebalance* getRebalance() const = 0;
+  virtual PullResult pull(const MQMessageQueue& mq, const std::string& subExpression, int64 offset, int maxNums) = 0;
+  virtual void pull(const MQMessageQueue& mq,
+                    const std::string& subExpression,
+                    int64 offset,
+                    int maxNums,
+                    PullCallback* pPullCallback) = 0;
+  virtual ConsumerRunningInfo* getConsumerRunningInfo() = 0;
+
+ public:
+  MessageModel getMessageModel() const { return m_messageModel; }
+  void setMessageModel(MessageModel messageModel) { m_messageModel = messageModel; }
+  bool isUseNameSpaceMode() const { return m_useNameSpaceMode; }
+
+ protected:
+  MessageModel m_messageModel;
+  bool m_useNameSpaceMode = false;
+};
+
+//<!***************************************************************************
+}  // namespace rocketmq
+#endif
diff --git a/include/MQProducer.h b/src/include/MQProducer.h
similarity index 95%
rename from include/MQProducer.h
rename to src/include/MQProducer.h
index 03e6b19..0f787d7 100644
--- a/include/MQProducer.h
+++ b/src/include/MQProducer.h
@@ -1,61 +1,61 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#ifndef __MQPRODUCER_H__
-#define __MQPRODUCER_H__
-
-#include "AsyncCallback.h"
-#include "MQClient.h"
-#include "MQMessageQueue.h"
-#include "MQSelector.h"
-#include "RocketMQClient.h"
-#include "SendResult.h"
-
-namespace rocketmq {
-//<!***************************************************************************
-class ROCKETMQCLIENT_API MQProducer : public MQClient {
- public:
-  MQProducer() {}
-  virtual ~MQProducer() {}
-  // if setted bActiveBroker, will search brokers with best service state
-  // firstly, then search brokers that had been sent failed by last time;
-  virtual SendResult send(MQMessage& msg, bool bSelectActiveBroker = false) = 0;
-  virtual SendResult send(MQMessage& msg, const MQMessageQueue& mq) = 0;
-  // strict order msg, if send failed on seleted MessageQueue, throw exception
-  // to up layer
-  virtual SendResult send(MQMessage& msg, MessageQueueSelector* selector, void* arg) = 0;
-  // non-strict order msg, if send failed on seleted MessageQueue, will auto
-  // retry others Broker queues with autoRetryTimes;
-  // if setted bActiveBroker, if send failed on seleted MessageQueue, , and then
-  // search brokers with best service state, lastly will search brokers that had
-  // been sent failed by last time;
-  virtual SendResult send(MQMessage& msg,
-                          MessageQueueSelector* selector,
-                          void* arg,
-                          int autoRetryTimes,
-                          bool bActiveBroker = false) = 0;
-  virtual void send(MQMessage& msg, SendCallback* sendCallback, bool bSelectActiveBroker = false) = 0;
-  virtual void send(MQMessage& msg, const MQMessageQueue& mq, SendCallback* sendCallback) = 0;
-  virtual void send(MQMessage& msg, MessageQueueSelector* selector, void* arg, SendCallback* sendCallback) = 0;
-  virtual SendResult send(std::vector<MQMessage>& msgs) = 0;
-  virtual SendResult send(std::vector<MQMessage>& msgs, const MQMessageQueue& mq) = 0;
-  virtual void sendOneway(MQMessage& msg, bool bSelectActiveBroker = false) = 0;
-  virtual void sendOneway(MQMessage& msg, const MQMessageQueue& mq) = 0;
-  virtual void sendOneway(MQMessage& msg, MessageQueueSelector* selector, void* arg) = 0;
-};
-//<!***************************************************************************
-}  // namespace rocketmq
-#endif
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef __MQPRODUCER_H__
+#define __MQPRODUCER_H__
+
+#include "AsyncCallback.h"
+#include "DefaultMQClient.h"
+#include "MQMessageQueue.h"
+#include "MQSelector.h"
+#include "RocketMQClient.h"
+#include "SendResult.h"
+
+namespace rocketmq {
+//<!***************************************************************************
+class MQProducer : public DefaultMQClient {
+ public:
+  MQProducer() {}
+  virtual ~MQProducer() {}
+  // if setted bActiveBroker, will search brokers with best service state
+  // firstly, then search brokers that had been sent failed by last time;
+  virtual SendResult send(MQMessage& msg, bool bSelectActiveBroker = false) = 0;
+  virtual SendResult send(MQMessage& msg, const MQMessageQueue& mq) = 0;
+  // strict order msg, if send failed on seleted MessageQueue, throw exception
+  // to up layer
+  virtual SendResult send(MQMessage& msg, MessageQueueSelector* selector, void* arg) = 0;
+  // non-strict order msg, if send failed on seleted MessageQueue, will auto
+  // retry others Broker queues with autoRetryTimes;
+  // if setted bActiveBroker, if send failed on seleted MessageQueue, , and then
+  // search brokers with best service state, lastly will search brokers that had
+  // been sent failed by last time;
+  virtual SendResult send(MQMessage& msg,
+                          MessageQueueSelector* selector,
+                          void* arg,
+                          int autoRetryTimes,
+                          bool bActiveBroker = false) = 0;
+  virtual void send(MQMessage& msg, SendCallback* sendCallback, bool bSelectActiveBroker = false) = 0;
+  virtual void send(MQMessage& msg, const MQMessageQueue& mq, SendCallback* sendCallback) = 0;
+  virtual void send(MQMessage& msg, MessageQueueSelector* selector, void* arg, SendCallback* sendCallback) = 0;
+  virtual SendResult send(std::vector<MQMessage>& msgs) = 0;
+  virtual SendResult send(std::vector<MQMessage>& msgs, const MQMessageQueue& mq) = 0;
+  virtual void sendOneway(MQMessage& msg, bool bSelectActiveBroker = false) = 0;
+  virtual void sendOneway(MQMessage& msg, const MQMessageQueue& mq) = 0;
+  virtual void sendOneway(MQMessage& msg, MessageQueueSelector* selector, void* arg) = 0;
+};
+//<!***************************************************************************
+}  // namespace rocketmq
+#endif
diff --git a/include/QueryResult.h b/src/include/QueryResult.h
similarity index 97%
rename from include/QueryResult.h
rename to src/include/QueryResult.h
index b7c3697..f03a206 100644
--- a/include/QueryResult.h
+++ b/src/include/QueryResult.h
@@ -1,42 +1,42 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#ifndef __QUERYRESULT_H__
-#define __QUERYRESULT_H__
-
-#include "MQMessageExt.h"
-#include "RocketMQClient.h"
-
-namespace rocketmq {
-//<!************************************************************************
-class ROCKETMQCLIENT_API QueryResult {
- public:
-  QueryResult(uint64 indexLastUpdateTimestamp, const std::vector<MQMessageExt*>& messageList) {
-    m_indexLastUpdateTimestamp = indexLastUpdateTimestamp;
-    m_messageList = messageList;
-  }
-
-  uint64 getIndexLastUpdateTimestamp() { return m_indexLastUpdateTimestamp; }
-
-  std::vector<MQMessageExt*>& getMessageList() { return m_messageList; }
-
- private:
-  uint64 m_indexLastUpdateTimestamp;
-  std::vector<MQMessageExt*> m_messageList;
-};
-//<!***************************************************************************
-}  // namespace rocketmq
-#endif
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef __QUERYRESULT_H__
+#define __QUERYRESULT_H__
+
+#include "MQMessageExt.h"
+#include "RocketMQClient.h"
+
+namespace rocketmq {
+//<!************************************************************************
+class ROCKETMQCLIENT_API QueryResult {
+ public:
+  QueryResult(uint64 indexLastUpdateTimestamp, const std::vector<MQMessageExt*>& messageList) {
+    m_indexLastUpdateTimestamp = indexLastUpdateTimestamp;
+    m_messageList = messageList;
+  }
+
+  uint64 getIndexLastUpdateTimestamp() { return m_indexLastUpdateTimestamp; }
+
+  std::vector<MQMessageExt*>& getMessageList() { return m_messageList; }
+
+ private:
+  uint64 m_indexLastUpdateTimestamp;
+  std::vector<MQMessageExt*> m_messageList;
+};
+//<!***************************************************************************
+}  // namespace rocketmq
+#endif
diff --git a/include/SendMessageHook.h b/src/include/SendMessageHook.h
similarity index 87%
rename from include/SendMessageHook.h
rename to src/include/SendMessageHook.h
index 1af0e92..0d3e1e3 100644
--- a/include/SendMessageHook.h
+++ b/src/include/SendMessageHook.h
@@ -1,47 +1,49 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#ifndef __SENDMESSAGEHOOK_H__
-#define __SENDMESSAGEHOOK_H__
-
-#include "MQClientException.h"
-#include "MQMessage.h"
-#include "RocketMQClient.h"
-
-namespace rocketmq {
-//<!***************************************************************************
-class ROCKETMQCLIENT_API SendMessageContext {
- public:
-  string producerGroup;
-  MQMessage msg;
-  MQMessageQueue mq;
-  string brokerAddr;
-  int communicationMode;
-  SendResult sendResult;
-  MQException* pException;
-  void* pArg;
-};
-
-class ROCKETMQCLIENT_API SendMessageHook {
- public:
-  virtual ~SendMessageHook() {}
-  virtual string hookName() = 0;
-  virtual void sendMessageBefore(const SendMessageContext& context) = 0;
-  virtual void sendMessageAfter(const SendMessageContext& context) = 0;
-};
-//<!***************************************************************************
-}  // namespace rocketmq
-#endif
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef __SENDMESSAGEHOOK_H__
+#define __SENDMESSAGEHOOK_H__
+
+#include "MQClientException.h"
+#include "MQMessage.h"
+#include "MQMessageQueue.h"
+#include "RocketMQClient.h"
+#include "SendResult.h"
+
+namespace rocketmq {
+//<!***************************************************************************
+class SendMessageContext {
+ public:
+  std::string producerGroup;
+  MQMessage msg;
+  MQMessageQueue mq;
+  std::string brokerAddr;
+  int communicationMode;
+  SendResult sendResult;
+  MQException* pException;
+  void* pArg;
+};
+
+class SendMessageHook {
+ public:
+  virtual ~SendMessageHook() {}
+  virtual std::string hookName() = 0;
+  virtual void sendMessageBefore(const SendMessageContext& context) = 0;
+  virtual void sendMessageAfter(const SendMessageContext& context) = 0;
+};
+//<!***************************************************************************
+}  // namespace rocketmq
+#endif
diff --git a/src/log/Logging.h b/src/log/Logging.h
index dfede34..24960c7 100644
--- a/src/log/Logging.h
+++ b/src/log/Logging.h
@@ -31,7 +31,7 @@
 #include <boost/log/utility/setup/file.hpp>
 #include <boost/scoped_array.hpp>
 #include <boost/shared_ptr.hpp>
-#include "MQClient.h"
+#include "include/DefaultMQClient.h"
 
 namespace logging = boost::log;
 namespace src = boost::log::sources;
diff --git a/src/message/BatchMessage.cpp b/src/message/BatchMessage.cpp
index 3a2481b..9bcca1c 100644
--- a/src/message/BatchMessage.cpp
+++ b/src/message/BatchMessage.cpp
@@ -14,7 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "BatchMessage.h"
+#include "include/BatchMessage.h"
 
 #include "MQDecoder.h"
 #include "StringIdMaker.h"
diff --git a/src/producer/DefaultMQProducer.cpp b/src/producer/DefaultMQProducer.cpp
index ee81a7b..9a6d414 100644
--- a/src/producer/DefaultMQProducer.cpp
+++ b/src/producer/DefaultMQProducer.cpp
@@ -1,635 +1,207 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
 #include "DefaultMQProducer.h"
 
-#include <assert.h>
-#include <typeindex>
-
-#include "BatchMessage.h"
-#include "CommandHeader.h"
-#include "CommunicationMode.h"
-#include "Logging.h"
-#include "MQClientAPIImpl.h"
-#include "MQClientException.h"
-#include "MQClientFactory.h"
-#include "MQClientManager.h"
-#include "MQDecoder.h"
-#include "MQProtos.h"
-#include "MessageAccessor.h"
-#include "NameSpaceUtil.h"
-#include "StringIdMaker.h"
-#include "TopicPublishInfo.h"
-#include "Validators.h"
+#include "DefaultMQProducerImpl.h"
 
 namespace rocketmq {
 
-//<!************************************************************************
-DefaultMQProducer::DefaultMQProducer(const string& groupname)
-    : m_sendMsgTimeout(3000),
-      m_compressMsgBodyOverHowmuch(4 * 1024),
-      m_maxMessageSize(1024 * 128),
-      // m_retryAnotherBrokerWhenNotStoreOK(false),
-      m_compressLevel(5),
-      m_retryTimes(5),
-      m_retryTimes4Async(1) {
-  //<!set default group name;
-  string gname = groupname.empty() ? DEFAULT_PRODUCER_GROUP : groupname;
-  setGroupName(gname);
+DefaultMQProducer::DefaultMQProducer(const std::string& groupName) {
+  impl = new DefaultMQProducerImpl(groupName);
 }
 
-DefaultMQProducer::~DefaultMQProducer() {}
-
+DefaultMQProducer::~DefaultMQProducer() {
+  delete impl;
+}
 void DefaultMQProducer::start() {
-#ifndef WIN32
-  /* Ignore the SIGPIPE */
-  struct sigaction sa;
-  memset(&sa, 0, sizeof(struct sigaction));
-  sa.sa_handler = SIG_IGN;
-  sa.sa_flags = 0;
-  sigaction(SIGPIPE, &sa, 0);
-#endif
-  // we should deal with namespaced before start.
-  dealWithNameSpace();
-  switch (m_serviceState) {
-    case CREATE_JUST: {
-      m_serviceState = START_FAILED;
-      MQClient::start();
-      LOG_INFO("DefaultMQProducer:%s start", m_GroupName.c_str());
-
-      bool registerOK = getFactory()->registerProducer(this);
-      if (!registerOK) {
-        m_serviceState = CREATE_JUST;
-        THROW_MQEXCEPTION(
-            MQClientException,
-            "The producer group[" + getGroupName() + "] has been created before, specify another name please.", -1);
-      }
-
-      getFactory()->start();
-      getFactory()->sendHeartbeatToAllBroker();
-      m_serviceState = RUNNING;
-      break;
-    }
-    case RUNNING:
-    case START_FAILED:
-    case SHUTDOWN_ALREADY:
-      break;
-    default:
-      break;
-  }
+  impl->start();
 }
 
 void DefaultMQProducer::shutdown() {
-  switch (m_serviceState) {
-    case RUNNING: {
-      LOG_INFO("DefaultMQProducer shutdown");
-      getFactory()->unregisterProducer(this);
-      getFactory()->shutdown();
-      m_serviceState = SHUTDOWN_ALREADY;
-      break;
-    }
-    case SHUTDOWN_ALREADY:
-    case CREATE_JUST:
-      break;
-    default:
-      break;
-  }
+  impl->shutdown();
 }
 
-SendResult DefaultMQProducer::send(MQMessage& msg, bool bSelectActiveBroker) {
-  Validators::checkMessage(msg, getMaxMessageSize());
-  if (!NameSpaceUtil::hasNameSpace(msg.getTopic(), getNameSpace())) {
-    MessageAccessor::withNameSpace(msg, getNameSpace());
-  }
-  try {
-    return sendDefaultImpl(msg, ComMode_SYNC, NULL, bSelectActiveBroker);
-  } catch (MQException& e) {
-    LOG_ERROR(e.what());
-    throw e;
-  }
-  return SendResult();
+// start mqclient set
+const std::string& DefaultMQProducer::getNamesrvAddr() const {
+  return impl->getNamesrvAddr();
 }
 
-void DefaultMQProducer::send(MQMessage& msg, SendCallback* pSendCallback, bool bSelectActiveBroker) {
-  Validators::checkMessage(msg, getMaxMessageSize());
-  if (!NameSpaceUtil::hasNameSpace(msg.getTopic(), getNameSpace())) {
-    MessageAccessor::withNameSpace(msg, getNameSpace());
-  }
-  try {
-    sendDefaultImpl(msg, ComMode_ASYNC, pSendCallback, bSelectActiveBroker);
-  } catch (MQException& e) {
-    LOG_ERROR(e.what());
-    throw e;
-  }
+void DefaultMQProducer::setNamesrvAddr(const std::string& namesrvAddr) {
+  impl->setNamesrvAddr(namesrvAddr);
 }
 
-SendResult DefaultMQProducer::send(std::vector<MQMessage>& msgs) {
-  SendResult result;
-  try {
-    BatchMessage batchMessage = buildBatchMessage(msgs);
-    result = sendDefaultImpl(batchMessage, ComMode_SYNC, NULL);
-  } catch (MQException& e) {
-    LOG_ERROR(e.what());
-    throw e;
-  }
-  return result;
+const std::string& DefaultMQProducer::getNamesrvDomain() const {
+  return impl->getNamesrvDomain();
 }
 
-SendResult DefaultMQProducer::send(std::vector<MQMessage>& msgs, const MQMessageQueue& mq) {
-  SendResult result;
-  try {
-    BatchMessage batchMessage = buildBatchMessage(msgs);
-    result = sendKernelImpl(batchMessage, mq, ComMode_SYNC, NULL);
-  } catch (MQException& e) {
-    LOG_ERROR(e.what());
-    throw e;
-  }
-  return result;
-}
-
-BatchMessage DefaultMQProducer::buildBatchMessage(std::vector<MQMessage>& msgs) {
-  if (msgs.size() < 1) {
-    THROW_MQEXCEPTION(MQClientException, "msgs need one message at least", -1);
-  }
-  BatchMessage batchMessage;
-  bool firstFlag = true;
-  string topic;
-  bool waitStoreMsgOK = false;
-  for (auto& msg : msgs) {
-    Validators::checkMessage(msg, getMaxMessageSize());
-    if (!NameSpaceUtil::hasNameSpace(msg.getTopic(), getNameSpace())) {
-      MessageAccessor::withNameSpace(msg, getNameSpace());
-    }
-    if (firstFlag) {
-      topic = msg.getTopic();
-      waitStoreMsgOK = msg.isWaitStoreMsgOK();
-      firstFlag = false;
-
-      if (UtilAll::startsWith_retry(topic)) {
-        THROW_MQEXCEPTION(MQClientException, "Retry Group is not supported for batching", -1);
-      }
-    } else {
-      if (msg.getDelayTimeLevel() > 0) {
-        THROW_MQEXCEPTION(MQClientException, "TimeDelayLevel in not supported for batching", -1);
-      }
-      if (msg.getTopic() != topic) {
-        THROW_MQEXCEPTION(MQClientException, "msgs need one message at least", -1);
-      }
-      if (msg.isWaitStoreMsgOK() != waitStoreMsgOK) {
-        THROW_MQEXCEPTION(MQClientException, "msgs need one message at least", -2);
-      }
-    }
-  }
-  batchMessage.setBody(BatchMessage::encode(msgs));
-  batchMessage.setTopic(topic);
-  batchMessage.setWaitStoreMsgOK(waitStoreMsgOK);
-  return batchMessage;
+void DefaultMQProducer::setNamesrvDomain(const std::string& namesrvDomain) {
+  impl->setNamesrvDomain(namesrvDomain);
+}
+void DefaultMQProducer::setSessionCredentials(const std::string& accessKey,
+                                              const std::string& secretKey,
+                                              const std::string& accessChannel) {
+  impl->setSessionCredentials(accessKey, secretKey, accessChannel);
 }
 
-SendResult DefaultMQProducer::send(MQMessage& msg, const MQMessageQueue& mq) {
-  Validators::checkMessage(msg, getMaxMessageSize());
-  if (!NameSpaceUtil::hasNameSpace(msg.getTopic(), getNameSpace())) {
-    MessageAccessor::withNameSpace(msg, getNameSpace());
-  }
-  if (msg.getTopic() != mq.getTopic()) {
-    LOG_WARN("message's topic not equal mq's topic");
-  }
-  try {
-    return sendKernelImpl(msg, mq, ComMode_SYNC, NULL);
-  } catch (MQException& e) {
-    LOG_ERROR(e.what());
-    throw e;
-  }
-  return SendResult();
+const SessionCredentials& DefaultMQProducer::getSessionCredentials() const {
+  return impl->getSessionCredentials();
+}
+const std::string& DefaultMQProducer::getInstanceName() const {
+  return impl->getInstanceName();
 }
 
-void DefaultMQProducer::send(MQMessage& msg, const MQMessageQueue& mq, SendCallback* pSendCallback) {
-  Validators::checkMessage(msg, getMaxMessageSize());
-  if (!NameSpaceUtil::hasNameSpace(msg.getTopic(), getNameSpace())) {
-    MessageAccessor::withNameSpace(msg, getNameSpace());
-  }
-  if (msg.getTopic() != mq.getTopic()) {
-    LOG_WARN("message's topic not equal mq's topic");
-  }
-  try {
-    sendKernelImpl(msg, mq, ComMode_ASYNC, pSendCallback);
-  } catch (MQException& e) {
-    LOG_ERROR(e.what());
-    throw e;
-  }
+void DefaultMQProducer::setInstanceName(const std::string& instanceName) {
+  impl->setInstanceName(instanceName);
 }
 
-void DefaultMQProducer::sendOneway(MQMessage& msg, bool bSelectActiveBroker) {
-  Validators::checkMessage(msg, getMaxMessageSize());
-  if (!NameSpaceUtil::hasNameSpace(msg.getTopic(), getNameSpace())) {
-    MessageAccessor::withNameSpace(msg, getNameSpace());
-  }
-  try {
-    sendDefaultImpl(msg, ComMode_ONEWAY, NULL, bSelectActiveBroker);
-  } catch (MQException& e) {
-    LOG_ERROR(e.what());
-    throw e;
-  }
+const std::string& DefaultMQProducer::getNameSpace() const {
+  return impl->getNameSpace();
 }
 
-void DefaultMQProducer::sendOneway(MQMessage& msg, const MQMessageQueue& mq) {
-  Validators::checkMessage(msg, getMaxMessageSize());
-  if (!NameSpaceUtil::hasNameSpace(msg.getTopic(), getNameSpace())) {
-    MessageAccessor::withNameSpace(msg, getNameSpace());
-  }
-  if (msg.getTopic() != mq.getTopic()) {
-    LOG_WARN("message's topic not equal mq's topic");
-  }
-  try {
-    sendKernelImpl(msg, mq, ComMode_ONEWAY, NULL);
-  } catch (MQException& e) {
-    LOG_ERROR(e.what());
-    throw e;
-  }
-}
-
-SendResult DefaultMQProducer::send(MQMessage& msg, MessageQueueSelector* pSelector, void* arg) {
-  try {
-    if (!NameSpaceUtil::hasNameSpace(msg.getTopic(), getNameSpace())) {
-      MessageAccessor::withNameSpace(msg, getNameSpace());
-    }
-    return sendSelectImpl(msg, pSelector, arg, ComMode_SYNC, NULL);
-  } catch (MQException& e) {
-    LOG_ERROR(e.what());
-    throw e;
-  }
-  return SendResult();
+void DefaultMQProducer::setNameSpace(const std::string& nameSpace) {
+  impl->setNameSpace(nameSpace);
+}
+const std::string& DefaultMQProducer::getGroupName() const {
+  return impl->getGroupName();
 }
 
-SendResult DefaultMQProducer::send(MQMessage& msg,
-                                   MessageQueueSelector* pSelector,
-                                   void* arg,
-                                   int autoRetryTimes,
-                                   bool bActiveBroker) {
-  try {
-    if (!NameSpaceUtil::hasNameSpace(msg.getTopic(), getNameSpace())) {
-      MessageAccessor::withNameSpace(msg, getNameSpace());
-    }
-    return sendAutoRetrySelectImpl(msg, pSelector, arg, ComMode_SYNC, NULL, autoRetryTimes, bActiveBroker);
-  } catch (MQException& e) {
-    LOG_ERROR(e.what());
-    throw e;
-  }
-  return SendResult();
-}
-
-void DefaultMQProducer::send(MQMessage& msg, MessageQueueSelector* pSelector, void* arg, SendCallback* pSendCallback) {
-  try {
-    if (!NameSpaceUtil::hasNameSpace(msg.getTopic(), getNameSpace())) {
-      MessageAccessor::withNameSpace(msg, getNameSpace());
-    }
-    sendSelectImpl(msg, pSelector, arg, ComMode_ASYNC, pSendCallback);
-  } catch (MQException& e) {
-    LOG_ERROR(e.what());
-    throw e;
-  }
-}
-
-void DefaultMQProducer::sendOneway(MQMessage& msg, MessageQueueSelector* pSelector, void* arg) {
-  try {
-    if (!NameSpaceUtil::hasNameSpace(msg.getTopic(), getNameSpace())) {
-      MessageAccessor::withNameSpace(msg, getNameSpace());
-    }
-    sendSelectImpl(msg, pSelector, arg, ComMode_ONEWAY, NULL);
-  } catch (MQException& e) {
-    LOG_ERROR(e.what());
-    throw e;
-  }
+void DefaultMQProducer::setGroupName(const std::string& groupName) {
+  impl->setGroupName(groupName);
+}
+void DefaultMQProducer::setSendMsgTimeout(int sendMsgTimeout) {
+  impl->setSendMsgTimeout(sendMsgTimeout);
 }
 
 int DefaultMQProducer::getSendMsgTimeout() const {
-  return m_sendMsgTimeout;
+  return impl->getSendMsgTimeout();
 }
 
-void DefaultMQProducer::setSendMsgTimeout(int sendMsgTimeout) {
-  m_sendMsgTimeout = sendMsgTimeout;
+void DefaultMQProducer::setRetryTimes(int times) {
+  impl->setRetryTimes(times);
+}
+
+int DefaultMQProducer::getRetryTimes() const {
+  return impl->getRetryTimes();
 }
 
 int DefaultMQProducer::getCompressMsgBodyOverHowmuch() const {
-  return m_compressMsgBodyOverHowmuch;
+  return impl->getCompressMsgBodyOverHowmuch();
 }
 
-void DefaultMQProducer::setCompressMsgBodyOverHowmuch(int compressMsgBodyOverHowmuch) {
-  m_compressMsgBodyOverHowmuch = compressMsgBodyOverHowmuch;
+void DefaultMQProducer::setCompressMsgBodyOverHowmuch(int compressMsgBodyThreshold) {
+  impl->setCompressMsgBodyOverHowmuch(compressMsgBodyThreshold);
 }
 
-int DefaultMQProducer::getMaxMessageSize() const {
-  return m_maxMessageSize;
+int DefaultMQProducer::getCompressLevel() const {
+  return impl->getCompressLevel();
+}
+
+void DefaultMQProducer::setCompressLevel(int compressLevel) {
+  impl->setCompressLevel(compressLevel);
 }
 
 void DefaultMQProducer::setMaxMessageSize(int maxMessageSize) {
-  m_maxMessageSize = maxMessageSize;
+  impl->setMaxMessageSize(maxMessageSize);
 }
 
-int DefaultMQProducer::getCompressLevel() const {
-  return m_compressLevel;
+int DefaultMQProducer::getMaxMessageSize() const {
+  return impl->getMaxMessageSize();
 }
 
-void DefaultMQProducer::setCompressLevel(int compressLevel) {
-  assert((compressLevel >= 0 && compressLevel <= 9) || compressLevel == -1);
-
-  m_compressLevel = compressLevel;
-}
-
-//<!************************************************************************
-SendResult DefaultMQProducer::sendDefaultImpl(MQMessage& msg,
-                                              int communicationMode,
-                                              SendCallback* pSendCallback,
-                                              bool bActiveMQ) {
-  MQMessageQueue lastmq;
-  int mq_index = 0;
-  for (int times = 1; times <= m_retryTimes; times++) {
-    boost::weak_ptr<TopicPublishInfo> weak_topicPublishInfo(
-        getFactory()->tryToFindTopicPublishInfo(msg.getTopic(), getSessionCredentials()));
-    boost::shared_ptr<TopicPublishInfo> topicPublishInfo(weak_topicPublishInfo.lock());
-    if (topicPublishInfo) {
-      if (times == 1) {
-        mq_index = topicPublishInfo->getWhichQueue();
-      } else {
-        mq_index++;
-      }
-
-      SendResult sendResult;
-      MQMessageQueue mq;
-      if (bActiveMQ)
-        mq = topicPublishInfo->selectOneActiveMessageQueue(lastmq, mq_index);
-      else
-        mq = topicPublishInfo->selectOneMessageQueue(lastmq, mq_index);
-
-      lastmq = mq;
-      if (mq.getQueueId() == -1) {
-        // THROW_MQEXCEPTION(MQClientException, "the MQMessageQueue is
-        // invalide", -1);
-        continue;
-      }
-
-      try {
-        LOG_DEBUG("send to mq:%s", mq.toString().data());
-        sendResult = sendKernelImpl(msg, mq, communicationMode, pSendCallback);
-        switch (communicationMode) {
-          case ComMode_ASYNC:
-            return sendResult;
-          case ComMode_ONEWAY:
-            return sendResult;
-          case ComMode_SYNC:
-            if (sendResult.getSendStatus() != SEND_OK) {
-              if (bActiveMQ) {
-                topicPublishInfo->updateNonServiceMessageQueue(mq, getSendMsgTimeout());
-              }
-              continue;
-            }
-            return sendResult;
-          default:
-            break;
-        }
-      } catch (...) {
-        LOG_ERROR("send failed of times:%d,brokerName:%s", times, mq.getBrokerName().c_str());
-        if (bActiveMQ) {
-          topicPublishInfo->updateNonServiceMessageQueue(mq, getSendMsgTimeout());
-        }
-        continue;
-      }
-    }  // end of for
-    LOG_WARN("Retry many times, still failed");
-  }
-  string info = "No route info of this topic: " + msg.getTopic();
-  THROW_MQEXCEPTION(MQClientException, info, -1);
-}
-
-SendResult DefaultMQProducer::sendKernelImpl(MQMessage& msg,
-                                             const MQMessageQueue& mq,
-                                             int communicationMode,
-                                             SendCallback* sendCallback) {
-  string brokerAddr = getFactory()->findBrokerAddressInPublish(mq.getBrokerName());
-
-  if (brokerAddr.empty()) {
-    getFactory()->tryToFindTopicPublishInfo(mq.getTopic(), getSessionCredentials());
-    brokerAddr = getFactory()->findBrokerAddressInPublish(mq.getBrokerName());
-  }
-
-  if (!brokerAddr.empty()) {
-    try {
-      bool isBatchMsg = std::type_index(typeid(msg)) == std::type_index(typeid(BatchMessage));
-      // msgId is produced by client, offsetMsgId produced by broker. (same with java sdk)
-      if (!isBatchMsg) {
-        string unique_id = StringIdMaker::getInstance().createUniqID();
-        msg.setProperty(MQMessage::PROPERTY_UNIQ_CLIENT_MESSAGE_ID_KEYIDX, unique_id);
-
-        // batch does not support compressing right now,
-        tryToCompressMessage(msg);
-      }
-
-      LOG_DEBUG("produce before:%s to %s", msg.toString().c_str(), mq.toString().c_str());
-
-      SendMessageRequestHeader* requestHeader = new SendMessageRequestHeader();
-      requestHeader->producerGroup = getGroupName();
-      requestHeader->topic = (msg.getTopic());
-      requestHeader->defaultTopic = DEFAULT_TOPIC;
-      requestHeader->defaultTopicQueueNums = 4;
-      requestHeader->queueId = (mq.getQueueId());
-      requestHeader->sysFlag = (msg.getSysFlag());
-      requestHeader->bornTimestamp = UtilAll::currentTimeMillis();
-      requestHeader->flag = (msg.getFlag());
-      requestHeader->consumeRetryTimes = 16;
-      requestHeader->batch = isBatchMsg;
-      requestHeader->properties = (MQDecoder::messageProperties2String(msg.getProperties()));
-
-      return getFactory()->getMQClientAPIImpl()->sendMessage(brokerAddr, mq.getBrokerName(), msg, requestHeader,
-                                                             getSendMsgTimeout(), getRetryTimes4Async(),
-                                                             communicationMode, sendCallback, getSessionCredentials());
-    } catch (MQException& e) {
-      throw e;
-    }
-  }
-  THROW_MQEXCEPTION(MQClientException, "The broker[" + mq.getBrokerName() + "] not exist", -1);
-}
-
-SendResult DefaultMQProducer::sendSelectImpl(MQMessage& msg,
-                                             MessageQueueSelector* pSelector,
-                                             void* pArg,
-                                             int communicationMode,
-                                             SendCallback* sendCallback) {
-  Validators::checkMessage(msg, getMaxMessageSize());
-
-  boost::weak_ptr<TopicPublishInfo> weak_topicPublishInfo(
-      getFactory()->tryToFindTopicPublishInfo(msg.getTopic(), getSessionCredentials()));
-  boost::shared_ptr<TopicPublishInfo> topicPublishInfo(weak_topicPublishInfo.lock());
-  if (topicPublishInfo)  //&& topicPublishInfo->ok())
-  {
-    MQMessageQueue mq = pSelector->select(topicPublishInfo->getMessageQueueList(), msg, pArg);
-    return sendKernelImpl(msg, mq, communicationMode, sendCallback);
-  }
-  THROW_MQEXCEPTION(MQClientException, "No route info for this topic", -1);
-}
-
-SendResult DefaultMQProducer::sendAutoRetrySelectImpl(MQMessage& msg,
-                                                      MessageQueueSelector* pSelector,
-                                                      void* pArg,
-                                                      int communicationMode,
-                                                      SendCallback* pSendCallback,
-                                                      int autoRetryTimes,
-                                                      bool bActiveMQ) {
-  Validators::checkMessage(msg, getMaxMessageSize());
-
-  MQMessageQueue lastmq;
-  MQMessageQueue mq;
-  int mq_index = 0;
-  for (int times = 1; times <= autoRetryTimes + 1; times++) {
-    boost::weak_ptr<TopicPublishInfo> weak_topicPublishInfo(
-        getFactory()->tryToFindTopicPublishInfo(msg.getTopic(), getSessionCredentials()));
-    boost::shared_ptr<TopicPublishInfo> topicPublishInfo(weak_topicPublishInfo.lock());
-    if (topicPublishInfo) {
-      SendResult sendResult;
-      if (times == 1) {
-        // always send to selected MQ firstly, evenif bActiveMQ was setted to true
-        mq = pSelector->select(topicPublishInfo->getMessageQueueList(), msg, pArg);
-        lastmq = mq;
-      } else {
-        LOG_INFO("sendAutoRetrySelectImpl with times:%d", times);
-        std::vector<MQMessageQueue> mqs(topicPublishInfo->getMessageQueueList());
-        for (size_t i = 0; i < mqs.size(); i++) {
-          if (mqs[i] == lastmq)
-            mq_index = i;
-        }
-        if (bActiveMQ)
-          mq = topicPublishInfo->selectOneActiveMessageQueue(lastmq, mq_index);
-        else
-          mq = topicPublishInfo->selectOneMessageQueue(lastmq, mq_index);
-        lastmq = mq;
-        if (mq.getQueueId() == -1) {
-          // THROW_MQEXCEPTION(MQClientException, "the MQMessageQueue is
-          // invalide", -1);
-          continue;
-        }
-      }
-
-      try {
-        LOG_DEBUG("send to broker:%s", mq.toString().c_str());
-        sendResult = sendKernelImpl(msg, mq, communicationMode, pSendCallback);
-        switch (communicationMode) {
-          case ComMode_ASYNC:
-            return sendResult;
-          case ComMode_ONEWAY:
-            return sendResult;
-          case ComMode_SYNC:
-            if (sendResult.getSendStatus() != SEND_OK) {
-              if (bActiveMQ) {
-                topicPublishInfo->updateNonServiceMessageQueue(mq, getSendMsgTimeout());
-              }
-              continue;
-            }
-            return sendResult;
-          default:
-            break;
-        }
-      } catch (...) {
-        LOG_ERROR("send failed of times:%d,mq:%s", times, mq.toString().c_str());
-        if (bActiveMQ) {
-          topicPublishInfo->updateNonServiceMessageQueue(mq, getSendMsgTimeout());
-        }
-        continue;
-      }
-    }  // end of for
-    LOG_WARN("Retry many times, still failed");
-  }
-  THROW_MQEXCEPTION(MQClientException, "No route info of this topic, ", -1);
-}
-
-bool DefaultMQProducer::tryToCompressMessage(MQMessage& msg) {
-  int sysFlag = msg.getSysFlag();
-  if ((sysFlag & MessageSysFlag::CompressedFlag) == MessageSysFlag::CompressedFlag) {
-    return true;
-  }
-
-  string body = msg.getBody();
-  if ((int)body.length() >= getCompressMsgBodyOverHowmuch()) {
-    string outBody;
-    if (UtilAll::deflate(body, outBody, getCompressLevel())) {
-      msg.setBody(outBody);
-      msg.setSysFlag(sysFlag | MessageSysFlag::CompressedFlag);
-      return true;
-    }
-  }
-
-  return false;
+void DefaultMQProducer::setRetryTimes4Async(int times) {
+  impl->setRetryTimes4Async(times);
 }
 
-int DefaultMQProducer::getRetryTimes() const {
-  return m_retryTimes;
+int DefaultMQProducer::getRetryTimes4Async() const {
+  return impl->getRetryTimes4Async();
 }
 
-void DefaultMQProducer::setRetryTimes(int times) {
-  if (times <= 0) {
-    LOG_WARN("set retry times illegal, use default value:5");
-    return;
-  }
+void DefaultMQProducer::setLogLevel(elogLevel inputLevel) {
+  impl->setLogLevel(inputLevel);
+}
 
-  if (times > 15) {
-    LOG_WARN("set retry times illegal, use max value:15");
-    m_retryTimes = 15;
-    return;
-  }
-  LOG_WARN("set retry times to:%d", times);
-  m_retryTimes = times;
+elogLevel DefaultMQProducer::getLogLevel() {
+  return impl->getLogLevel();
+}
+void DefaultMQProducer::setLogFileSizeAndNum(int fileNum, long perFileSize) {
+  impl->setLogFileSizeAndNum(fileNum, perFileSize);
 }
 
-int DefaultMQProducer::getRetryTimes4Async() const {
-  return m_retryTimes4Async;
+void DefaultMQProducer::setTcpTransportPullThreadNum(int num) {
+  impl->setTcpTransportPullThreadNum(num);
+}
+const int DefaultMQProducer::getTcpTransportPullThreadNum() const {
+  return impl->getTcpTransportPullThreadNum();
 }
 
-void DefaultMQProducer::setRetryTimes4Async(int times) {
-  if (times <= 0) {
-    LOG_WARN("set retry times illegal, use default value:1");
-    m_retryTimes4Async = 1;
-    return;
-  }
-
-  if (times > 15) {
-    LOG_WARN("set retry times illegal, use max value:15");
-    m_retryTimes4Async = 15;
-    return;
-  }
-  LOG_INFO("set retry times to:%d", times);
-  m_retryTimes4Async = times;
-}
-
-// we should deal with name space before producer start.
-bool DefaultMQProducer::dealWithNameSpace() {
-  string ns = getNameSpace();
-  if (ns.empty()) {
-    string nsAddr = getNamesrvAddr();
-    if (!NameSpaceUtil::checkNameSpaceExistInNameServer(nsAddr)) {
-      return true;
-    }
-    ns = NameSpaceUtil::getNameSpaceFromNsURL(nsAddr);
-    // reset namespace
-    setNameSpace(ns);
-  }
-  // reset group name
-  if (!NameSpaceUtil::hasNameSpace(getGroupName(), ns)) {
-    string fullGID = NameSpaceUtil::withNameSpace(getGroupName(), ns);
-    setGroupName(fullGID);
-  }
-  return true;
-}
-//<!***************************************************************************
-}  // namespace rocketmq
+void DefaultMQProducer::setTcpTransportConnectTimeout(uint64_t timeout) {
+  impl->setTcpTransportConnectTimeout(timeout);
+}
+const uint64_t DefaultMQProducer::getTcpTransportConnectTimeout() const {
+  return impl->getTcpTransportConnectTimeout();
+}
+void DefaultMQProducer::setTcpTransportTryLockTimeout(uint64_t timeout) {
+  impl->setTcpTransportTryLockTimeout(timeout);
+}
+const uint64_t DefaultMQProducer::getTcpTransportTryLockTimeout() const {
+  return impl->getTcpTransportTryLockTimeout();
+}
+
+void DefaultMQProducer::setUnitName(std::string unitName) {
+  impl->setUnitName(unitName);
+}
+const std::string& DefaultMQProducer::getUnitName() const {
+  return impl->getUnitName();
+}
+
+SendResult DefaultMQProducer::send(MQMessage& msg, bool bSelectActiveBroker) {
+  return impl->send(msg, bSelectActiveBroker);
+}
+
+SendResult DefaultMQProducer::send(MQMessage& msg, const MQMessageQueue& mq) {
+  return impl->send(msg, mq);
+}
+
+SendResult DefaultMQProducer::send(MQMessage& msg, MessageQueueSelector* selector, void* arg) {
+  return impl->send(msg, selector, arg);
+}
+
+SendResult DefaultMQProducer::send(MQMessage& msg,
+                                   MessageQueueSelector* selector,
+                                   void* arg,
+                                   int autoRetryTimes,
+                                   bool bActiveBroker) {
+  return impl->send(msg, selector, arg, autoRetryTimes, bActiveBroker);
+}
+
+SendResult DefaultMQProducer::send(std::vector<MQMessage>& msgs) {
+  return impl->send(msgs);
+}
+
+SendResult DefaultMQProducer::send(std::vector<MQMessage>& msgs, const MQMessageQueue& mq) {
+  return impl->send(msgs, mq);
+}
+
+void DefaultMQProducer::send(MQMessage& msg, SendCallback* pSendCallback, bool bSelectActiveBroker) {
+  impl->send(msg, pSendCallback, bSelectActiveBroker);
+}
+
+void DefaultMQProducer::send(MQMessage& msg, const MQMessageQueue& mq, SendCallback* pSendCallback) {
+  impl->send(msg, mq, pSendCallback);
+}
+
+void DefaultMQProducer::send(MQMessage& msg, MessageQueueSelector* selector, void* arg, SendCallback* pSendCallback) {
+  impl->send(msg, selector, arg, pSendCallback);
+}
+
+void DefaultMQProducer::sendOneway(MQMessage& msg, bool bSelectActiveBroker) {
+  impl->sendOneway(msg, bSelectActiveBroker);
+}
+
+void DefaultMQProducer::sendOneway(MQMessage& msg, const MQMessageQueue& mq) {
+  impl->sendOneway(msg, mq);
+}
+
+void DefaultMQProducer::sendOneway(MQMessage& msg, MessageQueueSelector* selector, void* arg) {
+  impl->sendOneway(msg, selector, arg);
+}
+
+}  // namespace rocketmq
\ No newline at end of file
diff --git a/src/producer/DefaultMQProducer.cpp b/src/producer/DefaultMQProducerImpl.cpp
similarity index 80%
copy from src/producer/DefaultMQProducer.cpp
copy to src/producer/DefaultMQProducerImpl.cpp
index ee81a7b..aff238b 100644
--- a/src/producer/DefaultMQProducer.cpp
+++ b/src/producer/DefaultMQProducerImpl.cpp
@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-#include "DefaultMQProducer.h"
+#include "DefaultMQProducerImpl.h"
 
 #include <assert.h>
 #include <typeindex>
@@ -39,7 +39,7 @@
 namespace rocketmq {
 
 //<!************************************************************************
-DefaultMQProducer::DefaultMQProducer(const string& groupname)
+DefaultMQProducerImpl::DefaultMQProducerImpl(const string& groupname)
     : m_sendMsgTimeout(3000),
       m_compressMsgBodyOverHowmuch(4 * 1024),
       m_maxMessageSize(1024 * 128),
@@ -52,9 +52,9 @@ DefaultMQProducer::DefaultMQProducer(const string& groupname)
   setGroupName(gname);
 }
 
-DefaultMQProducer::~DefaultMQProducer() {}
+DefaultMQProducerImpl::~DefaultMQProducerImpl() {}
 
-void DefaultMQProducer::start() {
+void DefaultMQProducerImpl::start() {
 #ifndef WIN32
   /* Ignore the SIGPIPE */
   struct sigaction sa;
@@ -68,8 +68,8 @@ void DefaultMQProducer::start() {
   switch (m_serviceState) {
     case CREATE_JUST: {
       m_serviceState = START_FAILED;
-      MQClient::start();
-      LOG_INFO("DefaultMQProducer:%s start", m_GroupName.c_str());
+      DefaultMQClient::start();
+      LOG_INFO("DefaultMQProducerImpl:%s start", m_GroupName.c_str());
 
       bool registerOK = getFactory()->registerProducer(this);
       if (!registerOK) {
@@ -93,10 +93,10 @@ void DefaultMQProducer::start() {
   }
 }
 
-void DefaultMQProducer::shutdown() {
+void DefaultMQProducerImpl::shutdown() {
   switch (m_serviceState) {
     case RUNNING: {
-      LOG_INFO("DefaultMQProducer shutdown");
+      LOG_INFO("DefaultMQProducerImpl shutdown");
       getFactory()->unregisterProducer(this);
       getFactory()->shutdown();
       m_serviceState = SHUTDOWN_ALREADY;
@@ -110,7 +110,7 @@ void DefaultMQProducer::shutdown() {
   }
 }
 
-SendResult DefaultMQProducer::send(MQMessage& msg, bool bSelectActiveBroker) {
+SendResult DefaultMQProducerImpl::send(MQMessage& msg, bool bSelectActiveBroker) {
   Validators::checkMessage(msg, getMaxMessageSize());
   if (!NameSpaceUtil::hasNameSpace(msg.getTopic(), getNameSpace())) {
     MessageAccessor::withNameSpace(msg, getNameSpace());
@@ -124,7 +124,7 @@ SendResult DefaultMQProducer::send(MQMessage& msg, bool bSelectActiveBroker) {
   return SendResult();
 }
 
-void DefaultMQProducer::send(MQMessage& msg, SendCallback* pSendCallback, bool bSelectActiveBroker) {
+void DefaultMQProducerImpl::send(MQMessage& msg, SendCallback* pSendCallback, bool bSelectActiveBroker) {
   Validators::checkMessage(msg, getMaxMessageSize());
   if (!NameSpaceUtil::hasNameSpace(msg.getTopic(), getNameSpace())) {
     MessageAccessor::withNameSpace(msg, getNameSpace());
@@ -137,7 +137,7 @@ void DefaultMQProducer::send(MQMessage& msg, SendCallback* pSendCallback, bool b
   }
 }
 
-SendResult DefaultMQProducer::send(std::vector<MQMessage>& msgs) {
+SendResult DefaultMQProducerImpl::send(std::vector<MQMessage>& msgs) {
   SendResult result;
   try {
     BatchMessage batchMessage = buildBatchMessage(msgs);
@@ -149,7 +149,7 @@ SendResult DefaultMQProducer::send(std::vector<MQMessage>& msgs) {
   return result;
 }
 
-SendResult DefaultMQProducer::send(std::vector<MQMessage>& msgs, const MQMessageQueue& mq) {
+SendResult DefaultMQProducerImpl::send(std::vector<MQMessage>& msgs, const MQMessageQueue& mq) {
   SendResult result;
   try {
     BatchMessage batchMessage = buildBatchMessage(msgs);
@@ -161,7 +161,7 @@ SendResult DefaultMQProducer::send(std::vector<MQMessage>& msgs, const MQMessage
   return result;
 }
 
-BatchMessage DefaultMQProducer::buildBatchMessage(std::vector<MQMessage>& msgs) {
+BatchMessage DefaultMQProducerImpl::buildBatchMessage(std::vector<MQMessage>& msgs) {
   if (msgs.size() < 1) {
     THROW_MQEXCEPTION(MQClientException, "msgs need one message at least", -1);
   }
@@ -200,7 +200,7 @@ BatchMessage DefaultMQProducer::buildBatchMessage(std::vector<MQMessage>& msgs)
   return batchMessage;
 }
 
-SendResult DefaultMQProducer::send(MQMessage& msg, const MQMessageQueue& mq) {
+SendResult DefaultMQProducerImpl::send(MQMessage& msg, const MQMessageQueue& mq) {
   Validators::checkMessage(msg, getMaxMessageSize());
   if (!NameSpaceUtil::hasNameSpace(msg.getTopic(), getNameSpace())) {
     MessageAccessor::withNameSpace(msg, getNameSpace());
@@ -217,7 +217,7 @@ SendResult DefaultMQProducer::send(MQMessage& msg, const MQMessageQueue& mq) {
   return SendResult();
 }
 
-void DefaultMQProducer::send(MQMessage& msg, const MQMessageQueue& mq, SendCallback* pSendCallback) {
+void DefaultMQProducerImpl::send(MQMessage& msg, const MQMessageQueue& mq, SendCallback* pSendCallback) {
   Validators::checkMessage(msg, getMaxMessageSize());
   if (!NameSpaceUtil::hasNameSpace(msg.getTopic(), getNameSpace())) {
     MessageAccessor::withNameSpace(msg, getNameSpace());
@@ -233,7 +233,7 @@ void DefaultMQProducer::send(MQMessage& msg, const MQMessageQueue& mq, SendCallb
   }
 }
 
-void DefaultMQProducer::sendOneway(MQMessage& msg, bool bSelectActiveBroker) {
+void DefaultMQProducerImpl::sendOneway(MQMessage& msg, bool bSelectActiveBroker) {
   Validators::checkMessage(msg, getMaxMessageSize());
   if (!NameSpaceUtil::hasNameSpace(msg.getTopic(), getNameSpace())) {
     MessageAccessor::withNameSpace(msg, getNameSpace());
@@ -246,7 +246,7 @@ void DefaultMQProducer::sendOneway(MQMessage& msg, bool bSelectActiveBroker) {
   }
 }
 
-void DefaultMQProducer::sendOneway(MQMessage& msg, const MQMessageQueue& mq) {
+void DefaultMQProducerImpl::sendOneway(MQMessage& msg, const MQMessageQueue& mq) {
   Validators::checkMessage(msg, getMaxMessageSize());
   if (!NameSpaceUtil::hasNameSpace(msg.getTopic(), getNameSpace())) {
     MessageAccessor::withNameSpace(msg, getNameSpace());
@@ -262,7 +262,7 @@ void DefaultMQProducer::sendOneway(MQMessage& msg, const MQMessageQueue& mq) {
   }
 }
 
-SendResult DefaultMQProducer::send(MQMessage& msg, MessageQueueSelector* pSelector, void* arg) {
+SendResult DefaultMQProducerImpl::send(MQMessage& msg, MessageQueueSelector* pSelector, void* arg) {
   try {
     if (!NameSpaceUtil::hasNameSpace(msg.getTopic(), getNameSpace())) {
       MessageAccessor::withNameSpace(msg, getNameSpace());
@@ -275,11 +275,11 @@ SendResult DefaultMQProducer::send(MQMessage& msg, MessageQueueSelector* pSelect
   return SendResult();
 }
 
-SendResult DefaultMQProducer::send(MQMessage& msg,
-                                   MessageQueueSelector* pSelector,
-                                   void* arg,
-                                   int autoRetryTimes,
-                                   bool bActiveBroker) {
+SendResult DefaultMQProducerImpl::send(MQMessage& msg,
+                                       MessageQueueSelector* pSelector,
+                                       void* arg,
+                                       int autoRetryTimes,
+                                       bool bActiveBroker) {
   try {
     if (!NameSpaceUtil::hasNameSpace(msg.getTopic(), getNameSpace())) {
       MessageAccessor::withNameSpace(msg, getNameSpace());
@@ -292,7 +292,10 @@ SendResult DefaultMQProducer::send(MQMessage& msg,
   return SendResult();
 }
 
-void DefaultMQProducer::send(MQMessage& msg, MessageQueueSelector* pSelector, void* arg, SendCallback* pSendCallback) {
+void DefaultMQProducerImpl::send(MQMessage& msg,
+                                 MessageQueueSelector* pSelector,
+                                 void* arg,
+                                 SendCallback* pSendCallback) {
   try {
     if (!NameSpaceUtil::hasNameSpace(msg.getTopic(), getNameSpace())) {
       MessageAccessor::withNameSpace(msg, getNameSpace());
@@ -304,7 +307,7 @@ void DefaultMQProducer::send(MQMessage& msg, MessageQueueSelector* pSelector, vo
   }
 }
 
-void DefaultMQProducer::sendOneway(MQMessage& msg, MessageQueueSelector* pSelector, void* arg) {
+void DefaultMQProducerImpl::sendOneway(MQMessage& msg, MessageQueueSelector* pSelector, void* arg) {
   try {
     if (!NameSpaceUtil::hasNameSpace(msg.getTopic(), getNameSpace())) {
       MessageAccessor::withNameSpace(msg, getNameSpace());
@@ -316,45 +319,45 @@ void DefaultMQProducer::sendOneway(MQMessage& msg, MessageQueueSelector* pSelect
   }
 }
 
-int DefaultMQProducer::getSendMsgTimeout() const {
+int DefaultMQProducerImpl::getSendMsgTimeout() const {
   return m_sendMsgTimeout;
 }
 
-void DefaultMQProducer::setSendMsgTimeout(int sendMsgTimeout) {
+void DefaultMQProducerImpl::setSendMsgTimeout(int sendMsgTimeout) {
   m_sendMsgTimeout = sendMsgTimeout;
 }
 
-int DefaultMQProducer::getCompressMsgBodyOverHowmuch() const {
+int DefaultMQProducerImpl::getCompressMsgBodyOverHowmuch() const {
   return m_compressMsgBodyOverHowmuch;
 }
 
-void DefaultMQProducer::setCompressMsgBodyOverHowmuch(int compressMsgBodyOverHowmuch) {
+void DefaultMQProducerImpl::setCompressMsgBodyOverHowmuch(int compressMsgBodyOverHowmuch) {
   m_compressMsgBodyOverHowmuch = compressMsgBodyOverHowmuch;
 }
 
-int DefaultMQProducer::getMaxMessageSize() const {
+int DefaultMQProducerImpl::getMaxMessageSize() const {
   return m_maxMessageSize;
 }
 
-void DefaultMQProducer::setMaxMessageSize(int maxMessageSize) {
+void DefaultMQProducerImpl::setMaxMessageSize(int maxMessageSize) {
   m_maxMessageSize = maxMessageSize;
 }
 
-int DefaultMQProducer::getCompressLevel() const {
+int DefaultMQProducerImpl::getCompressLevel() const {
   return m_compressLevel;
 }
 
-void DefaultMQProducer::setCompressLevel(int compressLevel) {
+void DefaultMQProducerImpl::setCompressLevel(int compressLevel) {
   assert((compressLevel >= 0 && compressLevel <= 9) || compressLevel == -1);
 
   m_compressLevel = compressLevel;
 }
 
 //<!************************************************************************
-SendResult DefaultMQProducer::sendDefaultImpl(MQMessage& msg,
-                                              int communicationMode,
-                                              SendCallback* pSendCallback,
-                                              bool bActiveMQ) {
+SendResult DefaultMQProducerImpl::sendDefaultImpl(MQMessage& msg,
+                                                  int communicationMode,
+                                                  SendCallback* pSendCallback,
+                                                  bool bActiveMQ) {
   MQMessageQueue lastmq;
   int mq_index = 0;
   for (int times = 1; times <= m_retryTimes; times++) {
@@ -415,10 +418,10 @@ SendResult DefaultMQProducer::sendDefaultImpl(MQMessage& msg,
   THROW_MQEXCEPTION(MQClientException, info, -1);
 }
 
-SendResult DefaultMQProducer::sendKernelImpl(MQMessage& msg,
-                                             const MQMessageQueue& mq,
-                                             int communicationMode,
-                                             SendCallback* sendCallback) {
+SendResult DefaultMQProducerImpl::sendKernelImpl(MQMessage& msg,
+                                                 const MQMessageQueue& mq,
+                                                 int communicationMode,
+                                                 SendCallback* sendCallback) {
   string brokerAddr = getFactory()->findBrokerAddressInPublish(mq.getBrokerName());
 
   if (brokerAddr.empty()) {
@@ -463,11 +466,11 @@ SendResult DefaultMQProducer::sendKernelImpl(MQMessage& msg,
   THROW_MQEXCEPTION(MQClientException, "The broker[" + mq.getBrokerName() + "] not exist", -1);
 }
 
-SendResult DefaultMQProducer::sendSelectImpl(MQMessage& msg,
-                                             MessageQueueSelector* pSelector,
-                                             void* pArg,
-                                             int communicationMode,
-                                             SendCallback* sendCallback) {
+SendResult DefaultMQProducerImpl::sendSelectImpl(MQMessage& msg,
+                                                 MessageQueueSelector* pSelector,
+                                                 void* pArg,
+                                                 int communicationMode,
+                                                 SendCallback* sendCallback) {
   Validators::checkMessage(msg, getMaxMessageSize());
 
   boost::weak_ptr<TopicPublishInfo> weak_topicPublishInfo(
@@ -481,13 +484,13 @@ SendResult DefaultMQProducer::sendSelectImpl(MQMessage& msg,
   THROW_MQEXCEPTION(MQClientException, "No route info for this topic", -1);
 }
 
-SendResult DefaultMQProducer::sendAutoRetrySelectImpl(MQMessage& msg,
-                                                      MessageQueueSelector* pSelector,
-                                                      void* pArg,
-                                                      int communicationMode,
-                                                      SendCallback* pSendCallback,
-                                                      int autoRetryTimes,
-                                                      bool bActiveMQ) {
+SendResult DefaultMQProducerImpl::sendAutoRetrySelectImpl(MQMessage& msg,
+                                                          MessageQueueSelector* pSelector,
+                                                          void* pArg,
+                                                          int communicationMode,
+                                                          SendCallback* pSendCallback,
+                                                          int autoRetryTimes,
+                                                          bool bActiveMQ) {
   Validators::checkMessage(msg, getMaxMessageSize());
 
   MQMessageQueue lastmq;
@@ -554,7 +557,7 @@ SendResult DefaultMQProducer::sendAutoRetrySelectImpl(MQMessage& msg,
   THROW_MQEXCEPTION(MQClientException, "No route info of this topic, ", -1);
 }
 
-bool DefaultMQProducer::tryToCompressMessage(MQMessage& msg) {
+bool DefaultMQProducerImpl::tryToCompressMessage(MQMessage& msg) {
   int sysFlag = msg.getSysFlag();
   if ((sysFlag & MessageSysFlag::CompressedFlag) == MessageSysFlag::CompressedFlag) {
     return true;
@@ -573,11 +576,11 @@ bool DefaultMQProducer::tryToCompressMessage(MQMessage& msg) {
   return false;
 }
 
-int DefaultMQProducer::getRetryTimes() const {
+int DefaultMQProducerImpl::getRetryTimes() const {
   return m_retryTimes;
 }
 
-void DefaultMQProducer::setRetryTimes(int times) {
+void DefaultMQProducerImpl::setRetryTimes(int times) {
   if (times <= 0) {
     LOG_WARN("set retry times illegal, use default value:5");
     return;
@@ -592,11 +595,11 @@ void DefaultMQProducer::setRetryTimes(int times) {
   m_retryTimes = times;
 }
 
-int DefaultMQProducer::getRetryTimes4Async() const {
+int DefaultMQProducerImpl::getRetryTimes4Async() const {
   return m_retryTimes4Async;
 }
 
-void DefaultMQProducer::setRetryTimes4Async(int times) {
+void DefaultMQProducerImpl::setRetryTimes4Async(int times) {
   if (times <= 0) {
     LOG_WARN("set retry times illegal, use default value:1");
     m_retryTimes4Async = 1;
@@ -613,7 +616,7 @@ void DefaultMQProducer::setRetryTimes4Async(int times) {
 }
 
 // we should deal with name space before producer start.
-bool DefaultMQProducer::dealWithNameSpace() {
+bool DefaultMQProducerImpl::dealWithNameSpace() {
   string ns = getNameSpace();
   if (ns.empty()) {
     string nsAddr = getNamesrvAddr();
diff --git a/include/DefaultMQProducer.h b/src/producer/DefaultMQProducerImpl.h
similarity index 93%
copy from include/DefaultMQProducer.h
copy to src/producer/DefaultMQProducerImpl.h
index 630e765..c4d2393 100644
--- a/include/DefaultMQProducer.h
+++ b/src/producer/DefaultMQProducerImpl.h
@@ -1,118 +1,118 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef __DEFAULTMQPRODUCER_H__
-#define __DEFAULTMQPRODUCER_H__
-
-#include "BatchMessage.h"
-#include "MQMessageQueue.h"
-#include "MQProducer.h"
-#include "RocketMQClient.h"
-#include "SendResult.h"
-
-namespace rocketmq {
-//<!***************************************************************************
-class ROCKETMQCLIENT_API DefaultMQProducer : public MQProducer {
- public:
-  DefaultMQProducer(const std::string& groupname);
-  virtual ~DefaultMQProducer();
-
-  //<!begin mqadmin;
-  virtual void start();
-  virtual void shutdown();
-  //<!end mqadmin;
-
-  //<! begin MQProducer;
-  virtual SendResult send(MQMessage& msg, bool bSelectActiveBroker = false);
-  virtual SendResult send(MQMessage& msg, const MQMessageQueue& mq);
-  virtual SendResult send(MQMessage& msg, MessageQueueSelector* selector, void* arg);
-  virtual SendResult send(MQMessage& msg,
-                          MessageQueueSelector* selector,
-                          void* arg,
-                          int autoRetryTimes,
-                          bool bActiveBroker = false);
-  virtual SendResult send(std::vector<MQMessage>& msgs);
-  virtual SendResult send(std::vector<MQMessage>& msgs, const MQMessageQueue& mq);
-  virtual void send(MQMessage& msg, SendCallback* pSendCallback, bool bSelectActiveBroker = false);
-  virtual void send(MQMessage& msg, const MQMessageQueue& mq, SendCallback* pSendCallback);
-  virtual void send(MQMessage& msg, MessageQueueSelector* selector, void* arg, SendCallback* pSendCallback);
-  virtual void sendOneway(MQMessage& msg, bool bSelectActiveBroker = false);
-  virtual void sendOneway(MQMessage& msg, const MQMessageQueue& mq);
-  virtual void sendOneway(MQMessage& msg, MessageQueueSelector* selector, void* arg);
-  //<! end MQProducer;
-
-  // set and get timeout of per msg
-  int getSendMsgTimeout() const;
-  void setSendMsgTimeout(int sendMsgTimeout);
-
-  /*
-  *  if msgBody size is large than m_compressMsgBodyOverHowmuch
-      rocketmq cpp will compress msgBody according to compressLevel
-  */
-  int getCompressMsgBodyOverHowmuch() const;
-  void setCompressMsgBodyOverHowmuch(int compressMsgBodyOverHowmuch);
-  int getCompressLevel() const;
-  void setCompressLevel(int compressLevel);
-
-  // if msgbody size larger than maxMsgBodySize, exception will be throwed
-  int getMaxMessageSize() const;
-  void setMaxMessageSize(int maxMessageSize);
-
-  // set msg max retry times, default retry times is 5
-  int getRetryTimes() const;
-  void setRetryTimes(int times);
-
-  int getRetryTimes4Async() const;
-  void setRetryTimes4Async(int times);
-
- protected:
-  SendResult sendAutoRetrySelectImpl(MQMessage& msg,
-                                     MessageQueueSelector* pSelector,
-                                     void* pArg,
-                                     int communicationMode,
-                                     SendCallback* pSendCallback,
-                                     int retryTimes,
-                                     bool bActiveBroker = false);
-  SendResult sendSelectImpl(MQMessage& msg,
-                            MessageQueueSelector* pSelector,
-                            void* pArg,
-                            int communicationMode,
-                            SendCallback* sendCallback);
-  SendResult sendDefaultImpl(MQMessage& msg,
-                             int communicationMode,
-                             SendCallback* pSendCallback,
-                             bool bActiveBroker = false);
-  SendResult sendKernelImpl(MQMessage& msg,
-                            const MQMessageQueue& mq,
-                            int communicationMode,
-                            SendCallback* pSendCallback);
-  bool tryToCompressMessage(MQMessage& msg);
-  BatchMessage buildBatchMessage(std::vector<MQMessage>& msgs);
-  bool dealWithNameSpace();
-
- private:
-  int m_sendMsgTimeout;
-  int m_compressMsgBodyOverHowmuch;
-  int m_maxMessageSize;  //<! default:128K;
-  // bool m_retryAnotherBrokerWhenNotStoreOK;
-  int m_compressLevel;
-  int m_retryTimes;
-  int m_retryTimes4Async;
-};
-//<!***************************************************************************
-}  // namespace rocketmq
-#endif
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __DEFAULTMQPRODUCERIMPL_H__
+#define __DEFAULTMQPRODUCERIMPL_H__
+
+#include "BatchMessage.h"
+#include "MQMessageQueue.h"
+#include "MQProducer.h"
+#include "RocketMQClient.h"
+#include "SendResult.h"
+
+namespace rocketmq {
+//<!***************************************************************************
+class DefaultMQProducerImpl : public MQProducer {
+ public:
+  DefaultMQProducerImpl(const std::string& groupname);
+  virtual ~DefaultMQProducerImpl();
+
+  //<!begin mqadmin;
+  virtual void start();
+  virtual void shutdown();
+  //<!end mqadmin;
+
+  //<! begin MQProducer;
+  virtual SendResult send(MQMessage& msg, bool bSelectActiveBroker = false);
+  virtual SendResult send(MQMessage& msg, const MQMessageQueue& mq);
+  virtual SendResult send(MQMessage& msg, MessageQueueSelector* selector, void* arg);
+  virtual SendResult send(MQMessage& msg,
+                          MessageQueueSelector* selector,
+                          void* arg,
+                          int autoRetryTimes,
+                          bool bActiveBroker = false);
+  virtual SendResult send(std::vector<MQMessage>& msgs);
+  virtual SendResult send(std::vector<MQMessage>& msgs, const MQMessageQueue& mq);
+  virtual void send(MQMessage& msg, SendCallback* pSendCallback, bool bSelectActiveBroker = false);
+  virtual void send(MQMessage& msg, const MQMessageQueue& mq, SendCallback* pSendCallback);
+  virtual void send(MQMessage& msg, MessageQueueSelector* selector, void* arg, SendCallback* pSendCallback);
+  virtual void sendOneway(MQMessage& msg, bool bSelectActiveBroker = false);
+  virtual void sendOneway(MQMessage& msg, const MQMessageQueue& mq);
+  virtual void sendOneway(MQMessage& msg, MessageQueueSelector* selector, void* arg);
+  //<! end MQProducer;
+
+  // set and get timeout of per msg
+  int getSendMsgTimeout() const;
+  void setSendMsgTimeout(int sendMsgTimeout);
+
+  /*
+  *  if msgBody size is large than m_compressMsgBodyOverHowmuch
+      rocketmq cpp will compress msgBody according to compressLevel
+  */
+  int getCompressMsgBodyOverHowmuch() const;
+  void setCompressMsgBodyOverHowmuch(int compressMsgBodyOverHowmuch);
+  int getCompressLevel() const;
+  void setCompressLevel(int compressLevel);
+
+  // if msgbody size larger than maxMsgBodySize, exception will be throwed
+  int getMaxMessageSize() const;
+  void setMaxMessageSize(int maxMessageSize);
+
+  // set msg max retry times, default retry times is 5
+  int getRetryTimes() const;
+  void setRetryTimes(int times);
+
+  int getRetryTimes4Async() const;
+  void setRetryTimes4Async(int times);
+
+ protected:
+  SendResult sendAutoRetrySelectImpl(MQMessage& msg,
+                                     MessageQueueSelector* pSelector,
+                                     void* pArg,
+                                     int communicationMode,
+                                     SendCallback* pSendCallback,
+                                     int retryTimes,
+                                     bool bActiveBroker = false);
+  SendResult sendSelectImpl(MQMessage& msg,
+                            MessageQueueSelector* pSelector,
+                            void* pArg,
+                            int communicationMode,
+                            SendCallback* sendCallback);
+  SendResult sendDefaultImpl(MQMessage& msg,
+                             int communicationMode,
+                             SendCallback* pSendCallback,
+                             bool bActiveBroker = false);
+  SendResult sendKernelImpl(MQMessage& msg,
+                            const MQMessageQueue& mq,
+                            int communicationMode,
+                            SendCallback* pSendCallback);
+  bool tryToCompressMessage(MQMessage& msg);
+  BatchMessage buildBatchMessage(std::vector<MQMessage>& msgs);
+  bool dealWithNameSpace();
+
+ private:
+  int m_sendMsgTimeout;
+  int m_compressMsgBodyOverHowmuch;
+  int m_maxMessageSize;  //<! default:128K;
+  // bool m_retryAnotherBrokerWhenNotStoreOK;
+  int m_compressLevel;
+  int m_retryTimes;
+  int m_retryTimes4Async;
+};
+//<!***************************************************************************
+}  // namespace rocketmq
+#endif
diff --git a/src/producer/TransactionMQProducer.cpp b/src/producer/TransactionMQProducer.cpp
index fbd78c5..b10e279 100644
--- a/src/producer/TransactionMQProducer.cpp
+++ b/src/producer/TransactionMQProducer.cpp
@@ -1,135 +1,148 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
 #include "TransactionMQProducer.h"
-#include <string>
-#include "CommandHeader.h"
-#include "Logging.h"
-#include "MQClientFactory.h"
-#include "MQDecoder.h"
-#include "MessageSysFlag.h"
-#include "TransactionListener.h"
-#include "TransactionSendResult.h"
-
-using namespace std;
+
+#include "TransactionMQProducerImpl.h"
+
 namespace rocketmq {
 
-void TransactionMQProducer::initTransactionEnv() {
-  for (int i = 0; i < m_thread_num; ++i) {
-    m_threadpool.create_thread(boost::bind(&boost::asio::io_service::run, &m_ioService));
-  }
+TransactionMQProducer::TransactionMQProducer(const std::string& groupName) {
+  impl = new TransactionMQProducerImpl(groupName);
 }
 
-void TransactionMQProducer::destroyTransactionEnv() {
-  m_ioService.stop();
-  m_threadpool.join_all();
+TransactionMQProducer::~TransactionMQProducer() {
+  delete impl;
+}
+void TransactionMQProducer::start() {
+  impl->start();
 }
 
-TransactionSendResult TransactionMQProducer::sendMessageInTransaction(MQMessage& msg, void* arg) {
-  if (!m_transactionListener) {
-    THROW_MQEXCEPTION(MQClientException, "transactionListener is null", -1);
-  }
-
-  SendResult sendResult;
-  msg.setProperty(MQMessage::PROPERTY_TRANSACTION_PREPARED, "true");
-  msg.setProperty(MQMessage::PROPERTY_PRODUCER_GROUP, getGroupName());
-  try {
-    sendResult = send(msg);
-  } catch (MQException& e) {
-    THROW_MQEXCEPTION(MQClientException, e.what(), -1);
-  }
-
-  LocalTransactionState localTransactionState = LocalTransactionState::UNKNOWN;
-  switch (sendResult.getSendStatus()) {
-    case SendStatus::SEND_OK:
-      try {
-        if (sendResult.getTransactionId() != "") {
-          msg.setProperty("__transactionId__", sendResult.getTransactionId());
-        }
-        string transactionId = msg.getProperty(MQMessage::PROPERTY_UNIQ_CLIENT_MESSAGE_ID_KEYIDX);
-        if (transactionId != "") {
-          msg.setTransactionId(transactionId);
-        }
-        LOG_DEBUG("sendMessageInTransaction, msgId:%s, transactionId:%s", sendResult.getMsgId().data(),
-                  transactionId.data());
-        localTransactionState = m_transactionListener->executeLocalTransaction(msg, arg);
-        if (localTransactionState != LocalTransactionState::COMMIT_MESSAGE) {
-          LOG_WARN("executeLocalTransaction ret not LocalTransactionState::commit, msg:%s", msg.toString().data());
-        }
-      } catch (MQException& e) {
-        THROW_MQEXCEPTION(MQClientException, e.what(), -1);
-      }
-      break;
-    case SendStatus::SEND_FLUSH_DISK_TIMEOUT:
-    case SendStatus::SEND_FLUSH_SLAVE_TIMEOUT:
-    case SendStatus::SEND_SLAVE_NOT_AVAILABLE:
-      localTransactionState = LocalTransactionState::ROLLBACK_MESSAGE;
-      LOG_WARN("sendMessageInTransaction, send not ok, rollback, result:%s", sendResult.toString().data());
-      break;
-    default:
-      break;
-  }
-
-  try {
-    endTransaction(sendResult, localTransactionState);
-  } catch (MQException& e) {
-    LOG_WARN("endTransaction exception:%s", e.what());
-  }
-
-  TransactionSendResult transactionSendResult(sendResult.getSendStatus(), sendResult.getMsgId(),
-                                              sendResult.getOffsetMsgId(), sendResult.getMessageQueue(),
-                                              sendResult.getQueueOffset());
-  transactionSendResult.setTransactionId(msg.getTransactionId());
-  transactionSendResult.setLocalTransactionState(localTransactionState);
-  return transactionSendResult;
-}
-
-void TransactionMQProducer::endTransaction(SendResult& sendResult, LocalTransactionState& localTransactionState) {
-  MQMessageId id;
-  if (sendResult.getOffsetMsgId() != "") {
-    id = MQDecoder::decodeMessageId(sendResult.getOffsetMsgId());
-  } else {
-    id = MQDecoder::decodeMessageId(sendResult.getMsgId());
-  }
-  string transId = sendResult.getTransactionId();
-
-  int commitOrRollback = MessageSysFlag::TransactionNotType;
-  switch (localTransactionState) {
-    case COMMIT_MESSAGE:
-      commitOrRollback = MessageSysFlag::TransactionCommitType;
-      break;
-    case ROLLBACK_MESSAGE:
-      commitOrRollback = MessageSysFlag::TransactionRollbackType;
-      break;
-    case UNKNOWN:
-      commitOrRollback = MessageSysFlag::TransactionNotType;
-      break;
-    default:
-      break;
-  }
-
-  bool fromTransCheck = false;
-  EndTransactionRequestHeader* requestHeader =
-      new EndTransactionRequestHeader(getGroupName(), sendResult.getQueueOffset(), id.getOffset(), commitOrRollback,
-                                      fromTransCheck, sendResult.getMsgId(), transId);
-  LOG_DEBUG("endTransaction: msg:%s", requestHeader->toString().data());
-  getFactory()->endTransactionOneway(sendResult.getMessageQueue(), requestHeader, getSessionCredentials());
+void TransactionMQProducer::shutdown() {
+  impl->shutdown();
+}
+
+// start mqclient set
+const std::string& TransactionMQProducer::getNamesrvAddr() const {
+  return impl->getNamesrvAddr();
+}
+
+void TransactionMQProducer::setNamesrvAddr(const std::string& namesrvAddr) {
+  impl->setNamesrvAddr(namesrvAddr);
+}
+
+const std::string& TransactionMQProducer::getNamesrvDomain() const {
+  return impl->getNamesrvDomain();
+}
+
+void TransactionMQProducer::setNamesrvDomain(const std::string& namesrvDomain) {
+  impl->setNamesrvDomain(namesrvDomain);
+}
+void TransactionMQProducer::setSessionCredentials(const std::string& accessKey,
+                                                  const std::string& secretKey,
+                                                  const std::string& accessChannel) {
+  impl->setSessionCredentials(accessKey, secretKey, accessChannel);
+}
+
+const SessionCredentials& TransactionMQProducer::getSessionCredentials() const {
+  return impl->getSessionCredentials();
+}
+const std::string& TransactionMQProducer::getInstanceName() const {
+  return impl->getInstanceName();
+}
+
+void TransactionMQProducer::setInstanceName(const std::string& instanceName) {
+  impl->setInstanceName(instanceName);
+}
+
+const std::string& TransactionMQProducer::getNameSpace() const {
+  return impl->getNameSpace();
+}
+
+void TransactionMQProducer::setNameSpace(const std::string& nameSpace) {
+  impl->setNameSpace(nameSpace);
+}
+const std::string& TransactionMQProducer::getGroupName() const {
+  return impl->getGroupName();
+}
+
+void TransactionMQProducer::setGroupName(const std::string& groupName) {
+  impl->setGroupName(groupName);
+}
+void TransactionMQProducer::setSendMsgTimeout(int sendMsgTimeout) {
+  impl->setSendMsgTimeout(sendMsgTimeout);
+}
+
+int TransactionMQProducer::getSendMsgTimeout() const {
+  return impl->getSendMsgTimeout();
+}
+void TransactionMQProducer::setTcpTransportPullThreadNum(int num) {
+  impl->setTcpTransportPullThreadNum(num);
+}
+const int TransactionMQProducer::getTcpTransportPullThreadNum() const {
+  return impl->getTcpTransportPullThreadNum();
+}
+
+void TransactionMQProducer::setTcpTransportConnectTimeout(uint64_t timeout) {
+  impl->setTcpTransportConnectTimeout(timeout);
+}
+const uint64_t TransactionMQProducer::getTcpTransportConnectTimeout() const {
+  return impl->getTcpTransportConnectTimeout();
+}
+void TransactionMQProducer::setTcpTransportTryLockTimeout(uint64_t timeout) {
+  impl->setTcpTransportTryLockTimeout(timeout);
+}
+const uint64_t TransactionMQProducer::getTcpTransportTryLockTimeout() const {
+  return impl->getTcpTransportTryLockTimeout();
+}
+int TransactionMQProducer::getCompressMsgBodyOverHowmuch() const {
+  return impl->getCompressMsgBodyOverHowmuch();
+}
+
+void TransactionMQProducer::setCompressMsgBodyOverHowmuch(int compressMsgBodyThreshold) {
+  impl->setCompressMsgBodyOverHowmuch(compressMsgBodyThreshold);
+}
+
+int TransactionMQProducer::getCompressLevel() const {
+  return impl->getCompressLevel();
+}
+
+void TransactionMQProducer::setCompressLevel(int compressLevel) {
+  impl->setCompressLevel(compressLevel);
+}
+
+void TransactionMQProducer::setMaxMessageSize(int maxMessageSize) {
+  impl->setMaxMessageSize(maxMessageSize);
+}
+
+int TransactionMQProducer::getMaxMessageSize() const {
+  return impl->getMaxMessageSize();
+}
+
+void TransactionMQProducer::setLogLevel(elogLevel inputLevel) {
+  impl->setLogLevel(inputLevel);
 }
 
+elogLevel TransactionMQProducer::getLogLevel() {
+  return impl->getLogLevel();
+}
+void TransactionMQProducer::setLogFileSizeAndNum(int fileNum, long perFileSize) {
+  impl->setLogFileSizeAndNum(fileNum, perFileSize);
+}
+
+void TransactionMQProducer::setUnitName(std::string unitName) {
+  impl->setUnitName(unitName);
+}
+const std::string& TransactionMQProducer::getUnitName() const {
+  return impl->getUnitName();
+}
+
+std::shared_ptr<TransactionListener> TransactionMQProducer::getTransactionListener() {
+  return impl->getTransactionListener();
+}
+void TransactionMQProducer::setTransactionListener(TransactionListener* listener) {
+  impl->setTransactionListener(listener);
+}
+TransactionSendResult TransactionMQProducer::sendMessageInTransaction(MQMessage& msg, void* arg) {
+  return impl->sendMessageInTransaction(msg, arg);
+}
 void TransactionMQProducer::checkTransactionState(const std::string& addr,
                                                   const MQMessageExt& message,
                                                   long tranStateTableOffset,
@@ -137,80 +150,6 @@ void TransactionMQProducer::checkTransactionState(const std::string& addr,
                                                   const std::string& msgId,
                                                   const std::string& transactionId,
                                                   const std::string& offsetMsgId) {
-  LOG_DEBUG("checkTransactionState: msgId:%s, transactionId:%s", msgId.data(), transactionId.data());
-  if (!m_transactionListener) {
-    LOG_WARN("checkTransactionState, transactionListener null");
-    THROW_MQEXCEPTION(MQClientException, "checkTransactionState, transactionListener null", -1);
-  }
-
-  m_ioService.post(boost::bind(&TransactionMQProducer::checkTransactionStateImpl, this, addr, message,
-                               tranStateTableOffset, commitLogOffset, msgId, transactionId, offsetMsgId));
-}
-
-void TransactionMQProducer::checkTransactionStateImpl(const std::string& addr,
-                                                      const MQMessageExt& message,
-                                                      long tranStateTableOffset,
-                                                      long commitLogOffset,
-                                                      const std::string& msgId,
-                                                      const std::string& transactionId,
-                                                      const std::string& offsetMsgId) {
-  LOG_DEBUG("checkTransactionStateImpl: msgId:%s, transactionId:%s", msgId.data(), transactionId.data());
-  LocalTransactionState localTransactionState = UNKNOWN;
-  try {
-    localTransactionState = m_transactionListener->checkLocalTransaction(message);
-  } catch (MQException& e) {
-    LOG_INFO("checkTransactionState, checkLocalTransaction exception: %s", e.what());
-  }
-
-  EndTransactionRequestHeader* endHeader = new EndTransactionRequestHeader();
-  endHeader->m_commitLogOffset = commitLogOffset;
-  endHeader->m_producerGroup = getGroupName();
-  endHeader->m_tranStateTableOffset = tranStateTableOffset;
-  endHeader->m_fromTransactionCheck = true;
-
-  string uniqueKey = transactionId;
-  if (transactionId.empty()) {
-    uniqueKey = message.getMsgId();
-  }
-
-  endHeader->m_msgId = uniqueKey;
-  endHeader->m_transactionId = transactionId;
-  switch (localTransactionState) {
-    case COMMIT_MESSAGE:
-      endHeader->m_commitOrRollback = MessageSysFlag::TransactionCommitType;
-      break;
-    case ROLLBACK_MESSAGE:
-      endHeader->m_commitOrRollback = MessageSysFlag::TransactionRollbackType;
-      LOG_WARN("when broker check, client rollback this transaction, %s", endHeader->toString().data());
-      break;
-    case UNKNOWN:
-      endHeader->m_commitOrRollback = MessageSysFlag::TransactionNotType;
-      LOG_WARN("when broker check, client does not know this transaction state, %s", endHeader->toString().data());
-      break;
-    default:
-      break;
-  }
-
-  LOG_INFO("checkTransactionState, endTransactionOneway: uniqueKey:%s, client state:%d, end header: %s",
-           uniqueKey.data(), localTransactionState, endHeader->toString().data());
-
-  string remark;
-  try {
-    getFactory()->getMQClientAPIImpl()->endTransactionOneway(addr, endHeader, remark, getSessionCredentials());
-  } catch (MQException& e) {
-    LOG_ERROR("endTransactionOneway exception:%s", e.what());
-    throw e;
-  }
-}
-
-void TransactionMQProducer::start() {
-  initTransactionEnv();
-  DefaultMQProducer::start();
+  impl->checkTransactionState(addr, message, tranStateTableOffset, commitLogOffset, msgId, transactionId, offsetMsgId);
 }
-
-void TransactionMQProducer::shutdown() {
-  DefaultMQProducer::shutdown();
-  destroyTransactionEnv();
-}
-
-}  // namespace rocketmq
+}  // namespace rocketmq
\ No newline at end of file
diff --git a/src/producer/TransactionMQProducer.cpp b/src/producer/TransactionMQProducerImpl.cpp
similarity index 85%
copy from src/producer/TransactionMQProducer.cpp
copy to src/producer/TransactionMQProducerImpl.cpp
index fbd78c5..849dd55 100644
--- a/src/producer/TransactionMQProducer.cpp
+++ b/src/producer/TransactionMQProducerImpl.cpp
@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-#include "TransactionMQProducer.h"
+#include "TransactionMQProducerImpl.h"
 #include <string>
 #include "CommandHeader.h"
 #include "Logging.h"
@@ -28,18 +28,18 @@
 using namespace std;
 namespace rocketmq {
 
-void TransactionMQProducer::initTransactionEnv() {
+void TransactionMQProducerImpl::initTransactionEnv() {
   for (int i = 0; i < m_thread_num; ++i) {
     m_threadpool.create_thread(boost::bind(&boost::asio::io_service::run, &m_ioService));
   }
 }
 
-void TransactionMQProducer::destroyTransactionEnv() {
+void TransactionMQProducerImpl::destroyTransactionEnv() {
   m_ioService.stop();
   m_threadpool.join_all();
 }
 
-TransactionSendResult TransactionMQProducer::sendMessageInTransaction(MQMessage& msg, void* arg) {
+TransactionSendResult TransactionMQProducerImpl::sendMessageInTransaction(MQMessage& msg, void* arg) {
   if (!m_transactionListener) {
     THROW_MQEXCEPTION(MQClientException, "transactionListener is null", -1);
   }
@@ -98,7 +98,7 @@ TransactionSendResult TransactionMQProducer::sendMessageInTransaction(MQMessage&
   return transactionSendResult;
 }
 
-void TransactionMQProducer::endTransaction(SendResult& sendResult, LocalTransactionState& localTransactionState) {
+void TransactionMQProducerImpl::endTransaction(SendResult& sendResult, LocalTransactionState& localTransactionState) {
   MQMessageId id;
   if (sendResult.getOffsetMsgId() != "") {
     id = MQDecoder::decodeMessageId(sendResult.getOffsetMsgId());
@@ -130,30 +130,30 @@ void TransactionMQProducer::endTransaction(SendResult& sendResult, LocalTransact
   getFactory()->endTransactionOneway(sendResult.getMessageQueue(), requestHeader, getSessionCredentials());
 }
 
-void TransactionMQProducer::checkTransactionState(const std::string& addr,
-                                                  const MQMessageExt& message,
-                                                  long tranStateTableOffset,
-                                                  long commitLogOffset,
-                                                  const std::string& msgId,
-                                                  const std::string& transactionId,
-                                                  const std::string& offsetMsgId) {
+void TransactionMQProducerImpl::checkTransactionState(const std::string& addr,
+                                                      const MQMessageExt& message,
+                                                      long tranStateTableOffset,
+                                                      long commitLogOffset,
+                                                      const std::string& msgId,
+                                                      const std::string& transactionId,
+                                                      const std::string& offsetMsgId) {
   LOG_DEBUG("checkTransactionState: msgId:%s, transactionId:%s", msgId.data(), transactionId.data());
   if (!m_transactionListener) {
     LOG_WARN("checkTransactionState, transactionListener null");
     THROW_MQEXCEPTION(MQClientException, "checkTransactionState, transactionListener null", -1);
   }
 
-  m_ioService.post(boost::bind(&TransactionMQProducer::checkTransactionStateImpl, this, addr, message,
+  m_ioService.post(boost::bind(&TransactionMQProducerImpl::checkTransactionStateImpl, this, addr, message,
                                tranStateTableOffset, commitLogOffset, msgId, transactionId, offsetMsgId));
 }
 
-void TransactionMQProducer::checkTransactionStateImpl(const std::string& addr,
-                                                      const MQMessageExt& message,
-                                                      long tranStateTableOffset,
-                                                      long commitLogOffset,
-                                                      const std::string& msgId,
-                                                      const std::string& transactionId,
-                                                      const std::string& offsetMsgId) {
+void TransactionMQProducerImpl::checkTransactionStateImpl(const std::string& addr,
+                                                          const MQMessageExt& message,
+                                                          long tranStateTableOffset,
+                                                          long commitLogOffset,
+                                                          const std::string& msgId,
+                                                          const std::string& transactionId,
+                                                          const std::string& offsetMsgId) {
   LOG_DEBUG("checkTransactionStateImpl: msgId:%s, transactionId:%s", msgId.data(), transactionId.data());
   LocalTransactionState localTransactionState = UNKNOWN;
   try {
@@ -203,13 +203,13 @@ void TransactionMQProducer::checkTransactionStateImpl(const std::string& addr,
   }
 }
 
-void TransactionMQProducer::start() {
+void TransactionMQProducerImpl::start() {
   initTransactionEnv();
-  DefaultMQProducer::start();
+  DefaultMQProducerImpl::start();
 }
 
-void TransactionMQProducer::shutdown() {
-  DefaultMQProducer::shutdown();
+void TransactionMQProducerImpl::shutdown() {
+  DefaultMQProducerImpl::shutdown();
   destroyTransactionEnv();
 }
 
diff --git a/include/TransactionMQProducer.h b/src/producer/TransactionMQProducerImpl.h
similarity index 87%
copy from include/TransactionMQProducer.h
copy to src/producer/TransactionMQProducerImpl.h
index fcd9a7c..603318b 100644
--- a/include/TransactionMQProducer.h
+++ b/src/producer/TransactionMQProducerImpl.h
@@ -15,8 +15,8 @@
  * limitations under the License.
  */
 
-#ifndef __TRANSACTIONMQPRODUCER_H__
-#define __TRANSACTIONMQPRODUCER_H__
+#ifndef __TRANSACTIONMQPRODUCERIMPL_H__
+#define __TRANSACTIONMQPRODUCERIMPL_H__
 
 #include <boost/asio.hpp>
 #include <boost/asio/io_service.hpp>
@@ -25,18 +25,18 @@
 #include <boost/weak_ptr.hpp>
 #include <memory>
 #include <string>
-#include "DefaultMQProducer.h"
+#include "DefaultMQProducerImpl.h"
 #include "MQMessageExt.h"
 #include "TransactionListener.h"
 #include "TransactionSendResult.h"
 
 namespace rocketmq {
 
-class ROCKETMQCLIENT_API TransactionMQProducer : public DefaultMQProducer {
+class TransactionMQProducerImpl : public DefaultMQProducerImpl {
  public:
-  TransactionMQProducer(const std::string& producerGroup)
-      : DefaultMQProducer(producerGroup), m_thread_num(1), m_ioServiceWork(m_ioService) {}
-  virtual ~TransactionMQProducer() {}
+  TransactionMQProducerImpl(const std::string& producerGroup)
+      : DefaultMQProducerImpl(producerGroup), m_thread_num(1), m_ioServiceWork(m_ioService) {}
+  virtual ~TransactionMQProducerImpl() {}
   void start();
   void shutdown();
   std::shared_ptr<TransactionListener> getTransactionListener() { return m_transactionListener; }


Mime
View raw message