• JAVA-WEB项目中，前后台结合AES和RSA对数据加密处理

    实际项目中为了系统安全，我们经常需要对请求数据和响应数据做加密处理，这里以spring后台，vue前台的java web为例，记录一个实现过程

    一、为什么要结合AES和RSA？

    因为AES是对称加密，即加密解密用的秘钥是一样，这样一来AES的秘钥保管尤其重要，但是AES有个很好的优点，就是处理效率高。而RSA是不对称加密，即加密解密用的秘钥不一样，分别叫公钥和私钥，通常用公钥加密，然后用私钥解密，其中公钥可以公开，只需要保管好私钥即可，而相比AES而言RSA速度慢效率低。所以，通常我们结合这两种加密方式的优点来完成数据的安全传输。

    二、AES和RSA的结合使用过程

    1.前端随机动态生成aesKey：因为AES的加密解密秘钥需要一致，如果整个系统写死AES的秘钥会很不安全，所以每次请求动态生成aesKey会比较好

    2.前端用RSA对动态aesKey加密：动态aesKey需要传到后端供解密，传输过程用RSA加密

    3.前端保存动态aesKey：因为同一个请求的响应需要一样的aesKey解密，所以前端还得把动态aesKey保存下来，可以再随机生成一个id，然后按键值对的方式保存在前端变量中{id: aesKey}

    4.把加密的aesKey和id放到请求头

    5.后端用RSA私钥解密得明文aesKey：后端从请求头取出加密的aesKey，然后用私钥解密拿到明文的aesKey，然后对请求数据解密

    6.后端用明文aesKey加密响应数据

    7.后端把请求过来的id放到响应头

    8.前端根据响应头的id，取到对应的aesKey，对响应数据解密

    9.前端删除动态的aesKey

    三、具体实现案例

    1.前端实现AES和RSA的公共方法

            aesUtils.js：

    1.  
    2.  const CryptoJS = require('crypto-js')
    3.  
    4.  function GetRandomNum (n) {
    5.     let chars = [
    6.       '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F',
    7.       'G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V',
    8.       'W','X','Y','Z','.','?','~','!','@','#','$','%','^','&','*']
    9.     if(n == null) {
    10.       n = 16
    11.     }
    12.     let res = ""
    13.     for(let i = 0; i < n ; i++) {
    14.       let id = Math.ceil(Math.random()*46)
    15.       res += chars[id]
    16.     }
    17.     return res
    18.  }
    19.  
    20. function GetUuid () {
    21.   let s = []
    22.   const hexDigits = '0123456789abcdef'
    23.   for (let i = 0; i < 36; i++) {
    24.     let indexStart = Math.floor(Math.random() * 0x10)
    25.     s[i] = hexDigits.substring(indexStart, indexStart+1)
    26.   }
    27.   s[14] = '4'
    28.   let indexStart = (s[19] & 0x3) | 0x8
    29.   s[19] = hexDigits.substring(indexStart, indexStart+1)
    30.   s[8] = s[13] = s[18] = s[23] = '-'
    31.   return s.join('')
    32. }
    33.  
    34. function Decrypt (word, key, iv) {
    35.   let key = CryptoJS.enc.Utf8.parse(key)
    36.   let base64 = CryptoJS.enc.Base64.parse(word)
    37.   let src = CryptoJS.enc.Base64.stringify(base64)
    38.   var decrypt = CryptoJS.AES.decrypt(src, key, { iv: iv, mode: CryptoJS.mode.CBC, padding: CryptoJS.pad.ZeroPadding })
    39.   var decryptedStr = decrypt.toString(CryptoJS.enc.Utf8)
    40.   return decryptedStr.toString()
    41. }
    42.  
    43. function Encrypt (word, key, iv) {
    44.   let key = CryptoJS.enc.Utf8.parse(key)
    45.   let src = CryptoJS.enc.Utf8.parse(word)
    46.   var encrypted = CryptoJS.AES.encrypt(src, key, { iv: iv, mode: CryptoJS.mode.CBC, padding: CryptoJS.pad.ZeroPadding })
    47.   return CryptoJS.enc.Base64.stringify(encrypted.ciphertext)
    48. }
    49.  
    50. export default {
    51.   Decrypt,
    52.   Encrypt,
    53.   GetRandomNum,
    54.   GetUuid,
    55. }

            rsaUtils.js：

    1. import JSEncrypt from 'jsencrypt'
    2.  
    3. const pubKey = `MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAMYWwlqtkWIdA0I/54TP/k1VLgyNwzQB1IvrVKdNfobivHzN02VFGAED1hDSLDiSp4yYrFcXmMFReJJOJ1zjvWECAwEAAQ==`
    4.  
    5. const encrypt = new JSEncrypt()
    6. encrypt.setPublicKey(pubKey)
    7.  
    8. function Encrypt(str) {
    9. 	let data = encrypt.encrypt(str.toString())
    10. 	return data
    11. }
    12.  
    13. function Decrypt(str) {
    14. 	let data = encrypt.decrypt(str.toString())
    15. 	return data
    16. }
    17.  
    18. export default {
    19.   Encrypt,
    20.   Decrypt,
    21. }

     2.前端在拦截请求处，生成AES随机秘钥并加密请求数据，再用RSA加密AES秘钥并放到请求头
            fetch.js：

    1. const aesKeys = {}
    2.  
    3. instance.interceptors.request.use(function(request) {
    4. 	let randomKey = aes.GetRandomNum()
    5.  
    6. 	let reqData
    7. 	if (request.data instanceof Object) {
    8. 		reqData = JSON.stringify(request.data)
    9. 	} else {
    10. 		reqData = request.data
    11. 	}
    12.  
    13. 	request.data = aes.Encrypt(reqData, randomKey, randomKey)
    14.  
    15. 	let uuid = aes.GetUuid()
    16. 	let encryptAesKey = rsa.Encrypt(randomKey)
    17. 	request.headers['EncryptAesKey'] = encryptAesKey
    18. 	request.headers['uuid'] = uuid
    19.  
    20. 	aesKeys[uuid] = randomKey
    21.  
    22. 	return request
    23. }, function(err) {
    24. 	Message({
    25. 		message: err,
    26. 		type: 'error'
    27. 	})
    28. 	return Promise.reject(err)
    29. })
    30.  
    31. instance.interceptors.response.use(function(response) {
    32. 	try {
    33. 		let uuid = response.headers['uuid']
    34.  
    35. 		let aesKey = aesKeys[uuid]
    36.  
    37. 		delete aesKeys[uuid]
    38.  
    39. 		return JSON.parse(aes.Decrypt(response.data, aesKey, aesKey))
    40. 	} catch (e) {
    41. 		return response.data
    42. 	}
    43. }, function(err) {
    44. 	Message({
    45. 		message: err,
    46. 		type: 'error'
    47. 	})
    48. 	return Promise.reject(err)
    49. })

    3.后端实现AES和RSA的公共方法
            AesUtils.java：

    1. import javax.crypto.Cipher;
    2. import javax.crypto.spec.IvParameterSpec;
    3. import javax.crypto.spec.SecretKeySpec;
    4.  
    5. import org.apache.commons.codec.binary.Base64;
    6.  
    7. public class AesUtil {
    8.     
    9.     public static String encrypt(String data, String key, String iv) throws Exception {
    10.         try {
    11.  
    12.             Cipher cipher = Cipher.getInstance("AES/CBC/NoPadding");
    13.             int blockSize = cipher.getBlockSize();
    14.             byte[] dataBytes = data.getBytes();
    15.             int plaintextLength = dataBytes.length;
    16.             if (plaintextLength % blockSize != 0) {
    17.                 plaintextLength = plaintextLength + (blockSize - (plaintextLength % blockSize));
    18.             }
    19.             byte[] plaintext = new byte[plaintextLength];
    20.             System.arraycopy(dataBytes, 0, plaintext, 0, dataBytes.length);
    21.             SecretKeySpec keyspec = new SecretKeySpec(key.getBytes(), "AES");
    22.             IvParameterSpec ivspec = new IvParameterSpec(iv.getBytes());
    23.             cipher.init(Cipher.ENCRYPT_MODE, keyspec, ivspec);
    24.             byte[] encrypted = cipher.doFinal(plaintext);
    25.             return new Base64().encodeToString(encrypted);
    26.  
    27.         } catch (Exception e) {
    28.             e.printStackTrace();
    29.             return null;
    30.         }
    31.     }
    32.     
    33.     public static String desEncrypt(String data, String key, String iv) throws Exception {
    34.         try {
    35.             byte[] encrypted1 = new Base64().decode(data);
    36.             Cipher cipher = Cipher.getInstance("AES/CBC/NoPadding");
    37.             SecretKeySpec keyspec = new SecretKeySpec(key.getBytes(), "AES");
    38.             IvParameterSpec ivspec = new IvParameterSpec(iv.getBytes());
    39.             cipher.init(Cipher.DECRYPT_MODE, keyspec, ivspec);
    40.             byte[] original = cipher.doFinal(encrypted1);
    41.             String originalString = new String(original);
    42.             return originalString.trim();
    43.         } catch (Exception e) {
    44.             e.printStackTrace();
    45.             return null;
    46.         }
    47.     }
    48.  
    49.     public static String encryptWithKey(String data, String key) throws Exception {
    50.         return encrypt(data, key, key);
    51.     }
    52.  
    53.     public static String desEncryptWithKey(String data, String key) throws Exception {
    54.         return desEncrypt(data, key, key);
    55.     }
    56.  
    57. }

            RsaUtils.java：

    1. import java.security.KeyFactory;
    2. import java.security.KeyPair;
    3. import java.security.KeyPairGenerator;
    4. import java.security.NoSuchAlgorithmException;
    5. import java.security.PrivateKey;
    6. import java.security.PublicKey;
    7. import java.security.SecureRandom;
    8. import java.security.spec.InvalidKeySpecException;
    9. import java.security.spec.PKCS8EncodedKeySpec;
    10. import java.security.interfaces.RSAPrivateKey;
    11. import java.security.interfaces.RSAPublicKey;
    12. import java.security.spec.X509EncodedKeySpec;
    13. import java.util.Base64;
    14. import java.util.HashMap;
    15. import java.util.Map;
    16. import java.util.UUID;
    17. import org.bouncycastle.asn1.ASN1Encodable;
    18. import org.bouncycastle.asn1.ASN1Primitive;
    19. import org.bouncycastle.asn1.pkcs.PrivateKeyInfo;
    20. import org.bouncycastle.asn1.x509.SubjectPublicKeyInfo;
    21. import org.springframework.util.Base64Utils;
    22.  
    23. import javax.crypto.Cipher;
    24.  
    25. public class RSAUtils {
    26.     
    27.     /** 算法名称 */
    28.     private static final String     ALGORITHM        = "RSA";
    29.     /** 默认密钥大小 */
    30.     private static final int        KEY_SIZE         = 4096;
    31.     /** 密钥对生成器 */
    32.     private static KeyPairGenerator keyPairGenerator = null;
    33.     
    34.     private static KeyFactory       keyFactory       = null;
    35.     /** 缓存的密钥对 */
    36.     private static KeyPair          keyPair          = null;
    37.     
    38.     /** Base64 编码/解码器 JDK1.8 */
    39.     private static Base64.Decoder   decoder          = Base64.getDecoder();
    40.     private static Base64.Encoder   encoder          = Base64.getEncoder();
    41.  
    42.     private static final String PRI_KEY = "MIIBVQIBADANBgkqhkiG9w0BAQEFAASCAT8wggE7AgEAAkEAxhbCWq2RYh0DQj/nhM/+TVUuDI3DNAHUi+tUp01+huK8fM3TZUUYAQPWENIsOJKnjJisVxeYwVF4kk4nXOO9YQIDAQABAkEArOrHJBLpm0UKSDWyq2xJaEZYGVtSsD58xNtcHWN3dNRFWLZWZ9+D31OT0yE0T+dUhBVQFzHh3uDPd3Ax4STIwQIhAOPcBuFP4hoLcCPGvnvl+Co79XRKVkFtlduimiMzxg65AiEA3o2CjUz6TN51P8Q/kkPLHZHj4kB3ZPjNLNdKQusfj+kCIDe6z9/5psZR99p4OIybIYhK4+zOZaxY/ica7PIhLpbZAiEAupudZC2vktTVK2q6g0IlBd5WXlf/xMJ6B6ddtU7BYEECIEzbfR1Ac5zTrxTQ5icmD/ZRChgfhdxToGa21SQscW+K";
    43.  
    44.     public static final String PEM_CODE_PUB = "MEEwDQYJKoZIhvcNAQEBBQADMAAwLQImDr5/bK6tmdEMYTJXsD/AXIOwE2a9/bfkPvtWUR7vzkvB33tPcEsCAwEAAQ==";
    45.  
    46.     public static final String PEM_CODE_PRI = "";
    47.  
    48.     /** 初始化密钥工厂 */
    49.     static {
    50.         try {
    51.             keyPairGenerator = KeyPairGenerator.getInstance(ALGORITHM);
    52.             keyFactory = KeyFactory.getInstance(ALGORITHM);
    53.         } catch (NoSuchAlgorithmException e) {
    54.             e.printStackTrace();
    55.         }
    56.     }
    57.     
    58.     private RSAUtils() {
    59.     }
    60.     
    61.     public static synchronized Map generateKeyPair() {
    62.         try {
    63.             keyPairGenerator.initialize(KEY_SIZE,
    64.                 new SecureRandom(UUID.randomUUID().toString().replaceAll("-", "").getBytes()));
    65.             keyPair = keyPairGenerator.generateKeyPair();
    66.         } catch (Exception e) {
    67.             e.printStackTrace();
    68.         }
    69.         RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
    70.         RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();
    71.         String publicKeyString = encoder.encodeToString(rsaPublicKey.getEncoded());
    72.         String privateKeyString = encoder.encodeToString(rsaPrivateKey.getEncoded());
    73.         Map keyPairMap = new HashMap();
    74.         keyPairMap.put("public", publicKeyString);
    75.         keyPairMap.put("private", privateKeyString);
    76.         return keyPairMap;
    77.     }
    78.     
    79.     public static synchronized Map generatePKS1KeyPair() {
    80.         Map keyPairMap = new HashMap();
    81.         try {
    82.             keyPairGenerator.initialize(KEY_SIZE,
    83.                 new SecureRandom(UUID.randomUUID().toString().replaceAll("-", "").getBytes()));
    84.             keyPair = keyPairGenerator.generateKeyPair();
    85.             PublicKey pub = keyPair.getPublic();
    86.             byte[] pubBytes = pub.getEncoded();
    87.             SubjectPublicKeyInfo spkInfo = SubjectPublicKeyInfo.getInstance(pubBytes);
    88.             ASN1Primitive pubprimitive = spkInfo.parsePublicKey();
    89.             byte[] publicKeyPKCS1 = pubprimitive.getEncoded();
    90.             System.out.println(publicKeyPKCS1.toString());
    91.             
    92.             PrivateKey priv = keyPair.getPrivate();
    93.             byte[] privBytes = priv.getEncoded();
    94.             PrivateKeyInfo pkInfo = PrivateKeyInfo.getInstance(privBytes);
    95.             ASN1Encodable encodable = pkInfo.parsePrivateKey();
    96.             ASN1Primitive priprimitive = encodable.toASN1Primitive();
    97.             byte[] privateKeyPKCS1 = priprimitive.getEncoded();
    98.             System.out.println(privateKeyPKCS1.toString());
    99.           
    100.             keyPairMap.put("public", publicKeyPKCS1);
    101.             keyPairMap.put("private", privateKeyPKCS1.toString());
    102.         
    103.         } catch (Exception e) {
    104.             e.printStackTrace();
    105.         }
    106.         return keyPairMap;
    107.     }
    108.     
    109.     public static PublicKey getPublicKey(String pubKey) {
    110.         try {
    111.             byte[] keyBytes = decoder.decode(pubKey);
    112.             X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(keyBytes);
    113.             return keyFactory.generatePublic(x509EncodedKeySpec);
    114.         } catch (InvalidKeySpecException e) {
    115.             e.printStackTrace();
    116.         }
    117.         return null;
    118.     }
    119.     
    120.     public static PrivateKey getPrivateKey(String priKey) {
    121.         try {
    122.             byte[] keyBytes = decoder.decode(priKey);
    123.             PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(keyBytes);
    124.             return (java.security.interfaces.RSAPrivateKey) keyFactory
    125.                 .generatePrivate(pkcs8EncodedKeySpec);
    126.         } catch (InvalidKeySpecException e) {
    127.             e.printStackTrace();
    128.         }
    129.         return null;
    130.     }
    131.     
    132.     public static String encryptByPublic(byte[] content, PublicKey publicKey) {
    133.         if (publicKey == null) {
    134.             publicKey = (PublicKey) getPublicKey(PEM_CODE_PUB);
    135.         }
    136.         try {
    137.             Cipher cipher = Cipher.getInstance("RSA");
    138.             cipher.init(Cipher.ENCRYPT_MODE, publicKey);
    139.             //该密钥能够加密的最大字节长度
    140.             int splitLength = ((RSAPublicKey) publicKey).getModulus().bitLength() / 8 - 11;
    141.             byte[][] arrays = splitBytes(content, splitLength);
    142.             StringBuffer stringBuffer = new StringBuffer();
    143.             for (byte[] array : arrays) {
    144.                 stringBuffer.append(Base64Utils.encodeToString(cipher.doFinal(array)));
    145.             }
    146.             return stringBuffer.toString();
    147.         } catch (Exception e) {
    148.             e.printStackTrace();
    149.         }
    150.         return null;
    151.     }
    152.  
    153.     public static String encryptByPrivate(byte[] content, PrivateKey privateKey) {
    154.         if (privateKey == null) {
    155.             privateKey = (PrivateKey) getPrivateKey(PEM_CODE_PRI);
    156.         }
    157.         try {
    158.             Cipher cipher = Cipher.getInstance("RSA");
    159.             cipher.init(Cipher.ENCRYPT_MODE, privateKey);
    160.             //该密钥能够加密的最大字节长度
    161.             int splitLength = ((RSAPrivateKey) privateKey).getModulus().bitLength() / 8 - 11;
    162.             byte[][] arrays = splitBytes(content, splitLength);
    163.             StringBuffer stringBuffer = new StringBuffer();
    164.             for (byte[] array : arrays) {
    165.                 stringBuffer.append(Base64Utils.encodeToString(cipher.doFinal(array)));
    166.             }
    167.             return stringBuffer.toString();
    168.         } catch (Exception e) {
    169.             e.printStackTrace();
    170.         }
    171.         return null;
    172.     }
    173.  
    174.     public static String decryptByPrivate(String content, PrivateKey privateKey) {
    175.         if (privateKey == null) {
    176.             privateKey = (PrivateKey) getPrivateKey(PEM_CODE_PRI);
    177.         }
    178.         try {
    179.             Cipher cipher = Cipher.getInstance("RSA");
    180.             cipher.init(Cipher.DECRYPT_MODE, privateKey);
    181.             //该密钥能够加密的最大字节长度
    182.             int splitLength = ((RSAPrivateKey) privateKey).getModulus().bitLength() / 8;
    183.             byte[] contentBytes = Base64Utils.decodeFromString(content);
    184.             byte[][] arrays = splitBytes(contentBytes, splitLength);
    185.             StringBuffer stringBuffer = new StringBuffer();
    186.             for (byte[] array : arrays) {
    187.                 stringBuffer.append(new String(cipher.doFinal(array)));
    188.             }
    189.             return stringBuffer.toString();
    190.         } catch (Exception e) {
    191.             e.printStackTrace();
    192.         }
    193.         return null;
    194.     }
    195.     
    196.     public static byte[][] splitBytes(byte[] bytes, int splitLength) {
    197.         //bytes与splitLength的余数
    198.         int remainder = bytes.length % splitLength;
    199.         //数据拆分后的组数，余数不为0时加1
    200.         int quotient = remainder != 0 ? bytes.length / splitLength + 1
    201.             : bytes.length / splitLength;
    202.         byte[][] arrays = new byte[quotient][];
    203.         byte[] array = null;
    204.         for (int i = 0; i < quotient; i++) {
    205.             //如果是最后一组（quotient-1）,同时余数不等于0，就将最后一组设置为remainder的长度
    206.             if (i == quotient - 1 && remainder != 0) {
    207.                 array = new byte[remainder];
    208.                 System.arraycopy(bytes, i * splitLength, array, 0, remainder);
    209.             } else {
    210.                 array = new byte[splitLength];
    211.                 System.arraycopy(bytes, i * splitLength, array, 0, splitLength);
    212.             }
    213.             arrays[i] = array;
    214.         }
    215.         return arrays;
    216.     }
    217.  
    218. }

    4.后端重写HttpServletRequestWrapper中的getInputStream()，解密拿到请求的明文

    1. import org.apache.commons.lang3.StringUtils;
    2.  
    3. import javax.servlet.ReadListener;
    4. import javax.servlet.ServletInputStream;
    5. import javax.servlet.http.HttpServletRequest;
    6. import javax.servlet.http.HttpServletRequestWrapper;
    7. import java.io.BufferedReader;
    8. import java.io.ByteArrayInputStream;
    9. import java.io.IOException;
    10. import java.io.InputStreamReader;
    11. import java.nio.charset.StandardCharsets;
    12. import java.util.*;
    13.  
    14. public class XssRequestWrappers extends HttpServletRequestWrapper {
    15.     public XssRequestWrappers(HttpServletRequest request) {
    16.         super(request);
    17.     }
    18.  
    19.     @Override
    20.     public ServletInputStream getInputStream() throws IOException {
    21.         Map headerMap = getHeadersInfo((HttpServletRequest) super.getRequest());
    22.  
    23.         String encryptAeskey = headerMap.get("encryptaeskey");
    24.         String aesKey = RSAUtils.decryptByPrivate(encryptAeskey, RSAUtils.getPrivateKey(CommConstants.RSA.PRI_KEY));
    25.  
    26.         ServletInputStream servletInputStream = super.getInputStream();
    27.  
    28.         try {
    29.             return decryptReqData(servletInputStream, aesKey);
    30.         } catch (Exception e) {
    31.             e.printStackTrace();
    32.         }
    33.  
    34.         return servletInputStream;
    35.     }
    36.  
    37.     private ServletInputStream decryptReqData(ServletInputStream servletInputStream, String aesKey)
    38.             throws Exception {
    39.         StringBuilder jb = new StringBuilder();
    40.         String line;
    41.         BufferedReader reader = new BufferedReader(new InputStreamReader(servletInputStream));
    42.         while ((line = reader.readLine()) != null) {
    43.             jb.append(line);
    44.         }
    45.         String encryptReqData = jb.toString();
    46.  
    47.         if(StringUtils.isNotBlank(encryptReqData)) {
    48.             String reqData = AesUtil.desEncryptWithKey(encryptReqData, aesKey);
    49.             ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(reqData.getBytes(StandardCharsets.UTF_8));
    50.             return new ServletInputStream() {
    51.                 @Override
    52.                 public int read() {
    53.                     return byteArrayInputStream.read();
    54.                 }
    55.                 @Override
    56.                 public boolean isFinished() {
    57.                     return false;
    58.                 }
    59.                 @Override
    60.                 public boolean isReady() {
    61.                     return false;
    62.                 }
    63.                 @Override
    64.                 public void setReadListener(ReadListener listener) {
    65.                 }
    66.             };
    67.         }
    68.         return servletInputStream;
    69.     }
    70.  
    71.     private Map getHeadersInfo(HttpServletRequest request) {
    72.         Map map = new HashMap<>();
    73.         Enumeration headerNames = request.getHeaderNames();
    74.         Locale.setDefault(Locale.ENGLISH);
    75.         while (headerNames.hasMoreElements()) {
    76.             String key = headerNames.nextElement().toLowerCase(Locale.ENGLISH);
    77.             String value = request.getHeader(key);
    78.             map.put(key, value);
    79.         }
    80.         return map;
    81.     }
    82. }

    5.通过ResponseBodyAdvice给响应数据加密处理

    1. import org.apache.commons.lang3.StringUtils;
    2. import org.springframework.core.MethodParameter;
    3. import org.springframework.http.MediaType;
    4. import org.springframework.http.converter.HttpMessageConverter;
    5. import org.springframework.http.server.ServerHttpRequest;
    6. import org.springframework.http.server.ServerHttpResponse;
    7. import org.springframework.http.server.ServletServerHttpRequest;
    8. import org.springframework.web.bind.annotation.ControllerAdvice;
    9.  
    10. import javax.servlet.http.HttpServletRequest;
    11. import java.util.*;
    12.  
    13. @ControllerAdvice
    14. public class ResponseBodyAdvice implements org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice {
    15.  
    16.     @Override
    17.     public Object beforeBodyWrite(Object o, MethodParameter methodParameter, MediaType mediaType, Class aClass, ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {
    18.  
    19.     try {
    20.            ServletServerHttpRequest request = (ServletServerHttpRequest)serverHttpRequest;
    21.            HttpServletRequest servletRequest = request.getServletRequest();
    22.            Map headerNames = RequestUtils.getHeadersInfo(servletRequest);
    23.  
    24.            String encryptAeskey = headerNames.get("encryptaeskey");
    25.            String aesKey = RSAUtils.decryptByPrivate(encryptAeskey, RSAUtils.getPrivateKey(CommConstants.RSA.PRI_KEY));
    26.  
    27.            String uuid = headerNames.get("uuid");
    28.            serverHttpResponse.getHeaders().add("uuid", uuid);
    29.            ArrayList list = new ArrayList<>();
    30.            list.add("uuid");
    31.            serverHttpResponse.getHeaders().setAccessControlExposeHeaders(list);
    32.  
    33.            return AesUtil.encryptWithKey(String.valueOf(o), aesKey);
    34. 	   } catch (Exception e) {
    35. 		   e.printStackTrace();
    36. 	   }
    37.        return o;
    38.     }
    39.  
    40.     @Override
    41.     public boolean supports(MethodParameter returnType, Class> converterType) {
    42.         return true;
    43.     }
    44. }
      45.  


        
      
                
                    
                

                
    45. 

                    相关阅读:
      
                    
Android-＞layer-list画对号画叉号画箭头画进度条                            
      
Shell变量与赋值、变量运算、特殊变量、重定向与管渠                            
      
HTTP1.0，1.1，2.0                            
      
React（react18）中组件通信03——简单使用 Context 深层传递参数                            
      
加速度速度位移的计算                            
      
【小白学机器学习13】一文理解假设检验的反证法，H0如何设计的，什么时候用左侧检验和右侧检验，等各种关于假设检验的基础知识                            
      
异常与错误处理高级用法                            
      
Python的一个图片识别工具-PyTesseract（Win10）                            
      
跳槽有技巧？超强测试开发面试经验等你pick                            
      
用于新能源汽车三电系统测试的格雷希尔快速密封连接器的优选方案                            
      
                          
                
      46. 
                
    46. 
                    原文地址：https://blog.csdn.net/u011998957/article/details/126765592
                
      47.