fastjson toJSONString
Java
fastjson toJSONString
Java

fastjson toJSONString

fastjson toJSONString

SerializerFeature

https://blog.csdn.net/u010246789/article/details/52539576

1.空值原样返回

SerializerFeature.WRITE_MAP_NULL_FEATURES



    final static int serializerFeature = SerializerFeature.QuoteFieldNames.getMask() | SerializerFeature.WriteMapNullValue.getMask();

2.序列化私有成员(按需)

final static int serializerFeature = SerializerFeature.WriteMapNullValue.getMask() | SerializerFeature.WriteNullListAsEmpty.getMask() | SerializerFeature.QuoteFieldNames.getMask();

后执行

var encryptor = new JSEncrypt()

const publicKey = '公钥'

const privateKey = '私钥'

// Convert a hex string to a byte array
function hexToBytes(hex) {
  for (var bytes = [], c = 0; c < hex.length; c += 2) {
    bytes.push(parseInt(hex.substr(c, 2), 16))
  }
  return bytes
}

// Convert a byte array to a hex string
function bytesToHex(bytes) {
  for (var hex = [], i = 0; i < bytes.length; i++) {
    hex.push((bytes[i] >>> 4).toString(16))
    hex.push((bytes[i] & 0xF).toString(16))
  }
  return hex.join('')
}

var BI_RM = '0123456789abcdefghijklmnopqrstuvwxyz'

function int2char(n) {
  return BI_RM.charAt(n)
}

var b64map = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
var b64pad = '='

function hex2b64(h) {
  var i
  var c
  var ret = ''
  for (i = 0; i + 3 <= h.length; i += 3) {
    c = parseInt(h.substring(i, i + 3), 16)
    ret += b64map.charAt(c >> 6) + b64map.charAt(c & 63)
  }
  if (i + 1 == h.length) {
    c = parseInt(h.substring(i, i + 1), 16)
    ret += b64map.charAt(c << 2)
  } else if (i + 2 == h.length) {
    c = parseInt(h.substring(i, i + 2), 16)
    ret += b64map.charAt(c >> 2) + b64map.charAt((c & 3) << 4)
  }
  while ((ret.length & 3) > 0) {
    ret += b64pad
  }
  return ret
}

// convert a base64 string to hex
function b64tohex(s) {
  var ret = ''
  var i
  var k = 0 // b64 state, 0-3
  var slop = 0
  for (i = 0; i < s.length; ++i) {
    if (s.charAt(i) == b64pad) {
      break
    }
    var v = b64map.indexOf(s.charAt(i))
    if (v < 0) {
      continue
    }
    if (k == 0) {
      ret += int2char(v >> 2)
      slop = v & 3
      k = 1
    } else if (k == 1) {
      ret += int2char((slop << 2) | (v >> 4))
      slop = v & 0xf
      k = 2
    } else if (k == 2) {
      ret += int2char(slop)
      ret += int2char(v >> 2)
      slop = v & 3
      k = 3
    } else {
      ret += int2char((slop << 2) | (v >> 4))
      ret += int2char(v & 0xf)
      k = 0
    }
  }
  if (k == 1) {
    ret += int2char(slop << 2)
  }
  return ret
}

// 方法一
JSEncrypt.prototype.encryptLong = function (d) {
  var k = this.key
  var maxLength = (((k.n.bitLength() + 7) >> 3) - 11)

  try {
    var lt = ''
    var ct = ''

    if (d.length > maxLength) {
      lt = d.match(/.{1,117}/g)
      lt.forEach(function (entry) {
        var t1 = k.encrypt(entry)
        ct += t1
      })
      return hexToBytes(ct)
    }
    var t = k.encrypt(d)
    var y = hexToBytes(t)
    return y
  } catch (ex) {
    return false
  }
}

JSEncrypt.prototype.decryptLong = function (string) {
  var k = this.getKey()
  var maxLength = ((k.n.bitLength() + 7) >> 3)
  // var maxLength = 128;
  try {
    var str = bytesToHex(string)
    // var b=hex2Bytes(str);

    var inputLen = str.length

    var ct = ''
    if (str.length > maxLength) {
      var lt = str.match(/.{1,256}/g)
      lt.forEach(function (entry) {
        var t1 = k.decrypt(entry)
        ct += t1
      })
      return ct
    }
    var y = k.decrypt(bytesToHex(string))
    return y
  } catch (ex) {
    return false
  }
}

