WeChat public account Development Tutorial Article 1-how to limit the length of text messages

I believe many of my friends have encountered this problem: when the content of the sent text message is too long, no response will be made. What is the maximum length of text messages allowed? How can we calculate the length of the text? Why does it seem that the maximum length of supported text messages is over 1300? This article will completely lift your questions.

I believe many of my friends have encountered this problem: when the content of the sent text message is too long, no response will be made. What is the maximum length of text messages allowed? How can we calculate the length of the text? Why does it seem that the maximum length of supported text messages is over 1300? This article will completely lift your questions.

The message length limit in the API documentation is 2048.

As you can see, the interface documentation clearly states that the length of the reply message cannot exceed 2048 bytes. So why don't many people respond when the message content length is over 1300 characters? I think this problem should not be clarified in this section how to calculate the number of bytes of text.

How to correctly calculate the number of bytes occupied by text

The first thought of calculating the number of bytes occupied by text (String) is the getBytes () method of the String class. this method returns the byte array corresponding to the String, then, the length of the array is calculated to obtain the number of bytes occupied by the string. For example:

[Java]View plaincopyprint?

1. Public static void main (String [] args ){
2. // Running result: 4
3. System. out. println ("Liu Feng". getBytes (). length );
4. }

Public static void main (String [] args) {// running result: 4System. out. println ("Liu Feng". getBytes (). length );}

In the preceding example, the number of bytes occupied by two Chinese characters is 4, that is, one Chinese character occupies 2 bytes. Is that true? In fact, we ignored a problem: for different encoding methods, the number of Chinese characters is different! What exactly does this mean? In the preceding example, the encoding method is not specified, so the default encoding method of the operating system is used. Let's take a look at three conclusions:

1) If the above example runs on the operating system platform with the default encoding method of ISO8859-1, the calculation result is 2;

2) if the preceding example runs on the operating system platform with the default encoding method gb2312 or gbk, the calculation result is 4;

3) If the preceding example runs on the operating system platform with the default encoding method UTF-8, the calculation result is 6;

If so, does it mean that the String. getBytes () method uses gb2312 or gbk encoding on our system platform by default? Let's look at an example:

[Java]View plaincopyprint?

1. Public static void main (String [] args) throws UnsupportedEncodingException {
2. // Running Result: 2
3. System. out. println ("Liu Feng". getBytes ("ISO8859-1"). length );
4. // Running result: 4
5. System. out. println ("Liu Feng". getBytes ("GB2312"). length );
6. // Running result: 4
7. System. out. println ("Liu Feng". getBytes ("GBK"). length );
8. // Running result: 6
9. System. out. println ("Liu Feng". getBytes ("UTF-8"). length );
10. }

