You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@rocketmq.apache.org by GitBox <gi...@apache.org> on 2022/08/03 14:48:19 UTC
[GitHub] [rocketmq-site] tsunghanjacktsai commented on a diff in pull request #172: Simple message sending
tsunghanjacktsai commented on code in PR #172:
URL: https://github.com/apache/rocketmq-site/pull/172#discussion_r936173269
##########
docs/09-英文/02-Producer/05message1.md:
##########
@@ -0,0 +1,173 @@
+# Simple Message Sending
+
+## 1.Creating Topic in Cluster
+
+RocketMQ cluster is enabled by default **autoCreateTopicEnable** configuration. It will automatically create Topic for messages, if autoCreateTopicEnable is not enabled, you can also use RocketMQ Admin tool to create the target Topic.
Review Comment:
> RocketMQ cluster is enabled by default **autoCreateTopicEnable** configuration. It will automatically create Topic for messages, if autoCreateTopicEnable is not enabled, you can also use RocketMQ Admin tool to create the target Topic.
to:
> RocketMQ cluster is enabled by default with **autoCreateTopicEnable** configuration, which will automatically create Topics for the sent messages. If autoCreateTopicEnable is not enabled, you can also use the RocketMQ Admin tool to create the target Topic.
##########
docs/09-英文/02-Producer/05message1.md:
##########
@@ -0,0 +1,173 @@
+# Simple Message Sending
+
+## 1.Creating Topic in Cluster
+
+RocketMQ cluster is enabled by default **autoCreateTopicEnable** configuration. It will automatically create Topic for messages, if autoCreateTopicEnable is not enabled, you can also use RocketMQ Admin tool to create the target Topic.
+
+```shell
+> sh bin/mqadmin updateTopic -c DefaultCluster -t TopicTest -n 127.0.0.1:9876
+create topic to 127.0.0.1:10911 success.
+TopicConfig [topicName=TopicTest, readQueueNums=8, writeQueueNums=8, perm=RW-, topicFilterType=SINGLE_TAG, topicSysFlag=0, order=false, attributes=null]
+```
+
+After the command is executed, 8 queues are created on that Broker machine, named Topic of TopicTest.
Review Comment:
> After the command is executed, 8 queues are created on that Broker machine, named Topic of TopicTest.
to:
> After executing the command above, 8 queues are created on the Broker machine with the Topic named TopicTest.
##########
docs/09-英文/02-Producer/05message1.md:
##########
@@ -0,0 +1,173 @@
+# Simple Message Sending
+
+## 1.Creating Topic in Cluster
+
+RocketMQ cluster is enabled by default **autoCreateTopicEnable** configuration. It will automatically create Topic for messages, if autoCreateTopicEnable is not enabled, you can also use RocketMQ Admin tool to create the target Topic.
+
+```shell
+> sh bin/mqadmin updateTopic -c DefaultCluster -t TopicTest -n 127.0.0.1:9876
+create topic to 127.0.0.1:10911 success.
+TopicConfig [topicName=TopicTest, readQueueNums=8, writeQueueNums=8, perm=RW-, topicFilterType=SINGLE_TAG, topicSysFlag=0, order=false, attributes=null]
+```
+
+After the command is executed, 8 queues are created on that Broker machine, named Topic of TopicTest.
+
+## 2.Adding Client-Side Dependency
+
+Firstly, add RocketMQ client-side dependency to JAVA application.
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+<Tabs>
+<TabItem value="Maven" label="Maven" default >
+
+```java
+<dependency>
+ <groupId>org.apache.rocketmq</groupId>
+ <artifactId>rocketmq-client</artifactId>
+ <version>4.9.4</version>
+</dependency>
+```
+</TabItem>
+<TabItem value="Gradle" label="Gradle">
+
+```java
+compile 'org.apache.rocketmq:rocketmq-client:4.9.4'
+```
+
+</TabItem>
+
+</Tabs>
+
+
+## 3.Message Sending
+
+Apache RocketMQ send messages in three ways: **synchronous, asynchronous, and one-way transmission**. The first two message types are reliable because they have responses regardless of whether they are successfully sent or not.
Review Comment:
> Apache RocketMQ send messages in three ways: **synchronous, asynchronous, and one-way transmission**. The first two message types are reliable because they have responses regardless of whether they are successfully sent or not.
to:
> Apache RocketMQ sends messages in three ways: **synchronous, asynchronous, and one-way**. The first two message types are reliable since the response will be returned from the server regardless of whether their messages are successfully sent or not.
##########
docs/09-英文/02-Producer/05message1.md:
##########
@@ -0,0 +1,173 @@
+# Simple Message Sending
+
+## 1.Creating Topic in Cluster
+
+RocketMQ cluster is enabled by default **autoCreateTopicEnable** configuration. It will automatically create Topic for messages, if autoCreateTopicEnable is not enabled, you can also use RocketMQ Admin tool to create the target Topic.
+
+```shell
+> sh bin/mqadmin updateTopic -c DefaultCluster -t TopicTest -n 127.0.0.1:9876
+create topic to 127.0.0.1:10911 success.
+TopicConfig [topicName=TopicTest, readQueueNums=8, writeQueueNums=8, perm=RW-, topicFilterType=SINGLE_TAG, topicSysFlag=0, order=false, attributes=null]
+```
+
+After the command is executed, 8 queues are created on that Broker machine, named Topic of TopicTest.
+
+## 2.Adding Client-Side Dependency
+
+Firstly, add RocketMQ client-side dependency to JAVA application.
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+<Tabs>
+<TabItem value="Maven" label="Maven" default >
+
+```java
+<dependency>
+ <groupId>org.apache.rocketmq</groupId>
+ <artifactId>rocketmq-client</artifactId>
+ <version>4.9.4</version>
+</dependency>
+```
+</TabItem>
+<TabItem value="Gradle" label="Gradle">
+
+```java
+compile 'org.apache.rocketmq:rocketmq-client:4.9.4'
+```
+
+</TabItem>
+
+</Tabs>
+
+
+## 3.Message Sending
+
+Apache RocketMQ send messages in three ways: **synchronous, asynchronous, and one-way transmission**. The first two message types are reliable because they have responses regardless of whether they are successfully sent or not.
+
+### 3.1 Synchronous Sending
+
+Synchronous Sending is a communication method in which the message sender sends a message and will send the next message only after receiving a synchronous response from the server. Reliable synchronous transmission is widely used in various scenarios, such as important notification messages, short message notifications, etc.
+
+
+
+
+The entire code for synchronous sending is as follows:
+1. **Firstly a producer will be created**. Simple Messages create DefaultMQProducer. While creating producer, fill in the name of the production group which is the collection of the same class of Producer, such Producer sends same class of messages with same transmission logic.
+2. **Set the address of NameServer**. Apache Rocket has MQ many ways to set the address of the NameServer (described in the client configuration), this example is set by calling the producer's setNamesrvAddr() method in the code, if there are more than one NameServer, separated by a semicolon, such as "127.0.0.2:9876;127.0.0.3:9876".
+3. **The third step is to build the message**. Set the topic, tag, body and so on. The tag can be understood as a label to categorize the message, and RocketMQ can filter the tag on the consumer side.
Review Comment:
> 3. **The third step is to build the message**. Set the topic, tag, body and so on. The tag can be understood as a label to categorize the message, and RocketMQ can filter the tag on the consumer side.
to:
> 3. **Build the message**. Set the topic, tag, body, and so on. The tag can be understood as a label to categorize the message, and RocketMQ can filter the tag on the Consumer side.
##########
docs/09-英文/02-Producer/05message1.md:
##########
@@ -0,0 +1,173 @@
+# Simple Message Sending
+
+## 1.Creating Topic in Cluster
+
+RocketMQ cluster is enabled by default **autoCreateTopicEnable** configuration. It will automatically create Topic for messages, if autoCreateTopicEnable is not enabled, you can also use RocketMQ Admin tool to create the target Topic.
+
+```shell
+> sh bin/mqadmin updateTopic -c DefaultCluster -t TopicTest -n 127.0.0.1:9876
+create topic to 127.0.0.1:10911 success.
+TopicConfig [topicName=TopicTest, readQueueNums=8, writeQueueNums=8, perm=RW-, topicFilterType=SINGLE_TAG, topicSysFlag=0, order=false, attributes=null]
+```
+
+After the command is executed, 8 queues are created on that Broker machine, named Topic of TopicTest.
+
+## 2.Adding Client-Side Dependency
+
+Firstly, add RocketMQ client-side dependency to JAVA application.
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+<Tabs>
+<TabItem value="Maven" label="Maven" default >
+
+```java
+<dependency>
+ <groupId>org.apache.rocketmq</groupId>
+ <artifactId>rocketmq-client</artifactId>
+ <version>4.9.4</version>
+</dependency>
+```
+</TabItem>
+<TabItem value="Gradle" label="Gradle">
+
+```java
+compile 'org.apache.rocketmq:rocketmq-client:4.9.4'
+```
+
+</TabItem>
+
+</Tabs>
+
+
+## 3.Message Sending
+
+Apache RocketMQ send messages in three ways: **synchronous, asynchronous, and one-way transmission**. The first two message types are reliable because they have responses regardless of whether they are successfully sent or not.
+
+### 3.1 Synchronous Sending
+
+Synchronous Sending is a communication method in which the message sender sends a message and will send the next message only after receiving a synchronous response from the server. Reliable synchronous transmission is widely used in various scenarios, such as important notification messages, short message notifications, etc.
+
+
+
+
+The entire code for synchronous sending is as follows:
+1. **Firstly a producer will be created**. Simple Messages create DefaultMQProducer. While creating producer, fill in the name of the production group which is the collection of the same class of Producer, such Producer sends same class of messages with same transmission logic.
+2. **Set the address of NameServer**. Apache Rocket has MQ many ways to set the address of the NameServer (described in the client configuration), this example is set by calling the producer's setNamesrvAddr() method in the code, if there are more than one NameServer, separated by a semicolon, such as "127.0.0.2:9876;127.0.0.3:9876".
+3. **The third step is to build the message**. Set the topic, tag, body and so on. The tag can be understood as a label to categorize the message, and RocketMQ can filter the tag on the consumer side.
+4. **Finally call the send() method to send the message out**. Ultimately, the send() method return a SendResult. The SendResut contains the actual send status including SEND_OK (send success), FLUSH_DISK_TIMEOUT (disk flush timeout), FLUSH_SLAVE_TIMEOUT (sync to slave timeout), SLAVE_NOT_AVAILABLE (slave can not be used), and an exception is thrown if send fails.
+``` javascript {16,15}
+public class SyncProducer {
+ public static void main(String[] args) throws Exception {
+ // Initialize a producer and set the Producer group name
+ DefaultMQProducer producer = new DefaultMQProducer("please_rename_unique_group_name"); //（1）
+ // Set the address of NameServer
+ producer.setNamesrvAddr("localhost:9876"); //（2）
+ // Start Producer
+ producer.start();
+ for (int i = 0; i < 100; i++) {
+ // Create a message and set the topic, tag, body and so on. The tag can be understood as a label to categorize the message, and RocketMQ can filter the tag on the consumer side.
+ Message msg = new Message("TopicTest" /* Topic */,
+ "TagA" /* Tag */,
+ ("Hello RocketMQ " + i).getBytes(RemotingHelper.DEFAULT_CHARSET) /* Message body */
+ ); //（3）
+ // Use the producer to send and wait for the result of sending synchronously
+ SendResult sendResult = producer.send(msg); //（4）
+ System.out.printf("%s%n", sendResult);
+ }
+ // Close the producer once it is no longer in use
+ producer.shutdown();
+ }
+}
+```
+
+
+
+### 3.2 Asynchronous Sending
+
+
+
+
+Asynchronous sending is a communication method in which the sender sends a message and then sends the next message without waiting for the server to return a response.
+Asynchronous sending requires the implementation of the **Asynchronous Send Callback Interface** (SendCallback).
+:::note
+Asynchronous sending requires the implementation of the **Asynchronous SendCallback Interface**.
+:::
+After sending a message, the sender does not need to wait for a response from the server to send the next message. The sender receives the response from the server through the callback interface and handles the result. Asynchronous sending is generally used in time-consuming and response time sensitive business scenarios. For example, the video upload notifies the start of transcoding service, and notifies the push of transcoding result after transcoding is completed.
+
+The following is the sample code.
+
+``` javascript {16,17}
+public class AsyncProducer {
+ public static void main(String[] args) throws Exception {
+ // Initialize a producer and set the Producer group name
+ DefaultMQProducer producer = new DefaultMQProducer("please_rename_unique_group_name");
+ // Set the address of NameServer
+ producer.setNamesrvAddr("localhost:9876");
+ // Start Producer
+ producer.start();
+ producer.setRetryTimesWhenSendAsyncFailed(0);
+ for (int i = 0; i < 100; i++) {
+ final int index = i;
+ // Create a message and set the topic, tag, body and so on. The tag can be understood as a label to categorize the message, and RocketMQ can filter the tag on the consumer side.
+ Message msg = new Message("TopicTest",
+ "TagA",
+ "Hello world".getBytes(RemotingHelper.DEFAULT_CHARSET));
+ // Send a message asynchronously, the result is returned to the client by callback
+ producer.send(msg, new SendCallback() {
+ @Override
+ public void onSuccess(SendResult sendResult) {
+ System.out.printf("%-10d OK %s %n", index,
+ sendResult.getMsgId());
+ }
+ @Override
+ public void onException(Throwable e) {
+ System.out.printf("%-10d Exception %s %n", index, e);
+ e.printStackTrace();
+ }
+ });
+ }
+ // Close the producer once it is no longer in use
+ producer.shutdown();
+ }
+}
+```
+
+:::note
+The only difference between asynchronous and synchronous sending code is the parameters for calling the sending interface. Asynchronous sending does not wait for the return of the send, instead, the send method needs to be passed into the SendCallback implementation. The SendCallback interface mainly has onSuccess and onException two methods, indicating that the message is sent successfully or failed.
+:::
+
+### 3.3 One Way Sending
Review Comment:
Should be: One-Way Sending
##########
docs/09-英文/02-Producer/05message1.md:
##########
@@ -0,0 +1,173 @@
+# Simple Message Sending
+
+## 1.Creating Topic in Cluster
+
+RocketMQ cluster is enabled by default **autoCreateTopicEnable** configuration. It will automatically create Topic for messages, if autoCreateTopicEnable is not enabled, you can also use RocketMQ Admin tool to create the target Topic.
+
+```shell
+> sh bin/mqadmin updateTopic -c DefaultCluster -t TopicTest -n 127.0.0.1:9876
+create topic to 127.0.0.1:10911 success.
+TopicConfig [topicName=TopicTest, readQueueNums=8, writeQueueNums=8, perm=RW-, topicFilterType=SINGLE_TAG, topicSysFlag=0, order=false, attributes=null]
+```
+
+After the command is executed, 8 queues are created on that Broker machine, named Topic of TopicTest.
+
+## 2.Adding Client-Side Dependency
+
+Firstly, add RocketMQ client-side dependency to JAVA application.
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+<Tabs>
+<TabItem value="Maven" label="Maven" default >
+
+```java
+<dependency>
+ <groupId>org.apache.rocketmq</groupId>
+ <artifactId>rocketmq-client</artifactId>
+ <version>4.9.4</version>
+</dependency>
+```
+</TabItem>
+<TabItem value="Gradle" label="Gradle">
+
+```java
+compile 'org.apache.rocketmq:rocketmq-client:4.9.4'
+```
+
+</TabItem>
+
+</Tabs>
+
+
+## 3.Message Sending
+
+Apache RocketMQ send messages in three ways: **synchronous, asynchronous, and one-way transmission**. The first two message types are reliable because they have responses regardless of whether they are successfully sent or not.
+
+### 3.1 Synchronous Sending
+
+Synchronous Sending is a communication method in which the message sender sends a message and will send the next message only after receiving a synchronous response from the server. Reliable synchronous transmission is widely used in various scenarios, such as important notification messages, short message notifications, etc.
+
+
+
+
+The entire code for synchronous sending is as follows:
+1. **Firstly a producer will be created**. Simple Messages create DefaultMQProducer. While creating producer, fill in the name of the production group which is the collection of the same class of Producer, such Producer sends same class of messages with same transmission logic.
+2. **Set the address of NameServer**. Apache Rocket has MQ many ways to set the address of the NameServer (described in the client configuration), this example is set by calling the producer's setNamesrvAddr() method in the code, if there are more than one NameServer, separated by a semicolon, such as "127.0.0.2:9876;127.0.0.3:9876".
+3. **The third step is to build the message**. Set the topic, tag, body and so on. The tag can be understood as a label to categorize the message, and RocketMQ can filter the tag on the consumer side.
+4. **Finally call the send() method to send the message out**. Ultimately, the send() method return a SendResult. The SendResut contains the actual send status including SEND_OK (send success), FLUSH_DISK_TIMEOUT (disk flush timeout), FLUSH_SLAVE_TIMEOUT (sync to slave timeout), SLAVE_NOT_AVAILABLE (slave can not be used), and an exception is thrown if send fails.
+``` javascript {16,15}
+public class SyncProducer {
+ public static void main(String[] args) throws Exception {
+ // Initialize a producer and set the Producer group name
+ DefaultMQProducer producer = new DefaultMQProducer("please_rename_unique_group_name"); //（1）
+ // Set the address of NameServer
+ producer.setNamesrvAddr("localhost:9876"); //（2）
+ // Start Producer
+ producer.start();
+ for (int i = 0; i < 100; i++) {
+ // Create a message and set the topic, tag, body and so on. The tag can be understood as a label to categorize the message, and RocketMQ can filter the tag on the consumer side.
+ Message msg = new Message("TopicTest" /* Topic */,
+ "TagA" /* Tag */,
+ ("Hello RocketMQ " + i).getBytes(RemotingHelper.DEFAULT_CHARSET) /* Message body */
+ ); //（3）
+ // Use the producer to send and wait for the result of sending synchronously
+ SendResult sendResult = producer.send(msg); //（4）
+ System.out.printf("%s%n", sendResult);
+ }
+ // Close the producer once it is no longer in use
+ producer.shutdown();
+ }
+}
+```
+
+
+
+### 3.2 Asynchronous Sending
+
+
+
+
+Asynchronous sending is a communication method in which the sender sends a message and then sends the next message without waiting for the server to return a response.
+Asynchronous sending requires the implementation of the **Asynchronous Send Callback Interface** (SendCallback).
+:::note
+Asynchronous sending requires the implementation of the **Asynchronous SendCallback Interface**.
+:::
+After sending a message, the sender does not need to wait for a response from the server to send the next message. The sender receives the response from the server through the callback interface and handles the result. Asynchronous sending is generally used in time-consuming and response time sensitive business scenarios. For example, the video upload notifies the start of transcoding service, and notifies the push of transcoding result after transcoding is completed.
+
+The following is the sample code.
+
+``` javascript {16,17}
+public class AsyncProducer {
+ public static void main(String[] args) throws Exception {
+ // Initialize a producer and set the Producer group name
+ DefaultMQProducer producer = new DefaultMQProducer("please_rename_unique_group_name");
+ // Set the address of NameServer
+ producer.setNamesrvAddr("localhost:9876");
+ // Start Producer
+ producer.start();
+ producer.setRetryTimesWhenSendAsyncFailed(0);
+ for (int i = 0; i < 100; i++) {
+ final int index = i;
+ // Create a message and set the topic, tag, body and so on. The tag can be understood as a label to categorize the message, and RocketMQ can filter the tag on the consumer side.
+ Message msg = new Message("TopicTest",
+ "TagA",
+ "Hello world".getBytes(RemotingHelper.DEFAULT_CHARSET));
+ // Send a message asynchronously, the result is returned to the client by callback
+ producer.send(msg, new SendCallback() {
+ @Override
+ public void onSuccess(SendResult sendResult) {
+ System.out.printf("%-10d OK %s %n", index,
+ sendResult.getMsgId());
+ }
+ @Override
+ public void onException(Throwable e) {
+ System.out.printf("%-10d Exception %s %n", index, e);
+ e.printStackTrace();
+ }
+ });
+ }
+ // Close the producer once it is no longer in use
+ producer.shutdown();
+ }
+}
+```
+
+:::note
+The only difference between asynchronous and synchronous sending code is the parameters for calling the sending interface. Asynchronous sending does not wait for the return of the send, instead, the send method needs to be passed into the SendCallback implementation. The SendCallback interface mainly has onSuccess and onException two methods, indicating that the message is sent successfully or failed.
+:::
+
+### 3.3 One Way Sending
+
+
+
+
+
+The sender is only responsible for sending the message and does not wait for the server to return a response and no callback function is triggered, in other word, it only sends the request and does not wait for the answer. The process of sending messages in this way is very short, usually in the microsecond level. It is suitable for some scenarios where the time consumption is very short, but the reliability requirement is not high, such as log collection.
Review Comment:
in other word -> in other words
##########
docs/09-英文/02-Producer/05message1.md:
##########
@@ -0,0 +1,173 @@
+# Simple Message Sending
+
+## 1.Creating Topic in Cluster
+
+RocketMQ cluster is enabled by default **autoCreateTopicEnable** configuration. It will automatically create Topic for messages, if autoCreateTopicEnable is not enabled, you can also use RocketMQ Admin tool to create the target Topic.
+
+```shell
+> sh bin/mqadmin updateTopic -c DefaultCluster -t TopicTest -n 127.0.0.1:9876
+create topic to 127.0.0.1:10911 success.
+TopicConfig [topicName=TopicTest, readQueueNums=8, writeQueueNums=8, perm=RW-, topicFilterType=SINGLE_TAG, topicSysFlag=0, order=false, attributes=null]
+```
+
+After the command is executed, 8 queues are created on that Broker machine, named Topic of TopicTest.
+
+## 2.Adding Client-Side Dependency
+
+Firstly, add RocketMQ client-side dependency to JAVA application.
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+<Tabs>
+<TabItem value="Maven" label="Maven" default >
+
+```java
+<dependency>
+ <groupId>org.apache.rocketmq</groupId>
+ <artifactId>rocketmq-client</artifactId>
+ <version>4.9.4</version>
+</dependency>
+```
+</TabItem>
+<TabItem value="Gradle" label="Gradle">
+
+```java
+compile 'org.apache.rocketmq:rocketmq-client:4.9.4'
+```
+
+</TabItem>
+
+</Tabs>
+
+
+## 3.Message Sending
+
+Apache RocketMQ send messages in three ways: **synchronous, asynchronous, and one-way transmission**. The first two message types are reliable because they have responses regardless of whether they are successfully sent or not.
+
+### 3.1 Synchronous Sending
+
+Synchronous Sending is a communication method in which the message sender sends a message and will send the next message only after receiving a synchronous response from the server. Reliable synchronous transmission is widely used in various scenarios, such as important notification messages, short message notifications, etc.
+
+
+
+
+The entire code for synchronous sending is as follows:
+1. **Firstly a producer will be created**. Simple Messages create DefaultMQProducer. While creating producer, fill in the name of the production group which is the collection of the same class of Producer, such Producer sends same class of messages with same transmission logic.
Review Comment:
> 1. **Firstly a producer will be created**. Simple Messages create DefaultMQProducer. While creating producer, fill in the name of the production group which is the collection of the same class of Producer, such Producer sends same class of messages with same transmission logic.
to:
> 1. **Create a Producer**. Create a DefaultMQProducer in advance. The Producer should contain the name of the Producer group, which is a collection of Producer, they would send the same type of messages with identical logic.
##########
docs/09-英文/02-Producer/05message1.md:
##########
@@ -0,0 +1,173 @@
+# Simple Message Sending
+
+## 1.Creating Topic in Cluster
+
+RocketMQ cluster is enabled by default **autoCreateTopicEnable** configuration. It will automatically create Topic for messages, if autoCreateTopicEnable is not enabled, you can also use RocketMQ Admin tool to create the target Topic.
+
+```shell
+> sh bin/mqadmin updateTopic -c DefaultCluster -t TopicTest -n 127.0.0.1:9876
+create topic to 127.0.0.1:10911 success.
+TopicConfig [topicName=TopicTest, readQueueNums=8, writeQueueNums=8, perm=RW-, topicFilterType=SINGLE_TAG, topicSysFlag=0, order=false, attributes=null]
+```
+
+After the command is executed, 8 queues are created on that Broker machine, named Topic of TopicTest.
+
+## 2.Adding Client-Side Dependency
+
+Firstly, add RocketMQ client-side dependency to JAVA application.
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+<Tabs>
+<TabItem value="Maven" label="Maven" default >
+
+```java
+<dependency>
+ <groupId>org.apache.rocketmq</groupId>
+ <artifactId>rocketmq-client</artifactId>
+ <version>4.9.4</version>
+</dependency>
+```
+</TabItem>
+<TabItem value="Gradle" label="Gradle">
+
+```java
+compile 'org.apache.rocketmq:rocketmq-client:4.9.4'
+```
+
+</TabItem>
+
+</Tabs>
+
+
+## 3.Message Sending
+
+Apache RocketMQ send messages in three ways: **synchronous, asynchronous, and one-way transmission**. The first two message types are reliable because they have responses regardless of whether they are successfully sent or not.
+
+### 3.1 Synchronous Sending
+
+Synchronous Sending is a communication method in which the message sender sends a message and will send the next message only after receiving a synchronous response from the server. Reliable synchronous transmission is widely used in various scenarios, such as important notification messages, short message notifications, etc.
+
+
+
+
+The entire code for synchronous sending is as follows:
+1. **Firstly a producer will be created**. Simple Messages create DefaultMQProducer. While creating producer, fill in the name of the production group which is the collection of the same class of Producer, such Producer sends same class of messages with same transmission logic.
+2. **Set the address of NameServer**. Apache Rocket has MQ many ways to set the address of the NameServer (described in the client configuration), this example is set by calling the producer's setNamesrvAddr() method in the code, if there are more than one NameServer, separated by a semicolon, such as "127.0.0.2:9876;127.0.0.3:9876".
+3. **The third step is to build the message**. Set the topic, tag, body and so on. The tag can be understood as a label to categorize the message, and RocketMQ can filter the tag on the consumer side.
+4. **Finally call the send() method to send the message out**. Ultimately, the send() method return a SendResult. The SendResut contains the actual send status including SEND_OK (send success), FLUSH_DISK_TIMEOUT (disk flush timeout), FLUSH_SLAVE_TIMEOUT (sync to slave timeout), SLAVE_NOT_AVAILABLE (slave can not be used), and an exception is thrown if send fails.
+``` javascript {16,15}
+public class SyncProducer {
+ public static void main(String[] args) throws Exception {
+ // Initialize a producer and set the Producer group name
+ DefaultMQProducer producer = new DefaultMQProducer("please_rename_unique_group_name"); //（1）
+ // Set the address of NameServer
+ producer.setNamesrvAddr("localhost:9876"); //（2）
+ // Start Producer
+ producer.start();
+ for (int i = 0; i < 100; i++) {
+ // Create a message and set the topic, tag, body and so on. The tag can be understood as a label to categorize the message, and RocketMQ can filter the tag on the consumer side.
+ Message msg = new Message("TopicTest" /* Topic */,
+ "TagA" /* Tag */,
+ ("Hello RocketMQ " + i).getBytes(RemotingHelper.DEFAULT_CHARSET) /* Message body */
+ ); //（3）
+ // Use the producer to send and wait for the result of sending synchronously
+ SendResult sendResult = producer.send(msg); //（4）
+ System.out.printf("%s%n", sendResult);
+ }
+ // Close the producer once it is no longer in use
+ producer.shutdown();
+ }
+}
+```
+
+
+
+### 3.2 Asynchronous Sending
+
+
Review Comment:
The figure name should be: 异步发送
##########
docs/09-英文/02-Producer/05message1.md:
##########
@@ -0,0 +1,173 @@
+# Simple Message Sending
+
+## 1.Creating Topic in Cluster
+
+RocketMQ cluster is enabled by default **autoCreateTopicEnable** configuration. It will automatically create Topic for messages, if autoCreateTopicEnable is not enabled, you can also use RocketMQ Admin tool to create the target Topic.
+
+```shell
+> sh bin/mqadmin updateTopic -c DefaultCluster -t TopicTest -n 127.0.0.1:9876
+create topic to 127.0.0.1:10911 success.
+TopicConfig [topicName=TopicTest, readQueueNums=8, writeQueueNums=8, perm=RW-, topicFilterType=SINGLE_TAG, topicSysFlag=0, order=false, attributes=null]
+```
+
+After the command is executed, 8 queues are created on that Broker machine, named Topic of TopicTest.
+
+## 2.Adding Client-Side Dependency
+
+Firstly, add RocketMQ client-side dependency to JAVA application.
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+<Tabs>
+<TabItem value="Maven" label="Maven" default >
+
+```java
+<dependency>
+ <groupId>org.apache.rocketmq</groupId>
+ <artifactId>rocketmq-client</artifactId>
+ <version>4.9.4</version>
+</dependency>
+```
+</TabItem>
+<TabItem value="Gradle" label="Gradle">
+
+```java
+compile 'org.apache.rocketmq:rocketmq-client:4.9.4'
+```
+
+</TabItem>
+
+</Tabs>
+
+
+## 3.Message Sending
+
+Apache RocketMQ send messages in three ways: **synchronous, asynchronous, and one-way transmission**. The first two message types are reliable because they have responses regardless of whether they are successfully sent or not.
+
+### 3.1 Synchronous Sending
+
+Synchronous Sending is a communication method in which the message sender sends a message and will send the next message only after receiving a synchronous response from the server. Reliable synchronous transmission is widely used in various scenarios, such as important notification messages, short message notifications, etc.
+
+
+
+
+The entire code for synchronous sending is as follows:
+1. **Firstly a producer will be created**. Simple Messages create DefaultMQProducer. While creating producer, fill in the name of the production group which is the collection of the same class of Producer, such Producer sends same class of messages with same transmission logic.
+2. **Set the address of NameServer**. Apache Rocket has MQ many ways to set the address of the NameServer (described in the client configuration), this example is set by calling the producer's setNamesrvAddr() method in the code, if there are more than one NameServer, separated by a semicolon, such as "127.0.0.2:9876;127.0.0.3:9876".
+3. **The third step is to build the message**. Set the topic, tag, body and so on. The tag can be understood as a label to categorize the message, and RocketMQ can filter the tag on the consumer side.
+4. **Finally call the send() method to send the message out**. Ultimately, the send() method return a SendResult. The SendResut contains the actual send status including SEND_OK (send success), FLUSH_DISK_TIMEOUT (disk flush timeout), FLUSH_SLAVE_TIMEOUT (sync to slave timeout), SLAVE_NOT_AVAILABLE (slave can not be used), and an exception is thrown if send fails.
Review Comment:
> 4. **Finally call the send() method to send the message out**. Ultimately, the send() method return a SendResult. The SendResut contains the actual send status including SEND_OK (send success), FLUSH_DISK_TIMEOUT (disk flush timeout), FLUSH_SLAVE_TIMEOUT (sync to slave timeout), SLAVE_NOT_AVAILABLE (slave can not be used), and an exception is thrown if send fails.
to:
> 4. **Call the send() method to send the message**. Ultimately, the send() method will return a SendResult. The SendResut contains the actual send status including SEND_OK (send success), FLUSH_DISK_TIMEOUT (disk flush timeout), FLUSH_SLAVE_TIMEOUT (sync to slave timeout), SLAVE_NOT_AVAILABLE (slave can not be used), and an exception is thrown if it fails.
##########
docs/09-英文/02-Producer/05message1.md:
##########
@@ -0,0 +1,173 @@
+# Simple Message Sending
+
+## 1.Creating Topic in Cluster
+
+RocketMQ cluster is enabled by default **autoCreateTopicEnable** configuration. It will automatically create Topic for messages, if autoCreateTopicEnable is not enabled, you can also use RocketMQ Admin tool to create the target Topic.
+
+```shell
+> sh bin/mqadmin updateTopic -c DefaultCluster -t TopicTest -n 127.0.0.1:9876
+create topic to 127.0.0.1:10911 success.
+TopicConfig [topicName=TopicTest, readQueueNums=8, writeQueueNums=8, perm=RW-, topicFilterType=SINGLE_TAG, topicSysFlag=0, order=false, attributes=null]
+```
+
+After the command is executed, 8 queues are created on that Broker machine, named Topic of TopicTest.
+
+## 2.Adding Client-Side Dependency
+
+Firstly, add RocketMQ client-side dependency to JAVA application.
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+<Tabs>
+<TabItem value="Maven" label="Maven" default >
+
+```java
+<dependency>
+ <groupId>org.apache.rocketmq</groupId>
+ <artifactId>rocketmq-client</artifactId>
+ <version>4.9.4</version>
+</dependency>
+```
+</TabItem>
+<TabItem value="Gradle" label="Gradle">
+
+```java
+compile 'org.apache.rocketmq:rocketmq-client:4.9.4'
+```
+
+</TabItem>
+
+</Tabs>
+
+
+## 3.Message Sending
+
+Apache RocketMQ send messages in three ways: **synchronous, asynchronous, and one-way transmission**. The first two message types are reliable because they have responses regardless of whether they are successfully sent or not.
+
+### 3.1 Synchronous Sending
+
+Synchronous Sending is a communication method in which the message sender sends a message and will send the next message only after receiving a synchronous response from the server. Reliable synchronous transmission is widely used in various scenarios, such as important notification messages, short message notifications, etc.
+
+
+
+
+The entire code for synchronous sending is as follows:
+1. **Firstly a producer will be created**. Simple Messages create DefaultMQProducer. While creating producer, fill in the name of the production group which is the collection of the same class of Producer, such Producer sends same class of messages with same transmission logic.
+2. **Set the address of NameServer**. Apache Rocket has MQ many ways to set the address of the NameServer (described in the client configuration), this example is set by calling the producer's setNamesrvAddr() method in the code, if there are more than one NameServer, separated by a semicolon, such as "127.0.0.2:9876;127.0.0.3:9876".
+3. **The third step is to build the message**. Set the topic, tag, body and so on. The tag can be understood as a label to categorize the message, and RocketMQ can filter the tag on the consumer side.
+4. **Finally call the send() method to send the message out**. Ultimately, the send() method return a SendResult. The SendResut contains the actual send status including SEND_OK (send success), FLUSH_DISK_TIMEOUT (disk flush timeout), FLUSH_SLAVE_TIMEOUT (sync to slave timeout), SLAVE_NOT_AVAILABLE (slave can not be used), and an exception is thrown if send fails.
+``` javascript {16,15}
+public class SyncProducer {
+ public static void main(String[] args) throws Exception {
+ // Initialize a producer and set the Producer group name
+ DefaultMQProducer producer = new DefaultMQProducer("please_rename_unique_group_name"); //（1）
+ // Set the address of NameServer
+ producer.setNamesrvAddr("localhost:9876"); //（2）
+ // Start Producer
+ producer.start();
+ for (int i = 0; i < 100; i++) {
+ // Create a message and set the topic, tag, body and so on. The tag can be understood as a label to categorize the message, and RocketMQ can filter the tag on the consumer side.
+ Message msg = new Message("TopicTest" /* Topic */,
+ "TagA" /* Tag */,
+ ("Hello RocketMQ " + i).getBytes(RemotingHelper.DEFAULT_CHARSET) /* Message body */
+ ); //（3）
+ // Use the producer to send and wait for the result of sending synchronously
+ SendResult sendResult = producer.send(msg); //（4）
+ System.out.printf("%s%n", sendResult);
+ }
+ // Close the producer once it is no longer in use
+ producer.shutdown();
+ }
+}
+```
+
+
+
+### 3.2 Asynchronous Sending
+
+
+
+
+Asynchronous sending is a communication method in which the sender sends a message and then sends the next message without waiting for the server to return a response.
Review Comment:
> Asynchronous sending is a communication method in which the sender sends a message and then sends the next message without waiting for the server to return a response.
to:
> Asynchronous sending is a sending method in which the sender sends messages continuously without waiting for the server to return a response.
##########
docs/09-英文/02-Producer/05message1.md:
##########
@@ -0,0 +1,173 @@
+# Simple Message Sending
+
+## 1.Creating Topic in Cluster
+
+RocketMQ cluster is enabled by default **autoCreateTopicEnable** configuration. It will automatically create Topic for messages, if autoCreateTopicEnable is not enabled, you can also use RocketMQ Admin tool to create the target Topic.
+
+```shell
+> sh bin/mqadmin updateTopic -c DefaultCluster -t TopicTest -n 127.0.0.1:9876
+create topic to 127.0.0.1:10911 success.
+TopicConfig [topicName=TopicTest, readQueueNums=8, writeQueueNums=8, perm=RW-, topicFilterType=SINGLE_TAG, topicSysFlag=0, order=false, attributes=null]
+```
+
+After the command is executed, 8 queues are created on that Broker machine, named Topic of TopicTest.
+
+## 2.Adding Client-Side Dependency
+
+Firstly, add RocketMQ client-side dependency to JAVA application.
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+<Tabs>
+<TabItem value="Maven" label="Maven" default >
+
+```java
+<dependency>
+ <groupId>org.apache.rocketmq</groupId>
+ <artifactId>rocketmq-client</artifactId>
+ <version>4.9.4</version>
+</dependency>
+```
+</TabItem>
+<TabItem value="Gradle" label="Gradle">
+
+```java
+compile 'org.apache.rocketmq:rocketmq-client:4.9.4'
+```
+
+</TabItem>
+
+</Tabs>
+
+
+## 3.Message Sending
+
+Apache RocketMQ send messages in three ways: **synchronous, asynchronous, and one-way transmission**. The first two message types are reliable because they have responses regardless of whether they are successfully sent or not.
+
+### 3.1 Synchronous Sending
+
+Synchronous Sending is a communication method in which the message sender sends a message and will send the next message only after receiving a synchronous response from the server. Reliable synchronous transmission is widely used in various scenarios, such as important notification messages, short message notifications, etc.
+
+
+
+
+The entire code for synchronous sending is as follows:
+1. **Firstly a producer will be created**. Simple Messages create DefaultMQProducer. While creating producer, fill in the name of the production group which is the collection of the same class of Producer, such Producer sends same class of messages with same transmission logic.
+2. **Set the address of NameServer**. Apache Rocket has MQ many ways to set the address of the NameServer (described in the client configuration), this example is set by calling the producer's setNamesrvAddr() method in the code, if there are more than one NameServer, separated by a semicolon, such as "127.0.0.2:9876;127.0.0.3:9876".
+3. **The third step is to build the message**. Set the topic, tag, body and so on. The tag can be understood as a label to categorize the message, and RocketMQ can filter the tag on the consumer side.
+4. **Finally call the send() method to send the message out**. Ultimately, the send() method return a SendResult. The SendResut contains the actual send status including SEND_OK (send success), FLUSH_DISK_TIMEOUT (disk flush timeout), FLUSH_SLAVE_TIMEOUT (sync to slave timeout), SLAVE_NOT_AVAILABLE (slave can not be used), and an exception is thrown if send fails.
+``` javascript {16,15}
+public class SyncProducer {
+ public static void main(String[] args) throws Exception {
+ // Initialize a producer and set the Producer group name
+ DefaultMQProducer producer = new DefaultMQProducer("please_rename_unique_group_name"); //（1）
+ // Set the address of NameServer
+ producer.setNamesrvAddr("localhost:9876"); //（2）
+ // Start Producer
+ producer.start();
+ for (int i = 0; i < 100; i++) {
+ // Create a message and set the topic, tag, body and so on. The tag can be understood as a label to categorize the message, and RocketMQ can filter the tag on the consumer side.
+ Message msg = new Message("TopicTest" /* Topic */,
+ "TagA" /* Tag */,
+ ("Hello RocketMQ " + i).getBytes(RemotingHelper.DEFAULT_CHARSET) /* Message body */
+ ); //（3）
+ // Use the producer to send and wait for the result of sending synchronously
+ SendResult sendResult = producer.send(msg); //（4）
+ System.out.printf("%s%n", sendResult);
+ }
+ // Close the producer once it is no longer in use
+ producer.shutdown();
+ }
+}
+```
+
+
+
+### 3.2 Asynchronous Sending
+
+
+
+
+Asynchronous sending is a communication method in which the sender sends a message and then sends the next message without waiting for the server to return a response.
+Asynchronous sending requires the implementation of the **Asynchronous Send Callback Interface** (SendCallback).
+:::note
+Asynchronous sending requires the implementation of the **Asynchronous SendCallback Interface**.
+:::
+After sending a message, the sender does not need to wait for a response from the server to send the next message. The sender receives the response from the server through the callback interface and handles the result. Asynchronous sending is generally used in time-consuming and response time sensitive business scenarios. For example, the video upload notifies the start of transcoding service, and notifies the push of transcoding result after transcoding is completed.
+
+The following is the sample code.
+
+``` javascript {16,17}
+public class AsyncProducer {
+ public static void main(String[] args) throws Exception {
+ // Initialize a producer and set the Producer group name
+ DefaultMQProducer producer = new DefaultMQProducer("please_rename_unique_group_name");
+ // Set the address of NameServer
+ producer.setNamesrvAddr("localhost:9876");
+ // Start Producer
+ producer.start();
+ producer.setRetryTimesWhenSendAsyncFailed(0);
+ for (int i = 0; i < 100; i++) {
+ final int index = i;
+ // Create a message and set the topic, tag, body and so on. The tag can be understood as a label to categorize the message, and RocketMQ can filter the tag on the consumer side.
+ Message msg = new Message("TopicTest",
+ "TagA",
+ "Hello world".getBytes(RemotingHelper.DEFAULT_CHARSET));
+ // Send a message asynchronously, the result is returned to the client by callback
+ producer.send(msg, new SendCallback() {
+ @Override
+ public void onSuccess(SendResult sendResult) {
+ System.out.printf("%-10d OK %s %n", index,
+ sendResult.getMsgId());
+ }
+ @Override
+ public void onException(Throwable e) {
+ System.out.printf("%-10d Exception %s %n", index, e);
+ e.printStackTrace();
+ }
+ });
+ }
+ // Close the producer once it is no longer in use
+ producer.shutdown();
+ }
+}
+```
+
+:::note
+The only difference between asynchronous and synchronous sending code is the parameters for calling the sending interface. Asynchronous sending does not wait for the return of the send, instead, the send method needs to be passed into the SendCallback implementation. The SendCallback interface mainly has onSuccess and onException two methods, indicating that the message is sent successfully or failed.
+:::
+
+### 3.3 One Way Sending
+
+
Review Comment:
The figure name should be: 单项模式发送
##########
docs/09-英文/02-Producer/05message1.md:
##########
@@ -0,0 +1,173 @@
+# Simple Message Sending
+
+## 1.Creating Topic in Cluster
+
+RocketMQ cluster is enabled by default **autoCreateTopicEnable** configuration. It will automatically create Topic for messages, if autoCreateTopicEnable is not enabled, you can also use RocketMQ Admin tool to create the target Topic.
+
+```shell
+> sh bin/mqadmin updateTopic -c DefaultCluster -t TopicTest -n 127.0.0.1:9876
+create topic to 127.0.0.1:10911 success.
+TopicConfig [topicName=TopicTest, readQueueNums=8, writeQueueNums=8, perm=RW-, topicFilterType=SINGLE_TAG, topicSysFlag=0, order=false, attributes=null]
+```
+
+After the command is executed, 8 queues are created on that Broker machine, named Topic of TopicTest.
+
+## 2.Adding Client-Side Dependency
+
+Firstly, add RocketMQ client-side dependency to JAVA application.
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+<Tabs>
+<TabItem value="Maven" label="Maven" default >
+
+```java
+<dependency>
+ <groupId>org.apache.rocketmq</groupId>
+ <artifactId>rocketmq-client</artifactId>
+ <version>4.9.4</version>
+</dependency>
+```
+</TabItem>
+<TabItem value="Gradle" label="Gradle">
+
+```java
+compile 'org.apache.rocketmq:rocketmq-client:4.9.4'
+```
+
+</TabItem>
+
+</Tabs>
+
+
+## 3.Message Sending
+
+Apache RocketMQ send messages in three ways: **synchronous, asynchronous, and one-way transmission**. The first two message types are reliable because they have responses regardless of whether they are successfully sent or not.
+
+### 3.1 Synchronous Sending
+
+Synchronous Sending is a communication method in which the message sender sends a message and will send the next message only after receiving a synchronous response from the server. Reliable synchronous transmission is widely used in various scenarios, such as important notification messages, short message notifications, etc.
+
+
+
+
+The entire code for synchronous sending is as follows:
+1. **Firstly a producer will be created**. Simple Messages create DefaultMQProducer. While creating producer, fill in the name of the production group which is the collection of the same class of Producer, such Producer sends same class of messages with same transmission logic.
+2. **Set the address of NameServer**. Apache Rocket has MQ many ways to set the address of the NameServer (described in the client configuration), this example is set by calling the producer's setNamesrvAddr() method in the code, if there are more than one NameServer, separated by a semicolon, such as "127.0.0.2:9876;127.0.0.3:9876".
+3. **The third step is to build the message**. Set the topic, tag, body and so on. The tag can be understood as a label to categorize the message, and RocketMQ can filter the tag on the consumer side.
+4. **Finally call the send() method to send the message out**. Ultimately, the send() method return a SendResult. The SendResut contains the actual send status including SEND_OK (send success), FLUSH_DISK_TIMEOUT (disk flush timeout), FLUSH_SLAVE_TIMEOUT (sync to slave timeout), SLAVE_NOT_AVAILABLE (slave can not be used), and an exception is thrown if send fails.
+``` javascript {16,15}
+public class SyncProducer {
+ public static void main(String[] args) throws Exception {
+ // Initialize a producer and set the Producer group name
+ DefaultMQProducer producer = new DefaultMQProducer("please_rename_unique_group_name"); //（1）
+ // Set the address of NameServer
+ producer.setNamesrvAddr("localhost:9876"); //（2）
+ // Start Producer
+ producer.start();
+ for (int i = 0; i < 100; i++) {
+ // Create a message and set the topic, tag, body and so on. The tag can be understood as a label to categorize the message, and RocketMQ can filter the tag on the consumer side.
+ Message msg = new Message("TopicTest" /* Topic */,
+ "TagA" /* Tag */,
+ ("Hello RocketMQ " + i).getBytes(RemotingHelper.DEFAULT_CHARSET) /* Message body */
+ ); //（3）
+ // Use the producer to send and wait for the result of sending synchronously
+ SendResult sendResult = producer.send(msg); //（4）
+ System.out.printf("%s%n", sendResult);
+ }
+ // Close the producer once it is no longer in use
+ producer.shutdown();
+ }
+}
+```
+
+
+
+### 3.2 Asynchronous Sending
+
+
+
+
+Asynchronous sending is a communication method in which the sender sends a message and then sends the next message without waiting for the server to return a response.
+Asynchronous sending requires the implementation of the **Asynchronous Send Callback Interface** (SendCallback).
+:::note
+Asynchronous sending requires the implementation of the **Asynchronous SendCallback Interface**.
+:::
+After sending a message, the sender does not need to wait for a response from the server to send the next message. The sender receives the response from the server through the callback interface and handles the result. Asynchronous sending is generally used in time-consuming and response time sensitive business scenarios. For example, the video upload notifies the start of transcoding service, and notifies the push of transcoding result after transcoding is completed.
+
+The following is the sample code.
+
+``` javascript {16,17}
+public class AsyncProducer {
+ public static void main(String[] args) throws Exception {
+ // Initialize a producer and set the Producer group name
+ DefaultMQProducer producer = new DefaultMQProducer("please_rename_unique_group_name");
+ // Set the address of NameServer
+ producer.setNamesrvAddr("localhost:9876");
+ // Start Producer
+ producer.start();
+ producer.setRetryTimesWhenSendAsyncFailed(0);
+ for (int i = 0; i < 100; i++) {
+ final int index = i;
+ // Create a message and set the topic, tag, body and so on. The tag can be understood as a label to categorize the message, and RocketMQ can filter the tag on the consumer side.
+ Message msg = new Message("TopicTest",
+ "TagA",
+ "Hello world".getBytes(RemotingHelper.DEFAULT_CHARSET));
+ // Send a message asynchronously, the result is returned to the client by callback
+ producer.send(msg, new SendCallback() {
+ @Override
+ public void onSuccess(SendResult sendResult) {
+ System.out.printf("%-10d OK %s %n", index,
+ sendResult.getMsgId());
+ }
+ @Override
+ public void onException(Throwable e) {
+ System.out.printf("%-10d Exception %s %n", index, e);
+ e.printStackTrace();
+ }
+ });
+ }
+ // Close the producer once it is no longer in use
+ producer.shutdown();
+ }
+}
+```
+
+:::note
+The only difference between asynchronous and synchronous sending code is the parameters for calling the sending interface. Asynchronous sending does not wait for the return of the send, instead, the send method needs to be passed into the SendCallback implementation. The SendCallback interface mainly has onSuccess and onException two methods, indicating that the message is sent successfully or failed.
Review Comment:
> The only difference between asynchronous and synchronous sending code is the parameters for calling the sending interface. Asynchronous sending does not wait for the return of the send, instead, the send method needs to be passed into the SendCallback implementation. The SendCallback interface mainly has onSuccess and onException two methods, indicating that the message is sent successfully or failed.
to:
> The only difference between asynchronous and synchronous sending methods is the parameters for calling the sending interface. Asynchronous sending does not wait for the return of send() method, instead, it will carry the SendCallback implementation. The SendCallback interface has two methods (onSuccess and onException), indicating that the message is sent successfully or failed.
##########
docs/09-英文/02-Producer/05message1.md:
##########
@@ -0,0 +1,173 @@
+# Simple Message Sending
+
+## 1.Creating Topic in Cluster
+
+RocketMQ cluster is enabled by default **autoCreateTopicEnable** configuration. It will automatically create Topic for messages, if autoCreateTopicEnable is not enabled, you can also use RocketMQ Admin tool to create the target Topic.
+
+```shell
+> sh bin/mqadmin updateTopic -c DefaultCluster -t TopicTest -n 127.0.0.1:9876
+create topic to 127.0.0.1:10911 success.
+TopicConfig [topicName=TopicTest, readQueueNums=8, writeQueueNums=8, perm=RW-, topicFilterType=SINGLE_TAG, topicSysFlag=0, order=false, attributes=null]
+```
+
+After the command is executed, 8 queues are created on that Broker machine, named Topic of TopicTest.
+
+## 2.Adding Client-Side Dependency
+
+Firstly, add RocketMQ client-side dependency to JAVA application.
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+<Tabs>
+<TabItem value="Maven" label="Maven" default >
+
+```java
+<dependency>
+ <groupId>org.apache.rocketmq</groupId>
+ <artifactId>rocketmq-client</artifactId>
+ <version>4.9.4</version>
+</dependency>
+```
+</TabItem>
+<TabItem value="Gradle" label="Gradle">
+
+```java
+compile 'org.apache.rocketmq:rocketmq-client:4.9.4'
+```
+
+</TabItem>
+
+</Tabs>
+
+
+## 3.Message Sending
+
+Apache RocketMQ send messages in three ways: **synchronous, asynchronous, and one-way transmission**. The first two message types are reliable because they have responses regardless of whether they are successfully sent or not.
+
+### 3.1 Synchronous Sending
+
+Synchronous Sending is a communication method in which the message sender sends a message and will send the next message only after receiving a synchronous response from the server. Reliable synchronous transmission is widely used in various scenarios, such as important notification messages, short message notifications, etc.
+
+
+
+
+The entire code for synchronous sending is as follows:
+1. **Firstly a producer will be created**. Simple Messages create DefaultMQProducer. While creating producer, fill in the name of the production group which is the collection of the same class of Producer, such Producer sends same class of messages with same transmission logic.
+2. **Set the address of NameServer**. Apache Rocket has MQ many ways to set the address of the NameServer (described in the client configuration), this example is set by calling the producer's setNamesrvAddr() method in the code, if there are more than one NameServer, separated by a semicolon, such as "127.0.0.2:9876;127.0.0.3:9876".
Review Comment:
> 2. **Set the address of NameServer**. Apache Rocket has MQ many ways to set the address of the NameServer (described in the client configuration), this example is set by calling the producer's setNamesrvAddr() method in the code, if there are more than one NameServer, separated by a semicolon, such as "127.0.0.2:9876;127.0.0.3:9876".
to:
> 2. **Set the address of NameServer**. Apache RocketMQ is able to set the address of the NameServer (described in the client configuration) in many ways. The following example is set by calling the producer's setNamesrvAddr() method in the code, separated by a semicolon if there is more than one NameServer, such as "127.0.0.2:9876;127.0.0.3:9876".
##########
docs/09-英文/02-Producer/05message1.md:
##########
@@ -0,0 +1,173 @@
+# Simple Message Sending
+
+## 1.Creating Topic in Cluster
+
+RocketMQ cluster is enabled by default **autoCreateTopicEnable** configuration. It will automatically create Topic for messages, if autoCreateTopicEnable is not enabled, you can also use RocketMQ Admin tool to create the target Topic.
+
+```shell
+> sh bin/mqadmin updateTopic -c DefaultCluster -t TopicTest -n 127.0.0.1:9876
+create topic to 127.0.0.1:10911 success.
+TopicConfig [topicName=TopicTest, readQueueNums=8, writeQueueNums=8, perm=RW-, topicFilterType=SINGLE_TAG, topicSysFlag=0, order=false, attributes=null]
+```
+
+After the command is executed, 8 queues are created on that Broker machine, named Topic of TopicTest.
+
+## 2.Adding Client-Side Dependency
+
+Firstly, add RocketMQ client-side dependency to JAVA application.
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+<Tabs>
+<TabItem value="Maven" label="Maven" default >
+
+```java
+<dependency>
+ <groupId>org.apache.rocketmq</groupId>
+ <artifactId>rocketmq-client</artifactId>
+ <version>4.9.4</version>
+</dependency>
+```
+</TabItem>
+<TabItem value="Gradle" label="Gradle">
+
+```java
+compile 'org.apache.rocketmq:rocketmq-client:4.9.4'
+```
+
+</TabItem>
+
+</Tabs>
+
+
+## 3.Message Sending
+
+Apache RocketMQ send messages in three ways: **synchronous, asynchronous, and one-way transmission**. The first two message types are reliable because they have responses regardless of whether they are successfully sent or not.
+
+### 3.1 Synchronous Sending
+
+Synchronous Sending is a communication method in which the message sender sends a message and will send the next message only after receiving a synchronous response from the server. Reliable synchronous transmission is widely used in various scenarios, such as important notification messages, short message notifications, etc.
+
+
+
+
+The entire code for synchronous sending is as follows:
+1. **Firstly a producer will be created**. Simple Messages create DefaultMQProducer. While creating producer, fill in the name of the production group which is the collection of the same class of Producer, such Producer sends same class of messages with same transmission logic.
+2. **Set the address of NameServer**. Apache Rocket has MQ many ways to set the address of the NameServer (described in the client configuration), this example is set by calling the producer's setNamesrvAddr() method in the code, if there are more than one NameServer, separated by a semicolon, such as "127.0.0.2:9876;127.0.0.3:9876".
+3. **The third step is to build the message**. Set the topic, tag, body and so on. The tag can be understood as a label to categorize the message, and RocketMQ can filter the tag on the consumer side.
+4. **Finally call the send() method to send the message out**. Ultimately, the send() method return a SendResult. The SendResut contains the actual send status including SEND_OK (send success), FLUSH_DISK_TIMEOUT (disk flush timeout), FLUSH_SLAVE_TIMEOUT (sync to slave timeout), SLAVE_NOT_AVAILABLE (slave can not be used), and an exception is thrown if send fails.
+``` javascript {16,15}
+public class SyncProducer {
+ public static void main(String[] args) throws Exception {
+ // Initialize a producer and set the Producer group name
+ DefaultMQProducer producer = new DefaultMQProducer("please_rename_unique_group_name"); //（1）
+ // Set the address of NameServer
+ producer.setNamesrvAddr("localhost:9876"); //（2）
+ // Start Producer
+ producer.start();
+ for (int i = 0; i < 100; i++) {
+ // Create a message and set the topic, tag, body and so on. The tag can be understood as a label to categorize the message, and RocketMQ can filter the tag on the consumer side.
+ Message msg = new Message("TopicTest" /* Topic */,
+ "TagA" /* Tag */,
+ ("Hello RocketMQ " + i).getBytes(RemotingHelper.DEFAULT_CHARSET) /* Message body */
+ ); //（3）
+ // Use the producer to send and wait for the result of sending synchronously
+ SendResult sendResult = producer.send(msg); //（4）
+ System.out.printf("%s%n", sendResult);
+ }
+ // Close the producer once it is no longer in use
+ producer.shutdown();
+ }
+}
+```
+
+
+
+### 3.2 Asynchronous Sending
+
+
+
+
+Asynchronous sending is a communication method in which the sender sends a message and then sends the next message without waiting for the server to return a response.
+Asynchronous sending requires the implementation of the **Asynchronous Send Callback Interface** (SendCallback).
+:::note
+Asynchronous sending requires the implementation of the **Asynchronous SendCallback Interface**.
+:::
+After sending a message, the sender does not need to wait for a response from the server to send the next message. The sender receives the response from the server through the callback interface and handles the result. Asynchronous sending is generally used in time-consuming and response time sensitive business scenarios. For example, the video upload notifies the start of transcoding service, and notifies the push of transcoding result after transcoding is completed.
+
+The following is the sample code.
+
+``` javascript {16,17}
+public class AsyncProducer {
+ public static void main(String[] args) throws Exception {
+ // Initialize a producer and set the Producer group name
+ DefaultMQProducer producer = new DefaultMQProducer("please_rename_unique_group_name");
+ // Set the address of NameServer
+ producer.setNamesrvAddr("localhost:9876");
+ // Start Producer
+ producer.start();
+ producer.setRetryTimesWhenSendAsyncFailed(0);
+ for (int i = 0; i < 100; i++) {
+ final int index = i;
+ // Create a message and set the topic, tag, body and so on. The tag can be understood as a label to categorize the message, and RocketMQ can filter the tag on the consumer side.
+ Message msg = new Message("TopicTest",
+ "TagA",
+ "Hello world".getBytes(RemotingHelper.DEFAULT_CHARSET));
+ // Send a message asynchronously, the result is returned to the client by callback
+ producer.send(msg, new SendCallback() {
+ @Override
+ public void onSuccess(SendResult sendResult) {
+ System.out.printf("%-10d OK %s %n", index,
+ sendResult.getMsgId());
+ }
+ @Override
+ public void onException(Throwable e) {
+ System.out.printf("%-10d Exception %s %n", index, e);
+ e.printStackTrace();
+ }
+ });
+ }
+ // Close the producer once it is no longer in use
+ producer.shutdown();
+ }
+}
+```
+
+:::note
+The only difference between asynchronous and synchronous sending code is the parameters for calling the sending interface. Asynchronous sending does not wait for the return of the send, instead, the send method needs to be passed into the SendCallback implementation. The SendCallback interface mainly has onSuccess and onException two methods, indicating that the message is sent successfully or failed.
+:::
+
+### 3.3 One Way Sending
+
+
+
+
+
+The sender is only responsible for sending the message and does not wait for the server to return a response and no callback function is triggered, in other word, it only sends the request and does not wait for the answer. The process of sending messages in this way is very short, usually in the microsecond level. It is suitable for some scenarios where the time consumption is very short, but the reliability requirement is not high, such as log collection.
+
+``` javascript {16}
+public class OnewayProducer {
+ public static void main(String[] args) throws Exception{
+ // Initialize a producer and set the Producer group name
+ DefaultMQProducer producer = new DefaultMQProducer("please_rename_unique_group_name");
+ // Set the address of NameServer
+ producer.setNamesrvAddr("localhost:9876");
+ // Start Producer
+ producer.start();
+ for (int i = 0; i < 100; i++) {
+ // Create a message and set the topic, tag, body and so on. The tag can be understood as a label to categorize the message, and RocketMQ can filter the tag on the consumer side.
+ Message msg = new Message("TopicTest" /* Topic */,
+ "TagA" /* Tag */,
+ ("Hello RocketMQ " + i).getBytes(RemotingHelper.DEFAULT_CHARSET) /* Message body */
+ );
+ // Since there is no request-answer processing when sending messages in the oneway method, if there is a message sending failure, data will be lost because there is no retry. If data cannot be lost, it is recommended to use the reliable synchronous or reliable asynchronous sending method.
+ producer.sendOneway(msg);
+ }
+ // Close the producer once it is no longer in use
+ producer.shutdown();
+ }
+}
+```
+
+One-way mode calls to the sendOneway() method do not have any waiting or processing for the returned results.
Review Comment:
> One-way mode calls to the sendOneway() method do not have any waiting or processing for the returned results.
to:
> One-way mode will call the sendOneway() method, which does not wait or process the returned result.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: dev-unsubscribe@rocketmq.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org