// 方法2
JSEncrypt.prototype.encryptLong2 = function (string) {
  var k = this.getKey()
  try {
    var lt = ''
    var ct = ''
    // RSA每次加密117bytes，需要辅助方法判断字符串截取位置
    // 1.获取字符串截取点
    var bytes = new Array()
    bytes.push(0)
    var byteNo = 0
    var len, c
    len = string.length
    var temp = 0
    for (var i = 0; i < len; i++) {
      c = string.charCodeAt(i)
      if (c >= 0x010000 && c <= 0x10FFFF) {
        byteNo += 4
      } else if (c >= 0x000800 && c <= 0x00FFFF) {
        byteNo += 3
      } else if (c >= 0x000080 && c <= 0x0007FF) {
        byteNo += 2
      } else {
        byteNo += 1
      }
      if ((byteNo % 117) >= 114 || (byteNo % 117) == 0) {
        if (byteNo - temp >= 114) {
          bytes.push(i)
          temp = byteNo
        }
      }
    }
    // 2.截取字符串并分段加密
    if (bytes.length > 1) {
      for (var i = 0; i < bytes.length - 1; i++) {
        var str
        if (i == 0) {
          str = string.substring(0, bytes[i + 1] + 1)
        } else {
          str = string.substring(bytes[i] + 1, bytes[i + 1] + 1)
        }
        var t1 = k.encrypt(str)
        ct += t1
      }

      if (bytes[bytes.length - 1] != string.length - 1) {
        var lastStr = string.substring(bytes[bytes.length - 1] + 1)
        ct += k.encrypt(lastStr)
      }
      // return hexToBytes(ct)
      return hex2b64(ct)
    }
    var t = k.encrypt(string)
    // var y = hexToBytes(t)
    var y = hex2b64(t)
    return y
  } catch (ex) {
    return false
  }
}

function strtohex(code) {
  var hexstr = []
  for (var i = 0; i < code.length; i++) {
    hexstr += code.charCodeAt(i).toString(16)
  }
  return hexstr
}

JSEncrypt.prototype.decryptLong2 = function (string) {
  var k = this.getKey()
  // var maxLength = ((k.n.bitLength()+7)>>3);
  var MAX_DECRYPT_BLOCK = 128
  try {
    var ct = ''
    var t1
    var bufTmp
    var hexTmp
    // var str = bytesToHex(string)
    var str = b64tohex(string)
    var buf = hexToBytes(str)
    var inputLen = buf.length
    // 开始长度
    var offSet = 0
    // 结束长度
    var endOffSet = MAX_DECRYPT_BLOCK

    // 分段解密
    while (inputLen - offSet > 0) {
      if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
        bufTmp = buf.slice(offSet, endOffSet)
        hexTmp = bytesToHex(bufTmp)
        t1 = k.decrypt(hexTmp)
        ct += t1
      } else {
        bufTmp = buf.slice(offSet, inputLen)
        hexTmp = bytesToHex(bufTmp)
        t1 = k.decrypt(hexTmp)
        ct += t1
      }
      offSet += MAX_DECRYPT_BLOCK
      endOffSet += MAX_DECRYPT_BLOCK
    }
    return ct
  } catch (ex) {
    return false
  }
}

// 加密
function encrypt(txt) {
  txt = encodeURIComponent(txt)
  const encryptor = new JSEncrypt()
  encryptor.setPublicKey(publicKey) // 设置公钥
  let s = encryptor.encryptLong2(txt)
  console.log('加密前:' + txt + '\n加密后:' + s)
  return s
}

// 解密
function decrypt(txt) {
  const decryptor = new JSEncrypt()
  decryptor.setPrivateKey(privateKey)
  let s = decryptor.decryptLong2(txt)
  s = decodeURIComponent(s)
  console.log('解密前:' + txt + '\n解密后:' + s)
  return s
}

var text = response.json.data
console.log(text)
text = decrypt(text);
console.log(text)
response.raw.responseText=text

预执行

var encryptor = new JSEncrypt()

const publicKey = '公钥'

const privateKey = '私钥'

