In the development of Wechat, it is very important for us to get user's detailed information through openid, including nicknames, avatars, provinces, cities and districts. But in the mobile age, many people pursue personality and use a lot of Martian characters or emoticons in their names. (I have actually tested a 20w + user's public number, nickname, provincial and urban information may contain special characters, but I do not know why there are special characters in provinces and urban areas for the time being.) This has brought some problems to the development of Wechat. When we get nicknames and save them in mysql database, we will make mistakes. Mistake.

The following three solutions:

1. Get the user's nickname, filter out the information containing special characters and save it. The advantage is simple, but the disadvantage is that the nickname details will be lost. Only under very lax circumstances can we use it.

nickname.replaceAll("[\ue000-\uefff]","");

2. Make special settings for mysql. The advantage is that you can solve the problem once and for all. The disadvantage is that it may affect the performance of mysql. And if your database is set up, the tables will be difficult to modify.

Step 1: Find your mysql configuration file, commonly called my.cnf. When you open it, search the character keyword globally, and you can find the information that contains the character. This is to set the character encoding so that their values are equal to utf8mb4, for example: default-character-set=utf8mb4.

Step 2: Modify the character set of the table column and change the character set of your existing table to utf8mb4 encoding.

Step 3: JDBC database connection

jdbc:mysql://localhost:3306/mediamall?useSSL=false&useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true

3. It's also the method I'm using right now, which is to find out nickname, then code nickname, and save it to the database after coding. The advantage of this method is that it does not lose details and is easy to operate. Only one line of code is needed to encode the data. The disadvantage is that nickname can't understand when it opens the table directly with navicat, and when it comes to nickname, it must remember to decode it first.

 import org.apache.commons.codec.binary.Base64;
 String nickname = jsonObject.getString("nickname");//jsonObject Objects are transformed from queried user information json The object is Alibaba's. fastjson
 //Coding
 nickname =Base64.encodeBase64String(nickname.getBytes("UTF-8"));
 //Decoding
 nickname = new String(Base64.decodeBase64(nickname),"UTF-8");

If the data needs to be encoded and decoded by Base64 on HTML pages, you can use the following methods:

        /**
         * Base64 encode / decode
         */
        function Base64() {
            // private property
            _keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
 
            // public method for encoding
            this.encode = function (input) {
                var output = "";
                var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
                var i = 0;
                input = _utf8_encode(input);
                while (i < input.length) {
                    chr1 = input.charCodeAt(i++);
                    chr2 = input.charCodeAt(i++);
                    chr3 = input.charCodeAt(i++);
                    enc1 = chr1 >> 2;
                    enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
                    enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
                    enc4 = chr3 & 63;
                    if (isNaN(chr2)) {
                        enc3 = enc4 = 64;
                    } else if (isNaN(chr3)) {
                        enc4 = 64;
                    }
                    output = output +
                        _keyStr.charAt(enc1) + _keyStr.charAt(enc2) +
                        _keyStr.charAt(enc3) + _keyStr.charAt(enc4);
                }
                return output;
            }
 
            // public method for decoding
            this.decode = function (input) {
                var output = "";
                var chr1, chr2, chr3;
                var enc1, enc2, enc3, enc4;
                var i = 0;
                input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
                while (i < input.length) {
                    enc1 = _keyStr.indexOf(input.charAt(i++));
                    enc2 = _keyStr.indexOf(input.charAt(i++));
                    enc3 = _keyStr.indexOf(input.charAt(i++));
                    enc4 = _keyStr.indexOf(input.charAt(i++));
                    chr1 = (enc1 << 2) | (enc2 >> 4);
                    chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
                    chr3 = ((enc3 & 3) << 6) | enc4;
                    output = output + String.fromCharCode(chr1);
                    if (enc3 != 64) {
                        output = output + String.fromCharCode(chr2);
                    }
                    if (enc4 != 64) {
                        output = output + String.fromCharCode(chr3);
                    }
                }
                output = _utf8_decode(output);
                return output;
            }
 
            // private method for UTF-8 encoding
            _utf8_encode = function (string) {
                string = string.replace(/\r\n/g, "\n");
                var utftext = "";
                for (var n = 0; n < string.length; n++) {
                    var c = string.charCodeAt(n);
                    if (c < 128) {
                        utftext += String.fromCharCode(c);
                    } else if ((c > 127) && (c < 2048)) {
                        utftext += String.fromCharCode((c >> 6) | 192);
                        utftext += String.fromCharCode((c & 63) | 128);
                    } else {
                        utftext += String.fromCharCode((c >> 12) | 224);
                        utftext += String.fromCharCode(((c >> 6) & 63) | 128);
                        utftext += String.fromCharCode((c & 63) | 128);
                    }
 
                }
                return utftext;
            }
 
            // private method for UTF-8 decoding
            _utf8_decode = function (utftext) {
                var string = "";
                var i = 0;
                var c = c1 = c2 = 0;
                while (i < utftext.length) {
                    c = utftext.charCodeAt(i);
                    if (c < 128) {
                        string += String.fromCharCode(c);
                        i++;
                    } else if ((c > 191) && (c < 224)) {
                        c2 = utftext.charCodeAt(i + 1);
                        string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
                        i += 2;
                    } else {
                        c2 = utftext.charCodeAt(i + 1);
                        c3 = utftext.charCodeAt(i + 2);
                        string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
                        i += 3;
                    }
                }
                return string;
            }
        }

//1.encryption  
var str = 'Contents requiring encryption and decryption';  
var base = new Base64();  
var result = base.encode(str);   
  
//2.Decrypt  
var result2 = base.decode(result);  

The above is my personal summary. I recommend that you use the third way to encode and save the data. You need to decode the data so that you won't lose details or affect other data in the database.