微信小程序前端传到服务器后端中文乱码问题(附AES)

微信小程序前端传到服务器后端中文乱码问题

问题描述

微信小程序通过wx.request接口连接服务器并传送data的json格式时，中文会出现乱码现象

解决办法

这里给出我研究出来的解决办法。先将你要传送的数据进行AES加密，在后台进行AES解密即可。虽然办法稍微有点复杂，但是对于处理乱码现象和增强数据的保密性安全性都有很大的帮助

这里简单说一下AES加解密的步骤：
1.前端运用到util.js和AES.js两个文件，其中在util.js里面运用AES.js文件设置有密钥和偏移iv
2.在需要传输数据的demo.js中用util.js文件暴露出来的接口方法encrypt加密
3.AESOperator.java是后端的工具类，在后端用其进行解密即可

代码如下

微信小程序前端代码

demo.js

var CryptoJS = require('../../util/util.js')

var name = CryptoJS.Encrypt('xxx');
wx.request({
   
      url: 'xxx',
      method: 'POST',
      dataType: 'STRING',
      data: {
   
		name:name
      },
      header: {
   
        'content-type': 'application/json' // 默认值
      },
      success: function (res) {
   
        console.log(JSON.parse(res.data))
      },
    })

demo.js主要用到了AES.js暴露的方法Encrypt，这里注意要先require AES.js 过来才能使用它暴露的方法

Util.js

var CryptoJS = require('AES.js');
var key = CryptoJS.enc.Utf8.parse("1234123412ABCDEF");
var iv = CryptoJS.enc.Utf8.parse('ABCDEF1234123412');
// AES加密
function Encrypt(word) {
   
  var srcs = CryptoJS.enc.Utf8.parse(word);
  var encrypted = CryptoJS.AES.encrypt(srcs, key, {
    iv: iv, mode: CryptoJS.mode.CBC, padding: CryptoJS.pad.Pkcs7 });
  encrypted =encrypted.ciphertext.toString().toUpperCase();
  return encrypted;
}
// AES解密
function Decrypt(word) {
   
  var encryptedHexStr = CryptoJS.enc.Hex.parse(word);
  var srcs = CryptoJS.enc.Base64.stringify(encryptedHexStr);
  var decrypt = CryptoJS.AES.decrypt(srcs, key, {
    iv: iv, mode: CryptoJS.mode.CBC, padding: CryptoJS.pad.Pkcs7 });
  var decryptedStr = decrypt.toString(CryptoJS.enc.Utf8);
  return decryptedStr.toString();
}
module.exports = {
   
  Encrypt: Encrypt,
  Decrypt: Decrypt,
}

AES.js

var CryptoJS = CryptoJS || function(u, p) {
   
  var d = {
   },
    l = d.lib = {
   },
    s = function() {
   },
    t = l.Base = {
   
      extend: function(a) {
   
        s.prototype = this;
        var c = new s;
        a && c.mixIn(a);
        c.hasOwnProperty("init") || (c.init = function() {
   
          c.$super.init.apply(this, arguments)
        });
        c.init.prototype = c;
        c.$super = this;
        return c
      },
      create: function() {
   
        var a = this.extend();
        a.init.apply(a, arguments);
        return a
      },
      init: function() {
   },
      mixIn: function(a) {
   
        for (var c in a) a.hasOwnProperty(c) && (this[c] = a[c]);
        a.hasOwnProperty("toString") && (this.toString = a.toString)
      },
      clone: function() {
   
        return this.init.prototype.extend(this)
      }
    },
    r = l.WordArray = t.extend({
   
      init: function(a, c) {
   
        a = this.words = a || [];
        this.sigBytes = c != p ? c : 4 * a.length
      },
      toString: function(a) {
   
        return (a || v).stringify(this)
      },
      concat: function(a) {
   
        var c = this.words,
          e = a.words,
          j = this.sigBytes;
        a = a.sigBytes;
        this.clamp();
        if (j % 4)
          for (var k = 0; k < a; k++) c[j + k >>> 2] |= (e[k >>> 2] >>> 24 - 8 * (k % 4) & 255) << 24 - 8 * ((j + k) % 4);
        else if (65535 < e.length)
          for (k = 0; k < a; k += 4) c[j + k >>> 2] = e[k >>> 2];
        else c.push.apply(c, e);
        this.sigBytes += a;
        return this
      },
      clamp: function() {
   
        var a = this.words,
          c = this.sigBytes;
        a[c >>> 2] &= 4294967295 <<
          32 - 8 * (c % 4);
        a.length = u.ceil(c / 4)
      },
      clone: function() {
   
        var a = t.clone.call(this);
        a.words = this.words.slice(0);
        return a
      },
      random: function(a) {
   
        for (var c = [], e = 0; e < a; e += 4) c.push(4294967296 * u.random() | 0);
        return new r.init(c, a)
      }
    }),
    w = d.enc = {
   },
    v = w.Hex = {
   
      stringify: function(a) {
   
        var c = a.words;
        a = a.sigBytes;
        for (var e = [], j = 0; j < a; j++) {
   
          var k = c[j >>> 2] >>> 24 - 8 * (j % 4) & 255;
          e.push((k >>> 4).toString(16));
          e.push((k & 15).toString(16))
        }
        return e.join("")
      },
      parse: function(a) {
   
        for (var c = a.length, e = [], j = 0; j < c; j += 2) e[j >>> 3] |= parseInt(a.substr(j,
          2), 16) << 24 - 4 * (j % 8);
        return new r.init(e, c / 2)
      }
    },
    b = w.Latin1 = {
   
      stringify: function(a) {
   
        var c = a.words;
        a = a.sigBytes;
        for (var e = [], j = 0; j < a; j++) e.push(String.fromCharCode(c[j >>> 2] >>> 24 - 8 * (j % 4) & 255));
        return e.join("")
      },
      parse: function(a) {
   
        for (var c = a.length, e = [], j = 0; j < c; j++) e[j >>> 2] |= (a.charCodeAt(j) & 255) << 24 - 8 * (j % 4);
        return new r.init(e, c)
      }
    },
    x = w.Utf8 = {
   
      stringify: function(a) {
   
        try {
   
          return decodeURIComponent(escape(b.stringify(a)))
        } catch (c) {
   
          throw Error("Malformed UTF-8 data");
        }
      },
      parse: function(a) {
   
        return b.parse(unescape(encodeURIComponent(a)))
      }
    },
    q = l.BufferedBlockAlgorithm = t.extend({
   
      reset: function() {
   
        this._data = new r.init;
        this._nDataBytes = 0
      },
      _append: function(a) {
   
        "string" == typeof a && (a = x.parse(a));
        this._data.concat(a);
        this._nDataBytes += a.sigBytes
      },
      _process: function(a) {
   
        var c = this._data,
          e = c.words,
          j = c.sigBytes,
          k = this.blockSize,
          b = j / (4 * k),
          b = a ? u.ceil(b) : u.max((b | 0) - this._minBufferSize, 0);
        a = b * k;
        j = u.min(4 * a, j);
        if (a) {
   
          for (var q = 0; q < a; q += k) this._doProcessBlock(e, q);
          q = e.splice(0, a);
          c.sigBytes -= j
        }
        return new r.init(q, j)
      },
      clone: function() {
   
        var a = t.clone.call(this);
        a._data = this._data.clone();
        return a
      },
      _minBufferSize: 0
    })