// Convert a hex string to a byte array
function hexToBytes(hex) {
  for (var bytes = [], c = 0; c < hex.length; c += 2) {
    bytes.push(parseInt(hex.substr(c, 2), 16))
  }
  return bytes
}

// Convert a byte array to a hex string
function bytesToHex(bytes) {
  for (var hex = [], i = 0; i < bytes.length; i++) {
    hex.push((bytes[i] >>> 4).toString(16))
    hex.push((bytes[i] & 0xF).toString(16))
  }
  return hex.join('')
}

var BI_RM = '0123456789abcdefghijklmnopqrstuvwxyz'

function int2char(n) {
  return BI_RM.charAt(n)
}

var b64map = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
var b64pad = '='

function hex2b64(h) {
  var i
  var c
  var ret = ''
  for (i = 0; i + 3 <= h.length; i += 3) {
    c = parseInt(h.substring(i, i + 3), 16)
    ret += b64map.charAt(c >> 6) + b64map.charAt(c & 63)
  }
  if (i + 1 == h.length) {
    c = parseInt(h.substring(i, i + 1), 16)
    ret += b64map.charAt(c << 2)
  } else if (i + 2 == h.length) {
    c = parseInt(h.substring(i, i + 2), 16)
    ret += b64map.charAt(c >> 2) + b64map.charAt((c & 3) << 4)
  }
  while ((ret.length & 3) > 0) {
    ret += b64pad
  }
  return ret
}

// convert a base64 string to hex
function b64tohex(s) {
  var ret = ''
  var i
  var k = 0 // b64 state, 0-3
  var slop = 0
  for (i = 0; i < s.length; ++i) {
    if (s.charAt(i) == b64pad) {
      break
    }
    var v = b64map.indexOf(s.charAt(i))
    if (v < 0) {
      continue
    }
    if (k == 0) {
      ret += int2char(v >> 2)
      slop = v & 3
      k = 1
    } else if (k == 1) {
      ret += int2char((slop << 2) | (v >> 4))
      slop = v & 0xf
      k = 2
    } else if (k == 2) {
      ret += int2char(slop)
      ret += int2char(v >> 2)
      slop = v & 3
      k = 3
    } else {
      ret += int2char((slop << 2) | (v >> 4))
      ret += int2char(v & 0xf)
      k = 0
    }
  }
  if (k == 1) {
    ret += int2char(slop << 2)
  }
  return ret
}

// 方法一
JSEncrypt.prototype.encryptLong = function (d) {
  var k = this.key
  var maxLength = (((k.n.bitLength() + 7) >> 3) - 11)

  try {
    var lt = ''
    var ct = ''

    if (d.length > maxLength) {
      lt = d.match(/.{1,117}/g)
      lt.forEach(function (entry) {
        var t1 = k.encrypt(entry)
        ct += t1
      })
      return hexToBytes(ct)
    }
    var t = k.encrypt(d)
    var y = hexToBytes(t)
    return y
  } catch (ex) {
    return false
  }
}

JSEncrypt.prototype.decryptLong = function (string) {
  var k = this.getKey()
  var maxLength = ((k.n.bitLength() + 7) >> 3)
  // var maxLength = 128;
  try {
    var str = bytesToHex(string)
    // var b=hex2Bytes(str);

    var inputLen = str.length

    var ct = ''
    if (str.length > maxLength) {
      var lt = str.match(/.{1,256}/g)
      lt.forEach(function (entry) {
        var t1 = k.decrypt(entry)
        ct += t1
      })
      return ct
    }
    var y = k.decrypt(bytesToHex(string))
    return y
  } catch (ex) {
    return false
  }
}