Public static void main (String [] args) throws UnsupportedEncodingException {// running result: 2System. out. println ("Liu Feng ". getBytes ("ISO8859-1 "). length); // running result: 4System. out. println ("Liu Feng ". getBytes ("GB2312 "). length); // running result: 4System. out. println ("Liu Feng ". getBytes ("GBK "). length); // running result: 6System. out. println ("Liu Feng ". getBytes ("UTF-8 "). length );}

Does this example prove the three conclusions I have given above? That is to say, the use of ISO8859-1 encoding, a medium/English are only one byte; the use of GB2312 or GBK encoding, a Chinese occupies two bytes; and the use of UTF-8 encoding, A Chinese character occupies three bytes.

The encoding method used by the platform and the calculation of the number of bytes occupied by the string

So what encoding method should I use when returning a message to the server? Of course it is UTF-8, because we have adopted the following code in the doPost method to avoid Chinese garbled characters:

[Java]View plaincopyprint?

1. // Set the request and response encoding to UTF-8 (to prevent Chinese garbled characters)
2. Request. setCharacterEncoding ("UTF-8 ");
3. Response. setCharacterEncoding ("UTF-8 ");

// Set the request and response encoding to UTF-8 (to prevent Chinese garbled characters) request. setCharacterEncoding ("UTF-8"); response. setCharacterEncoding ("UTF-8 ");

To verify what I said, I wrote an example to test:

[Java]View plaincopyprint?

1. Private static String getMsgContent (){
2. StringBuffer buffer = new StringBuffer ();
3. // There are 70 Chinese characters in each line. a total of 682 Chinese characters are added with an English exclamation point
4. Buffer. append I will accompany you with any difficulties ");
5. Buffer. append I will accompany you with any difficulties ");
6. Buffer. append I will accompany you with any difficulties ");
7. Buffer. append I will accompany you with any difficulties ");
8. Buffer. append I will accompany you with any difficulties ");
9. Buffer. append I will accompany you with any difficulties ");
10. Buffer. append I will accompany you with any difficulties ");
11. Buffer. append I will accompany you with any difficulties ");
12. Buffer. append I will accompany you with any difficulties ");
13. Buffer. append! ");
14. Return buffer. toString ();
15. }
17. Public static void main (String [] args) throws Exception {
18. // When gb2312 encoding is used, it occupies 1365 bytes.
19. System. out. println (getMsgContent (). getBytes ("gb2312"). length );
20. // UTF-8 encoding occupies 2047 bytes
21. System. out. println (getMsgContent (). getBytes ("UTF-8"). length );
22. }

Private static String getMsgContent () {StringBuffer buffer = new StringBuffer (); // each line contains 70 Chinese characters. a total of 682 Chinese characters are added with an English exclamation point buffer. append I will accompany you with any difficulties "); buffer. append I will accompany you with any difficulties "); buffer. append I will accompany you with any difficulties "); buffer. append ("I don't know when to like each At night, I will come here to see how beautiful you are, so that I can't help but see you, and I will lose myself and want to lead your hand through the ups and downs, and I will accompany you "); buffer. append I will accompany you with any difficulties "); buffer. append I will accompany you with any difficulties "); buffer. append I will accompany you with any difficulties "); buffer. append what I will always accompany you "); buffer. append I will accompany you with any difficulties "); buffer. append! "); Return buffer. toString ();} public static void main (String [] args) throws Exception {// 1365 bytes of System are occupied when gb2312 encoding is used. out. println (getMsgContent (). getBytes ("gb2312 "). length); // when UTF-8 encoding is used, the System occupies 2047 bytes. out. println (getMsgContent (). getBytes ("UTF-8 "). length );}

The content returned by the getMsgContent () method is exactly what the text message can support at most, that is, when UTF-8 encoding is used, the text message content supports up to 2047 bytesThat is, the reply message content in the public platform interface document cannot exceed 2048 bytes, even if it is equal to 2048 bytes. you can try () if you add an English symbol to the content of the method, it will not respond.

At the same time, we also found that if the gb2312 encoding method is used to calculate the number of bytes of the text returned by the getMsgContent () method, the result is 1365, this is why many friends say that the maximum length of text messages seems to only support more than 1300 bytes, not the 2048 bytes mentioned in the interface documentation. In fact, the encoding method is ignored, the getBytes () method of the String class is simply used instead of the getBytes ("UTF-8") method to calculate the number of occupied nodes.

Calculation method encapsulation of the number of bytes occupied by UTF-8 encoding in Java

[Java]View plaincopyprint?

1. /**
2. * Calculate the number of bytes occupied by the string when UTF-8 encoding is used.
3. *
4. * @ Param content
5. * @ Return
6. */
7. Public static int getByteSize (String content ){
8. Int size = 0;
9. If (null! = Content ){
10. Try {
11. // Chinese characters are UTF-8 encoded in 3 bytes
12. Size = content. getBytes ("UTF-8"). length;
13. } Catch (UnsupportedEncodingException e ){
14. E. printStackTrace ();
15. }
16. }
17. Return size;
18. }

/*** Calculate the number of bytes occupied by the String when UTF-8 encoding is used ** @ param content * @ return */public static int getByteSize (String content) {int size = 0; if (null! = Content) {try {// when Chinese characters are UTF-8 encoded, the size of the three bytes = content. getBytes ("UTF-8 "). length;} catch (UnsupportedEncodingException e) {e. printStackTrace () ;}} return size ;}

Well, the content of this chapter is here. I think you should not only learn the number 2047, but also have a new understanding of character encoding methods.