// 方法2
JSEncrypt.prototype.encryptLong2 = function (string) {
  var k = this.getKey()
  try {
    var lt = ''
    var ct = ''
    // RSA每次加密117bytes，需要辅助方法判断字符串截取位置
    // 1.获取字符串截取点
    var bytes = new Array()
    bytes.push(0)
    var byteNo = 0
    var len, c
    len = string.length
    var temp = 0
    for (var i = 0; i < len; i++) {
      c = string.charCodeAt(i)
      if (c >= 0x010000 && c <= 0x10FFFF) {
        byteNo += 4
      } else if (c >= 0x000800 && c <= 0x00FFFF) {
        byteNo += 3
      } else if (c >= 0x000080 && c <= 0x0007FF) {
        byteNo += 2
      } else {
        byteNo += 1
      }
      if ((byteNo % 117) >= 114 || (byteNo % 117) == 0) {
        if (byteNo - temp >= 114) {
          bytes.push(i)
          temp = byteNo
        }
      }
    }
    // 2.截取字符串并分段加密
    if (bytes.length > 1) {
      for (var i = 0; i < bytes.length - 1; i++) {
        var str
        if (i == 0) {
          str = string.substring(0, bytes[i + 1] + 1)
        } else {
          str = string.substring(bytes[i] + 1, bytes[i + 1] + 1)
        }
        var t1 = k.encrypt(str)
        ct += t1
      }

      if (bytes[bytes.length - 1] != string.length - 1) {
        var lastStr = string.substring(bytes[bytes.length - 1] + 1)
        ct += k.encrypt(lastStr)
      }
      // return hexToBytes(ct)
      return hex2b64(ct)
    }
    var t = k.encrypt(string)
    // var y = hexToBytes(t)
    var y = hex2b64(t)
    return y
  } catch (ex) {
    return false
  }
}

function strtohex(code) {
  var hexstr = []
  for (var i = 0; i < code.length; i++) {
    hexstr += code.charCodeAt(i).toString(16)
  }
  return hexstr
}

JSEncrypt.prototype.decryptLong2 = function (string) {
  var k = this.getKey()
  // var maxLength = ((k.n.bitLength()+7)>>3);
  var MAX_DECRYPT_BLOCK = 128
  try {
    var ct = ''
    var t1
    var bufTmp
    var hexTmp
    // var str = bytesToHex(string)
    var str = b64tohex(string)
    var buf = hexToBytes(str)
    var inputLen = buf.length
    // 开始长度
    var offSet = 0
    // 结束长度
    var endOffSet = MAX_DECRYPT_BLOCK

    // 分段解密
    while (inputLen - offSet > 0) {
      if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
        bufTmp = buf.slice(offSet, endOffSet)
        hexTmp = bytesToHex(bufTmp)
        t1 = k.decrypt(hexTmp)
        ct += t1
      } else {
        bufTmp = buf.slice(offSet, inputLen)
        hexTmp = bytesToHex(bufTmp)
        t1 = k.decrypt(hexTmp)
        ct += t1
      }
      offSet += MAX_DECRYPT_BLOCK
      endOffSet += MAX_DECRYPT_BLOCK
    }
    return ct
  } catch (ex) {
    return false
  }
}

// 加密
function encrypt(txt) {
  txt = encodeURIComponent(txt)
  const encryptor = new JSEncrypt()
  encryptor.setPublicKey(publicKey) // 设置公钥
  let s = encryptor.encryptLong2(txt)
  console.log('加密前:' + txt + '\n加密后:' + s)
  return s
}

// 解密
function decrypt(txt) {
  const decryptor = new JSEncrypt()
  decryptor.setPrivateKey(privateKey)
  let s = decryptor.decryptLong2(txt)
  s = decodeURIComponent(s)
  console.log('解密前:' + txt + '\n解密后:' + s)
  return s
}


var text = JSON.parse(request.request_bodys)
for (var key in text) {
  apt.removeRequestBody(key);
}
console.log(request.request_bodys)
text = encrypt(request.request_bodys)
console.log(text)
apt.setRequestBody("data", text);

image-20230203003632368

image-20230202233144322

RSA

package com.bezkoder.szswzg.commons.utils;

import cn.hutool.core.net.URLDecoder;
import cn.hutool.core.net.URLEncoder;
import cn.hutool.core.util.StrUtil;
import com.bezkoder.szswzg.commons.XStringUtils;
import org.apache.commons.codec.binary.Base64;
import org.springframework.stereotype.Component;

import javax.crypto.Cipher;
import java.io.ByteArrayOutputStream;
import java.nio.charset.StandardCharsets;
import java.security.KeyFactory;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

@Component
public class RsaNewUtils {

    private static URLEncoder urlEncoder = new URLEncoder();

    static {
        //====================这些字符不会进行替换操作 减少带宽的消耗操作
        // 前端传进来的数据先进行 encode 加密 防止中文传输的问题在进行rsa(或aes)加密操作
        // 后端则是先进行 rsa(或aes)解密在进行 decode操作  这样中文就可以正常传输  防止带宽的消耗操作(下面定义的这些特殊字符是为了防止  解密数量变多的问题)===============================
        //匹配 js encodeURIComponent() 函数
        urlEncoder.addSafeCharacter('{');
        urlEncoder.addSafeCharacter('}');
        urlEncoder.addSafeCharacter('"');
        urlEncoder.addSafeCharacter('[');
        urlEncoder.addSafeCharacter(']');
        urlEncoder.addSafeCharacter('-');
        urlEncoder.addSafeCharacter('.');
        urlEncoder.addSafeCharacter('_');
        urlEncoder.addSafeCharacter('~');
        urlEncoder.addSafeCharacter('!');
        urlEncoder.addSafeCharacter('$');
        urlEncoder.addSafeCharacter('&');
        urlEncoder.addSafeCharacter('\'');
        urlEncoder.addSafeCharacter('(');
        urlEncoder.addSafeCharacter(')');
        urlEncoder.addSafeCharacter('*');
        urlEncoder.addSafeCharacter(',');
        urlEncoder.addSafeCharacter(';');
        urlEncoder.addSafeCharacter('=');
        urlEncoder.addSafeCharacter('@');
        urlEncoder.addSafeCharacter('/');
    }

    /**
     * RSA最大加密明文大小 1024/8-11
     */
    private static final int MAX_ENCRYPT_BLOCK = 117;

    /**
     * RSA最大解密密文大小 1024/8
     */
    private static final int MAX_DECRYPT_BLOCK = 128;

    /**
     * 定义加密方式
     */
    public static final String KEY_RSA = "RSA";


    private static String PUBLIC_KEY = "公钥";
    private static String PRIVATE_KEY = "私钥";


    //私钥解密
    private static Cipher Decipher = GetCipher(Cipher.DECRYPT_MODE, null, PRIVATE_KEY);
    //公钥加密
    private static Cipher Encipher = GetCipher(Cipher.ENCRYPT_MODE, PUBLIC_KEY, null);


    public static Cipher GetCipher(int mothed, String publicKeyString, String privateKeyString) {
        try {
            if (StrUtil.isBlank(publicKeyString)) {
                byte[] privateKeyBytes = Base64.decodeBase64(privateKeyString);
                KeyFactory factory = KeyFactory.getInstance(KEY_RSA);
                PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKeyBytes);
                PrivateKey privateKey = factory.generatePrivate(keySpec);
                Cipher cipher = Cipher.getInstance(factory.getAlgorithm());
                cipher.init(mothed, privateKey);
                return cipher;
            } else {
                byte[] publicKeyBytes = Base64.decodeBase64(publicKeyString);
                KeyFactory factory = KeyFactory.getInstance(KEY_RSA);
                X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKeyBytes);
                PublicKey publicKey = factory.generatePublic(keySpec);
                Cipher cipher = Cipher.getInstance(factory.getAlgorithm());
                cipher.init(mothed, publicKey);
                return cipher;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 公钥加密  如果大于117则分段加密
     */
    public static String encryptByPublic(String publicKeyStr, String encryptingStr) {
        try {
            if (XStringUtils.isNotEmpty(encryptingStr)) {//不为空
                // 避免中文乱码,前后端都要使用URL加解密中文
                encryptingStr = urlEncoder.encode(encryptingStr, StandardCharsets.UTF_8);
                byte[] data = encryptingStr.getBytes(StandardCharsets.UTF_8);
                int inputLen = data.length;
                ByteArrayOutputStream out = new ByteArrayOutputStream();
                int offSet = 0;
                byte[] cache;
                int i = 0;
                // 对数据分段加密
                synchronized (Encipher) {
                    while (inputLen - offSet > 0) {
                        if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                            cache = Encipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
                        } else {
                            cache = Encipher.doFinal(data, offSet, inputLen - offSet);
                        }
                        out.write(cache, 0, cache.length);
                        i++;
                        offSet = i * MAX_ENCRYPT_BLOCK;
                    }
                }
                byte[] encryptedData = out.toByteArray();
                out.close();
                return Base64.encodeBase64String(encryptedData);
            }
            return encryptingStr;
        } catch (Exception e) {
            e.printStackTrace();
        }

        return null;
    }


    /**
     * 私钥解密 如果大于128则分段解密
     */
    public static String decryptByPrivate(String privateKeyStr, String encryptedStr) {
        try {
            byte[] data = Base64.decodeBase64(encryptedStr);
            int inputLen = data.length;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int offSet = 0;
            byte[] cache;
            int i = 0;
            synchronized (Decipher) {
                // 对数据分段解密
                while (inputLen - offSet > 0) {
                    if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                        cache = Decipher.doFinal(data, offSet, MAX_DECRYPT_BLOCK);
                    } else {
                        cache = Decipher.doFinal(data, offSet, inputLen - offSet);
                    }
                    out.write(cache, 0, cache.length);
                    i++;
                    offSet = i * MAX_DECRYPT_BLOCK;
                }
            }
            byte[] decryptedData = out.toByteArray();
            out.close();
            // 避免中文乱码,前后端都要使用URL加解密中文
            return URLDecoder.decode(new String(decryptedData, StandardCharsets.UTF_8), StandardCharsets.UTF_8);
        } catch (Exception e) {
            e.printStackTrace();
        }

        return null;
    }
}

AES

package com.bezkoder.szswzg.commons.utils;

import cn.hutool.crypto.SecureUtil;
import com.bezkoder.szswzg.commons.XStringUtils;
import org.apache.commons.codec.binary.Base64;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.springframework.stereotype.Component;

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.Security;

/**
 * @author QL
 * @date 2023/02/02 002 23:34
 */
@Component
public class AesUtils {

    // AES_128/CBC/PKCS7Padding
    private static final String ALGORITHM = "AES/CBC/PKCS7Padding";
    private static final String KEY = SecureUtil.md5("xmmkchy").substring(5, 21);
    private static final String IV = SecureUtil.md5(KEY).substring(5, 21);
    private static Cipher Encipher = getCipherByType(Cipher.ENCRYPT_MODE);
    private static Cipher DeCipher = getCipherByType(Cipher.DECRYPT_MODE);

    private static Cipher getCipherByType(int CipherType) {
        try {
            Cipher cipher = Cipher.getInstance(ALGORITHM,new BouncyCastleProvider());
            SecretKey secretKey = new SecretKeySpec(KEY.getBytes(), "AES");
            IvParameterSpec ivParameterSpec = new IvParameterSpec(IV.getBytes());
//            System.out.println("KEY:" + KEY + " IV:" + IV);
            cipher.init(CipherType, secretKey, ivParameterSpec);
            return cipher;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public static String Encrypt(String text) {
        try {
            if(XStringUtils.isNotEmpty(text)){
                synchronized (Encipher) {
                    return Base64.encodeBase64String(Encipher.doFinal(text.getBytes(StandardCharsets.UTF_8)));
                }
            }
            return null;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public static String Decrypt(String text) {
        try {
            if(XStringUtils.isNotEmpty(text)){
                synchronized (DeCipher){
                    return new String(DeCipher.doFinal(Base64.decodeBase64(text)), StandardCharsets.UTF_8);
                }
            }
            return null;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}


@Component
静态单例注入

https://www.cnblogs.com/WriteOnce/p/14954460.html

java.lang.SecurityException: JCE cannot authenticate the provider BC
Caused by: java.util.jar.JarException: file:/C:/Program%20Files/Java/jdk1.8.0_20/jre/lib/ext/bcprov-jdk18on-1.71.1.jar is not signed by a trusted signer.
java.lang.SecurityException: JCE cannot authenticate the provider BC

但是因为bouncycastle包有签名 maven的解包操作导致了签名失效 从而无法再使用。而本地的jre环境也没有这个jar包 就导致了JCE无法验证。

%JAVA_HOME%\jre\lib\security\java.security
数字按需递增
security.provider.11=org.bouncycastle.jce.provider.BouncyCastleProvider

复制 官网下载的   https://repo1.maven.org/maven2/org/bouncycastle/bcprov-jdk18on/
https://repo1.maven.org/maven2/org/bouncycastle/bcprov-jdk18on/1.71.1/bcprov-jdk18on-1.71.1.jar
到        %JAVA_HOME%\jre\lib\ext

http://openlayers.vip/examples/csdn/Openlayers-feature.html

https://openlayers.org/en/latest/apidoc/module-ol_format_WKB-WKB.html

jbntbhpk/findListByCondition 返回数据转 jbntbhpk/findByCondition 返回数据

//jbntbhpk/findListByCondition
{
    "type": "FeatureCollection",
    "features": [
        {
            "type": "Feature",
            "geometry": {
                "type": "MultiPolygon",
                "crs": {
                    "type": "name",
                    "properties": {
                        "name": "EPSG:4527"
                    }
                },
                "coordinates": []
            },
            "properties": {
                "gid": "3",
                "objectid": "92",
                "bsm": "92",
                "ysdm": "200",
                "bhpkbh": "0120001",
                "bhpkmj": "7300000",
                "jbntmj": "8100000",
                "gdmj": "8100000",
                "szfw": "北至溪流",
                "zldjdm": "09",
                "bhkssj": 1000,
                "bhjssj": 1000,
                "bz": null,
                "shapeLeng": "45921993",
                "shapeArea": "6405735",
                "deleteKey": null,
                "dzbspId": "2",
                "wgId": "2"
            }
        }
    ],
    "totalFeatures": 5,
    "crs": {
        "type": "name",
        "properties": {
            "name": "urn:ogc:def:crs:EPSG::4527"
        }
    }
}



//jbntbhpk/findByCondition
[
    {
        "type": "Feature",
        "geometry": {
            "type": "MultiPolygon",
            "coordinates": []
        },
        "properties": {
            "gid": "3",
            "objectid": "92",
            "bsm": "92",
            "ysdm": "200",
            "bhpkbh": "0120001",
            "bhpkmj": "7300000",
            "jbntmj": "8100000",
            "gdmj": "8100000",
            "szfw": "北至溪流",
            "zldjdm": "09",
            "bhkssj": 1000,
            "bhjssj": 1000,
            "bz": null,
            "shapeLeng": "45921993",
            "shapeArea": "6405735",
            "deleteKey": null,
            "dzbspId": "2",
            "wgId": "2"
        }
    }
]

//接口返回改造
run() {
    axios.post("/api/jbntbhpk/findListByCondition", {
        "bhpkbh": "",
        "gid": "",
        "x": "",
        "y": "",
        "geomStr": "",
        "code": "",
        "dzbspId": "",
        "wgId": "3"
    }).then(res => {
        let data = res.data.data;
        let featurelist = []
        data.forEach(item => {
            let geom = item.geom
            delete item.geom
            featurelist.push(this.HexWKB2GeoJson(geom, item))
        })
        // console.log(featurelist);
        let datalist = {
            "type": "FeatureCollection",
            "features": featurelist,
            "crs": {
                "type": "name",
                "properties": {
                    "name": "urn:ogc:def:crs:EPSG::4527"
                }
            },
            "totalFeatures": featurelist.length,
        }
        console.log(JSON.stringify(datalist));
    })
},

//hex的geom数据解成geojson
HexWKB2GeoJson(coordinate, properties) {
    if (coordinate == null || coordinate == undefined || coordinate == '') {
        return {}
    }
    // console.log(coordinate,properties)
    // 读入hex_wkb
    let featureTemp = new ol.format.WKB().readFeature(coordinate)
    // wkb_feature转GeoJSON
    let geoJSON = new ol.format.GeoJSON().writeFeature(featureTemp);
    let geo_json = JSON.parse(geoJSON)
    geo_json.properties = properties
    console.log(geo_json);
    return geo_json
}

//geojson到hex数据
GeoJson2HexWKB(geoJson) {
    if (geoJson == null || geoJson == undefined || geoJson == '') {
        return {}
    }
    // 读入geoJSON文本
    let geoJSON = new ol.format.GeoJSON().readFeature(geoJson);
    // 转为hex_wkb文本
    let wkb = new ol.format.WKB({
        hex: true,
        ewkb: true
    }).writeFeature(geoJSON)
    return wkb
}

关闭 ESLint 格式化

//vue.config.js
module.exports = defineConfig({
    lintOnSave: false,
})