RSA算法實現數據加密簽名傳輸與數據解密代碼實例(上)

1. RSA算法實現數據加解密與簽名的原理淺析：RSA算法實現數據的加解密與簽名都是經過一對非對稱的密鑰對（公鑰與私鑰）來實現的，公鑰可對外公開給其餘要傳輸數據給個人人使用，私鑰留着我本身對加密的數據進行解密時使用。公鑰一般用來加密數據，私鑰一般用來解密數據。使用私鑰簽名主要是爲了防止傳送的數據被篡改。

2. 廢話很少說，直接上代碼

 項目目錄結構：

 

 

 

RSA密鑰常量文件

package com.sxy.rsademo.rsa;

/**
 * @Description 密鑰相關常量
 * @By SuXingYong
 * @DateTime 2020/7/11 23:35
 **/
public class KeyConstant {

    /** 字符編碼  **/
    public final static String CHARACTER_ENCODING_FORMAT = "utf-8";

    /** 密鑰常量 -  密鑰採用的算法 **/
    public final static String KEY_ALGORITHM = "RSA";

    /** 密鑰常量 -  簽名算法 **/
    public final static String SIGN_ALGORITHMS = "MD5withRSA";

    /**
     * 密鑰長度，DH算法的默認密鑰長度是1024
     * 密鑰長度必須是64的倍數，在512到65536位之間
     **/
    public final static int KEY_SIZE = 1024;

    /** 最大 - 加密字節數組 - 大小 **/
    public final static int ENCRYPT_MAX_SIZE = 117;

    /** 最大 - 解密字節數組 - 大小 **/
    public final static int DECRYPT_MAX_SIZE = 128;

    /** RSA - 模式 - 01 - 加密 **/
    public final static String RSA_MODE_01 = "encrypt";

    /** RSA - 模式 - 02 - 解密 **/
    public final static String RSA_MODE_02 = "decrypt";

    /** 公鑰 **/
    public final static String PUBLIC_KEY = "public.key";

    /** 私鑰 **/
    public final static String PRIVATE_KEY = "private.key";

    /** A方 - 原文 **/
    public final static String A_ORIGINAL_TEXT = "aOriginalText";

    /** B方 - 原文 **/
    public final static String B_ORIGINAL_TEXT = "bOriginalText";

    /** A方 - 公鑰 - 密文 **/
    public final static String  A_PUBLIC_KEY_CIPHER_TEXT = "aPublicKeyCipherText";

    /** A方 - 私鑰 - 密文 **/
    public final static String A_PRIVATE_KEY_CIPHER_TEXT = "aPrivateKeyCipherText";

    /** A方 - 公鑰 - 明文 **/
    public final static String A_PUBLIC_KEY_PLAIN_TEXT = "aPublicKeyPlainText";

    /** A方 - 私鑰 - 明文 **/
    public final static String A_PRIVATE_KEY_PLAIN_TEXT = "aPrivateKeyPlainText";

    /** B方 - 公鑰 - 密文 **/
    public final static String  B_PUBLIC_KEY_CIPHER_TEXT = "bPublicKeyCipherText";

    /** B方 - 私鑰 - 密文 **/
    public final static String B_PRIVATE_KEY_CIPHER_TEXT = "bPrivateKeyCipherText";

    /** B方 - 公鑰 - 明文 **/
    public final static String B_PUBLIC_KEY_PLAIN_TEXT = "bPublicKeyPlainText";

    /** B方 - 私鑰 - 明文 **/
    public final static String B_PRIVATE_KEY_PLAIN_TEXT = "bPrivateKeyPlainText";

    /** A方 - 私鑰 - 簽名 - 原文 **/
    public final static String A_PRIVATE_KEY_SIGN_ORIGINAL_TEXT = "aPrivateKeySignOriginalText";

    /** A方 - 私鑰 - 簽名 - 密文 **/
    public final static String A_PRIVATE_KEY_SIGN_CIPHER_TEXT = "aPrivateKeySignCipherText";

    /** B方 - 私鑰 - 簽名 - 原文 **/
    public final static String B_PRIVATE_KEY_SIGN_ORIGINAL_TEXT = "bPrivateKeySignOriginalText";

    /** B方 - 私鑰 - 簽名 - 密文 **/
    public final static String B_PRIVATE_KEY_SIGN_CIPHER_TEXT = "bPrivateKeySignCipherText";

    /** 私鑰 - 簽名 - 合法性 **/
    public final static String PRIVATE_KEY_SIGN_VERIFY = "privateKeySignVerify";

    /** 公鑰文件存儲路徑 **/
    public final static String PUBLIC_KEY_FILE_ULR = "d:/upload/rsaKey/publicKey.keystore";

    /** 私鑰鑰文件存儲路徑 **/
    public final static String PRIVATE_KEY_FILE_ULR = "d:/upload/rsaKey/privateKey.keystore";

    /** 密鑰名稱和值的分隔符 **/
    public final static String KEY_AND_VALUE_SEPARATOR = "==>";

    /** 公鑰文件存儲路徑 -  鍵名 **/
    public final static String PUBLIC_KEY_FILE_SAVE_PATH = "publicKeyFile.savePath";

    /** 私鑰鑰文件存儲路徑 -  鍵名 **/
    public final static String PRIVATE_KEY_FILE_SAVE_PATH = "privateKeyFile.savePath";


}

KeyConstant.java

RSA工具類：

package com.sxy.rsademo.rsa;

import com.sxy.rsademo.utils.Base64;
import com.sxy.rsademo.utils.CastUtils;
import lombok.extern.slf4j.Slf4j;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import java.io.*;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * @Description: RSA 工具類
 * @Author: SuXingYong
 * @Date 2020/7/11 23:35
 **/
@Slf4j
public class RsaUtils extends KeyConstant {

    /************************************************* 密鑰初始化、持久化、獲取start  *************************************************/

    /**
     * @Description 初始化密鑰對
     *                返回甲方密鑰的Map
     * @Author SuXingYong
     * @Date 2020/7/11 23:35
     * @Param []
     * @Return java.util.Map<java.lang.String,java.lang.Object>
     **/
    public static Map<String,Object> initKey(){
        // 將密鑰存儲在map中
        Map<String,Object> keyMap = new HashMap<String,Object>();
        try {
            // 實例化密鑰生成器 採用RSA算法
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);
            // 初始化密鑰生成器 1024
            keyPairGenerator.initialize(KEY_SIZE);
            // 生成密鑰對
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            // 甲方公鑰
            RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
            log.info("係數："+publicKey.getModulus()+"  加密指數："+publicKey.getPublicExponent());
            // 甲方私鑰
            RSAPrivateKey privateKey=(RSAPrivateKey) keyPair.getPrivate();
            log.info("係數："+privateKey.getModulus()+"  解密指數："+privateKey.getPrivateExponent());

            // 公鑰
            keyMap.put(PUBLIC_KEY, Base64.encode(publicKey.getEncoded()));
            // 私鑰
            keyMap.put(PRIVATE_KEY,  Base64.encode(privateKey.getEncoded()));
            // 公鑰持久性文件存儲地址
            String publicKeyFileSavePath = PUBLIC_KEY_FILE_ULR;
            if (publicKeyFileSavePath != null && !publicKeyFileSavePath.equals("")){
                keyMap.put(PUBLIC_KEY_FILE_SAVE_PATH,publicKeyFileSavePath);
            }
            // 私鑰持久性文件存儲地址
            String privateKeyFileSavePath = PRIVATE_KEY_FILE_ULR;
            if (privateKeyFileSavePath != null && !privateKeyFileSavePath.equals("")){
                keyMap.put(PRIVATE_KEY_FILE_SAVE_PATH,privateKeyFileSavePath);
            }
            // 密鑰對持久化存儲
            RsaUtils.saveKeyPairToFile(keyMap);
        }catch (Exception e){
            e.printStackTrace();
            log.error(e.getMessage());
        }
        return keyMap;
    }


    /**
     * @Description 保存密鑰對 到文件中
     * @Author SuXingYong
     * @Date 2020/7/11 23:35
     * @Param [keyMap]
     * @Return void
     **/
    public static void saveKeyPairToFile(Map<String,Object> keyMap){
        try {
            // 公鑰原始字符串
            String publicKeyOriginalString = CastUtils.castString(keyMap.get(PUBLIC_KEY));
            log.info("公鑰："+publicKeyOriginalString);
            // 私鑰原始字符串
            String privateKeyOriginalString = CastUtils.castString(keyMap.get(PRIVATE_KEY));
            log.info("私鑰："+privateKeyOriginalString);
            // 須要存儲的公鑰字符串鍵值對
            StringBuilder publicKeyOutString = new StringBuilder("");
            publicKeyOutString.append(PUBLIC_KEY).append(KEY_AND_VALUE_SEPARATOR).append(publicKeyOriginalString);
            // 須要存儲的私鑰字符串鍵值對
            StringBuilder privateKeyOutString = new StringBuilder("");
            privateKeyOutString.append(PUBLIC_KEY).append(KEY_AND_VALUE_SEPARATOR).append(privateKeyOriginalString);
            // 公鑰存儲地址
            String publicKeyPath = CastUtils.castString(keyMap.get(PUBLIC_KEY_FILE_SAVE_PATH));
            File publicKeyFile = new File(publicKeyPath);
            if (!publicKeyFile.exists()){
                publicKeyFile.getParentFile().mkdirs();
            }
            log.info("公鑰存儲地址："+publicKeyPath);
            // 私鑰存儲地址
            String privateKeyPath = CastUtils.castString(keyMap.get(PRIVATE_KEY_FILE_SAVE_PATH));
            File privateKeyFile = new File(privateKeyPath);
            if (!privateKeyFile.exists()){
                privateKeyFile.getParentFile().mkdirs();
            }
            log.info("私鑰存儲地址："+privateKeyPath);
            // 將密鑰對寫入到文件
            FileWriter publicFileWriter = new FileWriter(publicKeyPath);
            FileWriter privateFileWriter = new FileWriter(privateKeyPath);
            BufferedWriter publicBufferedWriter = new BufferedWriter(publicFileWriter);
            BufferedWriter privateBufferedWriter = new BufferedWriter(privateFileWriter);
            publicBufferedWriter.write(publicKeyOutString.toString());
            privateBufferedWriter.write(privateKeyOutString.toString());
            publicBufferedWriter.flush();
            publicBufferedWriter.close();
            publicFileWriter.close();
            privateBufferedWriter.flush();
            privateBufferedWriter.close();
            privateFileWriter.close();
        }catch (Exception e){
            e.printStackTrace();
            log.error(e.getMessage());
        }
    }

    /**
     * @Description 從文件中輸入流中得到密鑰(公鑰或者私鑰[根據傳入的地址不一樣讀取不一樣的文件])字符串
     * @Author SuXingYong
     * @Date 2020/7/11 23:35
     * @Param [keyFilePath]
     * @Return java.lang.String
     **/
    public static String getKeyByFile(String keyFilePath) throws Exception {
        try {
            BufferedReader bufferedReader = new BufferedReader(new FileReader(keyFilePath));
            String readLine = null;
            StringBuilder keyOutStr = new StringBuilder();
            // 讀取文件
            while ((readLine = bufferedReader.readLine()) != null) {
                keyOutStr.append(readLine);
            }
            bufferedReader.close();
            // 密鑰字符串
            String  keyStr = "";
            if (keyOutStr.toString().indexOf(KEY_AND_VALUE_SEPARATOR) != -1){
                String[] keyOutStrArr = keyOutStr.toString().split(KEY_AND_VALUE_SEPARATOR);
                if (keyOutStrArr != null && keyOutStrArr.length >1){
                    keyStr = keyOutStrArr[1];
                }
            }
            return keyStr;
        } catch (IOException e) {
            throw new Exception("密鑰數據流讀取錯誤");
        } catch (NullPointerException e) {
            throw new Exception("密鑰輸入流爲空");
        }
    }

    /**
     * @Description 獲取持久的密鑰對(直接從密鑰文件中讀取的)
     * @Author SuXingYong
     * @Date 2020/7/11 23:35
     * @Param []
     * @Return java.util.Map<java.lang.String,java.lang.Object> 返回持久的公鑰和私鑰
     **/
    public static Map<String, Object> getLastingKeyPair() throws Exception {
        Map<String, Object> returnMap = new LinkedHashMap<>();
        // 讀取文件中的公鑰  獲取方式爲：基礎文件路徑 + 公鑰文件存儲地址
        String publicKeyFileStr = RsaUtils.getKeyByFile(PUBLIC_KEY_FILE_ULR);
        if (publicKeyFileStr != null && !publicKeyFileStr.equals("")){
            // 公鑰
            returnMap.put(PUBLIC_KEY,publicKeyFileStr);
            log.info("持久化公鑰："+publicKeyFileStr);
        }
        // 讀取文件中的私鑰 獲取方式爲：基礎文件路徑 + 私鑰文件存儲地址
        String privateKeyFileStr = RsaUtils.getKeyByFile(PRIVATE_KEY_FILE_ULR);
        if (privateKeyFileStr != null && !privateKeyFileStr.equals("")){
            // 私鑰
            returnMap.put(PRIVATE_KEY,privateKeyFileStr);
            log.info("持久化私鑰："+privateKeyFileStr);
        }
        return returnMap;
    }

    /************************************************* 密鑰初始化、持久化、獲取end  *************************************************/



    /**
     * @Description  分組加密/解密
     * @Author SuXingYong
     * @Date 2020/7/11 23:35
     * @Param [rsaMode, dataByteArr, cipher]
     * @param rsaMode RSA模式：encrypt:加密  decrypt：解密
     * @param dataByteArr 須要加密/解密的數據字節數組
     * @param cipher
     * @Return byte[] 完成加密/解密以後的字節數組
     **/
    public static byte[] groupEncryptOrDecrypt(String rsaMode,byte[] dataByteArr, Cipher cipher) throws BadPaddingException, IllegalBlockSizeException {
        // 結果數組
        byte[] returnByteArr = {};
        // 分段處理
        int dataByteArrLength = dataByteArr.length;
        log.info("數據字節數：" + dataByteArrLength);
        // 最大加密/解密字節數，超出最大字節數須要分組加密/解密
        int MAX_BLOCK = 0;
        if (rsaMode != null && !rsaMode.equals("")){
            // 加密模式
            if (RSA_MODE_01.equalsIgnoreCase(rsaMode)){
                // 117
                MAX_BLOCK = ENCRYPT_MAX_SIZE;
            }
            // 解密模式
            if (RSA_MODE_02.equalsIgnoreCase(rsaMode)){
                // 128
                MAX_BLOCK = DECRYPT_MAX_SIZE;
            }
        }
        // 標識
        int offSet = 0;
        // 緩存數組
        byte[] tempByteArr = {};
        // 判斷加密/解密字節數 - 標識 是否到達末尾
        while (dataByteArrLength - offSet > 0) {
            // 若是加密/解密字節數 - 標識 > 最大加密/解密字節數
            if (dataByteArrLength - offSet > MAX_BLOCK) {
                // 執行加密/解密  標識位 到 最大加密/解密字節數位
                tempByteArr = cipher.doFinal(dataByteArr, offSet, MAX_BLOCK);
                // 標識 = 自身 + 最大加密/解密字節數
                offSet += MAX_BLOCK;
            } else {
                // 若是加密/解密字節數 - 標識 小於等於 最大加密/解密字節數
                // 執行加密/解密  標識位 到 （加密/解密字節數 - 標誌）位
                tempByteArr = cipher.doFinal(dataByteArr, offSet, dataByteArrLength - offSet);
                // 標識 = 加密/解密字節數
                offSet = dataByteArrLength;
            }
            // 建立信息的數組 原來數組的長度  想要獲得的新數組的長度(原數組長度 + 緩存數組長度)
            returnByteArr = Arrays.copyOf(returnByteArr, returnByteArr.length + tempByteArr.length);
            // 數組複製 (源數組, 源數組要複製的起始位置, 目標數組, 目標數組放置的起始位置, 要複製的長度)
            // 將緩存數組中的數據 複製到結果數組中
            System.arraycopy(tempByteArr, 0, returnByteArr, returnByteArr.length - tempByteArr.length, tempByteArr.length);
        }
        return returnByteArr;
    }

    /************************************************* 加密start  *************************************************/

    /**
     * @Description 私鑰加密(字節數組)
     * @Author SuXingYong
     * @Date 2020/7/11 23:35
     * @Param [data, key]
     * @param data 待加密數據
     * @param key 密鑰
     * @Return byte[] 加密以後的數據
     **/
    public static byte[] encryptByPrivateKey(byte[] data,byte[] key) throws Exception{
        // 返回結果
        byte[] result = {};
        // 取得私鑰
        PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(key);
        // 實例化密鑰工廠  RSA 算法的
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        // 生成私鑰
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
        // 數據加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        // 加密模式 1
        cipher.init(Cipher.ENCRYPT_MODE, privateKey);
        // RSA模式 加密模式
        String rsaMode = RSA_MODE_01;
        // 分組加密
        byte[] returnByteArr = RsaUtils.groupEncryptOrDecrypt(rsaMode,data,cipher);
        if (returnByteArr != null && returnByteArr.length > 0){
            result = returnByteArr;
        }
        return result;
    }


    /**
     * @Description 公鑰加密(字節數組)
     * @Author SuXingYong
     * @Date 2020/7/11 23:35
     * @Param [data, key]
     * @param data 待加密的數據
     * @param key 密鑰
     * @Return byte[] 加密以後的數據
     **/
    public static byte[] encryptByPublicKey(byte[] data,byte[] key) throws Exception{
        // 返回結果
        byte[] result = {};
        // 實例化密鑰工廠 RSA 算法的
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        // 初始化公鑰
        // 密鑰材料轉換
        X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(key);
        // 產生公鑰
        PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
        // 數據加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        // 加密模式
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        // RSA模式 加密模式
        String rsaMode = RSA_MODE_01;
        // 分組加密
        byte[] returnByteArr = RsaUtils.groupEncryptOrDecrypt(rsaMode,data,cipher);
        if (returnByteArr != null && returnByteArr.length > 0){
            result = returnByteArr;
        }
        return result;
    }

    /**
     * @Description 公鑰加密(字符串)
     * @Author SuXingYong
     * @Date 2020/7/11 23:35
     * @Param [data, key]
     * @param data 待加密的數據
     * @param key 密鑰
     * @Return java.lang.String 加密以後的數據
     **/
    public static String encryptByPublicKey(String data,String key) throws Exception{
        // 返回結果
        StringBuilder result = new StringBuilder("");
        // 實例化密鑰工廠 RSA 算法的
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        // 初始化公鑰
        // 密鑰材料轉換
        X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(Base64.decode(key));
        // 產生公鑰
        PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
        // 數據加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        // 加密模式
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        // 將數據字符串轉換爲字節數組
        byte[] dataByteArr = data.getBytes();
        // RSA模式 加密模式
        String rsaMode = RSA_MODE_01;
        // 分組加密
        byte[] returnByteArr = RsaUtils.groupEncryptOrDecrypt(rsaMode,dataByteArr,cipher);
        if (returnByteArr != null && returnByteArr.length > 0){
            result.append(Base64.encode(returnByteArr));
        }
        return result.toString();
    }

    /**
     * @Description 私鑰加密(字符串)
     * @Author SuXingYong
     * @Date 2020/7/11 23:35
     * @Param [data, key]
     * @param data 待加密數據
     * @param key 密鑰
     * @Return java.lang.String 加密以後的數據
     **/
    public static String encryptByPrivateKey(String data,String key) throws Exception{
        // 返回結果
        StringBuilder result = new StringBuilder("");
        // 取得私鑰
        PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(Base64.decode(key));
        // 實例化密鑰工廠  RSA 算法的
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        // 生成私鑰
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
        // 數據加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        // 加密模式 1
        cipher.init(Cipher.ENCRYPT_MODE, privateKey);
        // 將數據字符串轉換爲字節數組
        byte[] dataByteArr = data.getBytes();
        // RSA模式 加密模式
        String rsaMode = RSA_MODE_01;
        // 分組加密
        byte[] returnByteArr = RsaUtils.groupEncryptOrDecrypt(rsaMode,dataByteArr,cipher);
        if (returnByteArr != null && returnByteArr.length > 0){
            result.append(Base64.encode(returnByteArr));
        }
        return result.toString();
    }

    /************************************************* 加密end  *************************************************/


    /************************************************* 解密start  *************************************************/

    /**
     * @Description 私鑰解密(字節數組)
     * @Author SuXingYong
     * @Date 2020/7/11 23:35
     * @Param [data, key]
     * @param data 待解密數據
     * @param key 密鑰
     * @Return byte[] 解密以後的數據
     **/
    public static byte[] decryptByPrivateKey(byte[] data,byte[] key) throws Exception{
        // 返回的結果字節數組
        byte[] resultByteArr = {};
        // 取得私鑰
        PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(key);
        // 實例化密鑰工廠 RSA算法的
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        // 生成私鑰
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
        // 數據解密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        // 解密模式
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        // RSA模式 解密模式
        String rsaMode = RSA_MODE_02;
        // 分組解密
        byte[] returnBytes = RsaUtils.groupEncryptOrDecrypt(rsaMode,data,cipher);
        if (returnBytes != null && resultByteArr.length >0){
            resultByteArr = returnBytes;
        }
        return resultByteArr;
    }

    /**
     * @Description 公鑰解密(字節數組)
     * @Author SuXingYong
     * @Date 2020/7/11 23:35
     * @Param [data, key]
     * @param data 待解密數據
     * @param key 密鑰
     * @Return byte[] 解密以後的數據
     **/
    public static byte[] decryptByPublicKey(byte[] data,byte[] key) throws Exception{
        // 返回的結果字節數組
        byte[] resultByteArr = {};
        // 實例化密鑰工廠 RSA算法的
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        // 初始化公鑰
        // 密鑰材料轉換
        X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(key);
        // 產生公鑰
        PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
        // 數據解密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        // 解密模式
        cipher.init(Cipher.DECRYPT_MODE, publicKey);
        // RSA模式 解密模式
        String rsaMode = RSA_MODE_02;
        // 分組解密
        byte[] returnBytes = RsaUtils.groupEncryptOrDecrypt(rsaMode,data,cipher);
        if (returnBytes != null && resultByteArr.length >0){
            resultByteArr = returnBytes;
        }
        return resultByteArr;
    }

    /**
     * @Description 私鑰解密(字符串)
     * @Author SuXingYong
     * @Date 2020/7/11 23:35
     * @Param [data, key]
     * @param data 待解密數據
     * @param key 密鑰
     * @Return java.lang.String 解密以後的數據
     **/
    public static String decryptByPrivateKey(String data,String key) throws Exception{
        // 解密以後的明文字符串
        StringBuilder result = new StringBuilder("");
        // 取得私鑰
        PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(Base64.decode(key));
        // 實例化密鑰工廠 RSA算法的
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        // 生成私鑰
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
        // 數據解密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        // 解密模式
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        // 將字符串數據轉換爲字節數組
        byte[] dataByteArr = Base64.decode(data);
        // RSA模式 解密模式
        String rsaMode = RSA_MODE_02;
        // 分組解密
        byte[] resultBytes = RsaUtils.groupEncryptOrDecrypt(rsaMode,dataByteArr,cipher);
        // 給返回結果賦值
        // TODO 特別注意: 本處將字節數組裝換爲字符串的時候，必須使用 new String()方法，不能使用toString()方法
        // TODO toString()方法是調用的對象自己的，也就是繼承或者重寫的object.toString()方法，若是是byte[] b,那麼返回的是b的內存地址。
        // TODO new String()方法是使用虛擬機默認的編碼base返回對應的字符。
        result.append(new String(resultBytes));
        return result.toString();
    }

    /**
     * @Description 公鑰解密(字節數組)
     * @Author SuXingYong
     * @Date 2020/7/11 23:35
     * @Param [data, key]
     * @param data 待解密數據
     * @param key 密鑰
     * @Return ava.lang.String 解密以後的數據
     **/
    public static String decryptByPublicKey(String data,String key) throws Exception{
        // 解密以後的明文字符串
        StringBuilder result = new StringBuilder("");
        // 實例化密鑰工廠 RSA算法的
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        // 初始化公鑰
        // 密鑰材料轉換
        X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(Base64.decode(key));
        // 產生公鑰
        PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
        // 數據解密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        // 解密模式
        cipher.init(Cipher.DECRYPT_MODE, publicKey);
        // 將字符串數據轉換爲字節數組
        byte[] dataByteArr = Base64.decode(data);
        // RSA模式 解密模式
        String rsaMode = RSA_MODE_02;
        // 分組解密
        byte[] resultBytes = RsaUtils.groupEncryptOrDecrypt(rsaMode,dataByteArr,cipher);
        // 給返回結果賦值
        // TODO 特別注意: 本處將字節數組裝換爲字符串的時候，必須使用 new String()方法，不能使用toString()方法
        // TODO toString()方法是調用的對象自己的，也就是繼承或者重寫的object.toString()方法，若是是byte[] b,那麼返回的是b的內存地址。
        // TODO new String()方法是使用虛擬機默認的編碼base返回對應的字符。
        result.append(new String(resultBytes));
        return result.toString();
    }

    /************************************************* 解密end  *************************************************/


    /************************************************* 生成簽名、簽名驗證start  *************************************************/

    /**
     * @Description 生成簽名
     * @Author SuXingYong
     * @Date 2020/7/11 23:35
     * @Param [content, privateKey]
     * @param content 待簽名的數據原文
     * @param privateKey 私鑰字符串
     * @Return java.lang.String 簽名值
     **/
    public static String generatorSign(String content, String privateKey) {
        String signStr = "";
        try {
            // 取得私鑰
            PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(Base64.decode(privateKey));
            // 實例化密鑰工廠 RSA算法的
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            // 生成私鑰
            PrivateKey priKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
            // 實例化簽名
            Signature signature = Signature.getInstance(SIGN_ALGORITHMS);
            // 初始化簽名
            signature.initSign(priKey);
            // 簽名更新
            signature.update(content.getBytes());
            // 生成的簽名字節數組
            byte[] signByteArr = signature.sign();
            // 返回Base64編碼的簽名字符串
            signStr = Base64.encode(signByteArr);
        } catch (Exception e) {
            e.printStackTrace();
            log.error(e.getMessage());
        }
        return signStr;
    }

    /**
     * @Description 檢查簽名是否合法性
     * @Author SuXingYong
     * @Date 2020/7/11 23:35
     * @Param [content, sign, publicKey]
     * @param content 待簽名的數據原文
     * @param sign 簽名值
     * @param publicKey 私鑰
     * @Return boolean 是否合法
     **/
    public static boolean checkSignVerify(String content, String sign, String publicKey) {
        boolean isOK = false;
        try {
            // 取得公鑰
            X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(Base64.decode(publicKey));
            // 實例化密鑰工廠
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            // 生成公鑰
            PublicKey pubKey = keyFactory.generatePublic(x509EncodedKeySpec);
            // 實例化簽名
            Signature signature = Signature.getInstance(SIGN_ALGORITHMS);
            // 簽名驗證初始化
            signature.initVerify(pubKey);
            // 更新簽名
            signature.update(content.getBytes());
            // 驗證簽名是否合法
            isOK = signature.verify(Base64.decode(sign));
        } catch (Exception e) {
            e.printStackTrace();
            log.error(e.getMessage());
        }
        return isOK;
    }

    /************************************************* 生成簽名、簽名驗證end  *************************************************/

}

RsaUtils.java

Base64類可使用java自帶的Base64替代：

package com.sxy.rsademo.utils;

public final class Base64 {

    static private final int BASELENGTH = 128;
    static private final int LOOKUPLENGTH = 64;
    static private final int TWENTYFOURBITGROUP = 24;
    static private final int EIGHTBIT = 8;
    static private final int SIXTEENBIT = 16;
    static private final int FOURBYTE = 4;
    static private final int SIGN = -128;
    static private final char PAD = '=';
    static private final boolean fDebug = false;
    static final private byte[] base64Alphabet = new byte[BASELENGTH];
    static final private char[] lookUpBase64Alphabet = new char[LOOKUPLENGTH];

    static {
        for (int i = 0; i < BASELENGTH; ++i) {
            base64Alphabet[i] = -1;
        }
        for (int i = 'Z'; i >= 'A'; i--) {
            base64Alphabet[i] = (byte) (i - 'A');
        }
        for (int i = 'z'; i >= 'a'; i--) {
            base64Alphabet[i] = (byte) (i - 'a' + 26);
        }

        for (int i = '9'; i >= '0'; i--) {
            base64Alphabet[i] = (byte) (i - '0' + 52);
        }

        base64Alphabet['+'] = 62;
        base64Alphabet['/'] = 63;

        for (int i = 0; i <= 25; i++) {
            lookUpBase64Alphabet[i] = (char) ('A' + i);
        }

        for (int i = 26, j = 0; i <= 51; i++, j++) {
            lookUpBase64Alphabet[i] = (char) ('a' + j);
        }

        for (int i = 52, j = 0; i <= 61; i++, j++) {
            lookUpBase64Alphabet[i] = (char) ('0' + j);
        }
        lookUpBase64Alphabet[62] = (char) '+';
        lookUpBase64Alphabet[63] = (char) '/';

    }

    private static boolean isWhiteSpace(char octect) {
        return (octect == 0x20 || octect == 0xd || octect == 0xa || octect == 0x9);
    }

    private static boolean isPad(char octect) {
        return (octect == PAD);
    }

    private static boolean isData(char octect) {
        return (octect < BASELENGTH && base64Alphabet[octect] != -1);
    }

    /**
     * Encodes hex octects into Base64
     *
     * @param binaryData Array containing binaryData
     * @return Encoded Base64 array
     */
    public static String encode(byte[] binaryData) {

        if (binaryData == null) {
            return null;
        }

        int lengthDataBits = binaryData.length * EIGHTBIT;
        if (lengthDataBits == 0) {
            return "";
        }

        int fewerThan24bits = lengthDataBits % TWENTYFOURBITGROUP;
        int numberTriplets = lengthDataBits / TWENTYFOURBITGROUP;
        int numberQuartet = fewerThan24bits != 0 ? numberTriplets + 1 : numberTriplets;
        char encodedData[] = null;

        encodedData = new char[numberQuartet * 4];

        byte k = 0, l = 0, b1 = 0, b2 = 0, b3 = 0;

        int encodedIndex = 0;
        int dataIndex = 0;
        if (fDebug) {
            System.out.println("number of triplets = " + numberTriplets);
        }

        for (int i = 0; i < numberTriplets; i++) {
            b1 = binaryData[dataIndex++];
            b2 = binaryData[dataIndex++];
            b3 = binaryData[dataIndex++];

            if (fDebug) {
                System.out.println("b1= " + b1 + ", b2= " + b2 + ", b3= " + b3);
            }

            l = (byte) (b2 & 0x0f);
            k = (byte) (b1 & 0x03);

            byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
            byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0);
            byte val3 = ((b3 & SIGN) == 0) ? (byte) (b3 >> 6) : (byte) ((b3) >> 6 ^ 0xfc);

            if (fDebug) {
                System.out.println("val2 = " + val2);
                System.out.println("k4   = " + (k << 4));
                System.out.println("vak  = " + (val2 | (k << 4)));
            }

            encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];
            encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)];
            encodedData[encodedIndex++] = lookUpBase64Alphabet[(l << 2) | val3];
            encodedData[encodedIndex++] = lookUpBase64Alphabet[b3 & 0x3f];
        }

        // form integral number of 6-bit groups  
        if (fewerThan24bits == EIGHTBIT) {
            b1 = binaryData[dataIndex];
            k = (byte) (b1 & 0x03);
            if (fDebug) {
                System.out.println("b1=" + b1);
                System.out.println("b1<<2 = " + (b1 >> 2));
            }
            byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
            encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];
            encodedData[encodedIndex++] = lookUpBase64Alphabet[k << 4];
            encodedData[encodedIndex++] = PAD;
            encodedData[encodedIndex++] = PAD;
        } else if (fewerThan24bits == SIXTEENBIT) {
            b1 = binaryData[dataIndex];
            b2 = binaryData[dataIndex + 1];
            l = (byte) (b2 & 0x0f);
            k = (byte) (b1 & 0x03);

            byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
            byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0);

            encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];
            encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)];
            encodedData[encodedIndex++] = lookUpBase64Alphabet[l << 2];
            encodedData[encodedIndex++] = PAD;
        }

        return new String(encodedData);
    }

    /**
     * Decodes Base64 data into octects
     *
     * @param encoded string containing Base64 data
     * @return Array containind decoded data.
     */
    public static byte[] decode(String encoded) {

        if (encoded == null) {
            return null;
        }

        char[] base64Data = encoded.toCharArray();
        // remove white spaces  
        int len = removeWhiteSpace(base64Data);

        if (len % FOURBYTE != 0) {
            // should be divisible by four
            return null;
        }

        int numberQuadruple = (len / FOURBYTE);

        if (numberQuadruple == 0) {
            return new byte[0];
        }

        byte decodedData[] = null;
        byte b1 = 0, b2 = 0, b3 = 0, b4 = 0;
        char d1 = 0, d2 = 0, d3 = 0, d4 = 0;

        int i = 0;
        int encodedIndex = 0;
        int dataIndex = 0;
        decodedData = new byte[(numberQuadruple) * 3];

        for (; i < numberQuadruple - 1; i++) {

            if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++]))
                    || !isData((d3 = base64Data[dataIndex++]))
                    || !isData((d4 = base64Data[dataIndex++]))) {
                return null;
            }//if found "no data" just return null  

            b1 = base64Alphabet[d1];
            b2 = base64Alphabet[d2];
            b3 = base64Alphabet[d3];
            b4 = base64Alphabet[d4];

            decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
            decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
            decodedData[encodedIndex++] = (byte) (b3 << 6 | b4);
        }

        if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++]))) {
            //if found "no data" just return null
            return null;
        }

        b1 = base64Alphabet[d1];
        b2 = base64Alphabet[d2];

        d3 = base64Data[dataIndex++];
        d4 = base64Data[dataIndex++];
        // Check if they are PAD characters
        if (!isData((d3)) || !isData((d4))) {
            if (isPad(d3) && isPad(d4)) {
                // last 4 bits should be zero
                if ((b2 & 0xf) != 0)
                {
                    return null;
                }
                byte[] tmp = new byte[i * 3 + 1];
                System.arraycopy(decodedData, 0, tmp, 0, i * 3);
                tmp[encodedIndex] = (byte) (b1 << 2 | b2 >> 4);
                return tmp;
            } else if (!isPad(d3) && isPad(d4)) {
                b3 = base64Alphabet[d3];
                //last 2 bits should be zero
                if ((b3 & 0x3) != 0)
                {
                    return null;
                }
                byte[] tmp = new byte[i * 3 + 2];
                System.arraycopy(decodedData, 0, tmp, 0, i * 3);
                tmp[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
                tmp[encodedIndex] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
                return tmp;
            } else {
                return null;
            }
        } else {
            //No PAD e.g 3cQl
            b3 = base64Alphabet[d3];
            b4 = base64Alphabet[d4];
            decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
            decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
            decodedData[encodedIndex++] = (byte) (b3 << 6 | b4);

        }

        return decodedData;
    }

    /**
     * remove WhiteSpace from MIME containing encoded Base64 data.
     *
     * @param data  the byte array of base64 data (with WS)
     * @return      the new length
     */
    private static int removeWhiteSpace(char[] data) {
        if (data == null) {
            return 0;
        }

        // count characters that's not whitespace
        int newSize = 0;
        int len = data.length;
        for (int i = 0; i < len; i++) {
            if (!isWhiteSpace(data[i])) {
                data[newSize++] = data[i];
            }
        }
        return newSize;
    }

}

Base64.java

 轉型工具類：

package com.sxy.rsademo.utils;

/**
 * @Description 轉型工具類
 * @Author SuXingYong
 * @Date 2020/7/11 23:35
 **/
public final class CastUtils {

    /**
     * @Description 轉爲String 型 默認爲空
     * @Author SuXingYong
     * @Date 2020/7/11 23:35
     * @Param [obj]
     * @param obj
     * @Return java.lang.String
     **/
    public static String castString(Object obj) {
        return CastUtils.castString(obj, "");
    }

    /**
     * @Description 轉爲String 型(提供默認值)
     * @Author SuXingYong
     * @Date 2020/7/11 23:35
     * @Param [obj, defaultValue]
     * @param obj
     * @param defaultValue 默認值
     * @Return java.lang.String
     **/
    public static String castString(Object obj, String defaultValue) {
        return obj != null ? String.valueOf(obj) : defaultValue;
    }
}

CastUtils.java

統一返回常量類：

package com.sxy.rsademo.utils;

/**
 * @Description: 返回常量
 * @Author: SuXingYong
 * @Date 2020/7/11 23:35
 **/
public class ReturnConstant {
    /** 返回值常量 - 成功 **/
    public final static String SUCCESS = "success";

    /** 返回值常量 - 失敗 **/
    public final static String ERROR = "error";
}

ReturnConstant.java

HttpClientUtils工具類：

package com.sxy.rsademo.utils;

import com.alibaba.fastjson.JSON;
import com.sxy.rsademo.rsa.RsaUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;

import javax.servlet.http.HttpServletRequest;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.util.*;

/**
 * @Description HttpClient 工具類
 * @Author SuXingYong
 * @Date 2020/7/11 23:35
 **/
@Slf4j
public class HttpClientUtils {

    /** 目標服務器 - URL - 01 **/
    public final static String CLIENT_URL_01 = "http://localhost:9009/target-server/data/receive";
    /** 目標服務器 - 數據 - 鍵名 **/
    public final static String SERVER_DATA_KEY = "dataJson";
    /** 目標服務器 - 簽名 - 鍵名 **/
    public final static String SERVER_SIGN_KEY = "sign";


    public static void main(String[] args) {
        try {
            String url = "";
            Map<String, String> parameterMap = new LinkedHashMap<>();
            // 發送數據
            Map<String, String> resultMap = HttpClientUtils.sendDataToTargetServerForOne(url,parameterMap);
            for (Map.Entry<String, String> result : resultMap.entrySet()){
               log.info("result==》 "+result.getKey()+": "+result.getValue());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * @Description 構造數據
     * @Author SuXingYong
     * @Date 2020/7/11 23:35
     * @Param []
     * @Return java.util.Map<java.lang.String,java.lang.String>
     **/
    public static Map<String,String> createData() throws UnsupportedEncodingException {
        Map<String, String> returnMap = new LinkedHashMap<>();
        Map<String, String> dataMap = new LinkedHashMap<>();
        dataMap.put("id","11eh-9b58-af45b5c8-b5e2-9d0036e9473z");
        dataMap.put("name","小明");
        dataMap.put("loginName","xiaoming");
        dataMap.put("phone","12345678901");
        dataMap.put("time","2020-07-12 00:33:27");
        dataMap.put("content","隨便整了些內容，就驗證一下。");
        for (Map.Entry<String, String> data : dataMap.entrySet()){
            returnMap.put(data.getKey(),URLEncoder.encode(data.getValue(),"UTF-8"));
        }
        return returnMap;
    }

    /**
     * @Description 單條發送數據
     * @Author SuXingYong
     * @Date 2020/7/11 23:35
     * @Param [url,parameterMap]
     * @Return java.util.Map<java.lang.String,java.lang.String>
     **/
    public static Map<String, String> sendDataToTargetServerForOne(String url,Map<String, String> parameterMap) throws Exception {
        // 返回結果集
        Map<String, String> returnMap = new LinkedHashMap<>();
        // 請求參數 傳入參數結果集爲空的時候就直接使用默認值
        Map<String, String>  requestMap = HttpClientUtils.createData();
        if (parameterMap != null && parameterMap.size() >0){
            // 清空默認值
            requestMap = new LinkedHashMap<>();
            // 對參數集合的值進行url編碼
            for (Map.Entry<String, String> param : parameterMap.entrySet()){
                requestMap.put(param.getKey(),URLEncoder.encode(param.getValue(),"UTF-8"));
            }
        }
        if (requestMap != null && requestMap.size() >0){
            // 數據參數字符串
            StringBuilder dataStr  = new StringBuilder("");
            // 遍歷參數集合並拼接成字符串
            for (Map.Entry<String, String> map : requestMap.entrySet()){
                // 鍵名
                String dataKey = map.getKey();
                // 鍵值
                String dataValue = map.getValue();
                dataStr.append(dataKey).append("=");
                dataStr.append(dataValue);
                dataStr.append("&");
            }
           log.info("send==》 dataStr："+dataStr);
            // 去除最後一個&符號
            String paramStr = dataStr.toString().substring(0, dataStr.length() - 1);
           log.info("send==》 paramStr："+paramStr);

            // 服務器原文數據
            //requestMap.put("originalTextData",paramStr);

            // 將數據轉化爲json字符串
            String dataJson = JSON.toJSONString(requestMap);
           log.info("send==》 dataJson: "+dataJson);
            // 重置請求參數集合
            requestMap = new LinkedHashMap<>();
            // 將json數據放到請求參數集合中
            //requestMap.put("data",dataJson);

            // 密鑰對
            Map<String,Object> keyMap = RsaUtils.getLastingKeyPair();

            // 使用持久化公鑰對數據進行加密
            String cipherTextData = RsaUtils.encryptByPublicKey(dataJson, CastUtils.castString(keyMap.get(RsaUtils.PUBLIC_KEY)));
           log.info("send==》  cipherTextData: "+cipherTextData);
            // 服務器密文數據
            requestMap.put("data",cipherTextData);

            // 使用持久化私鑰生成簽名
            String sign = RsaUtils.generatorSign(cipherTextData, CastUtils.castString(keyMap.get(RsaUtils.PRIVATE_KEY)));
            //
           log.info("send==》  sign: "+sign);

            // 請求參數中需帶上簽名字符串
            requestMap.put(SERVER_SIGN_KEY, sign);

            // 將請求參數轉化爲json字符串
            String requestJson = JSON.toJSONString(requestMap);
           log.info("send==》  requestJson："+requestJson);
            // 請求地址 沒有傳入的時候就使用默認值
            String requestUrl = CLIENT_URL_01;
            if (url != null && url != ""){
                requestUrl = url;
               log.info("send==》 requestUrl："+requestUrl);
            }
            if (requestUrl != null && requestUrl != ""){
                requestMap = new LinkedHashMap<>();
                requestMap.put(SERVER_DATA_KEY, requestJson);
                if (requestMap != null && requestMap.size() >0){
                    //發送POST請求 parameterMap模式
                    returnMap = HttpClientUtils.sendPostRequest(requestUrl,requestMap);
                }else{
                    returnMap.put(ReturnConstant.ERROR,"請求數據參數爲空，不支持");
                }

                //if (requestJson != null && requestJson != ""){
                    // 發送POST請求 json模式
                //    returnMap = HttpClientUtils.sendPostRequest(requestUrl,requestJson);
                //}else{
                //    returnMap.put(ReturnConstant.ERROR,"請求數據參數爲空，不支持");
                //}
            }else{
                returnMap.put(ReturnConstant.ERROR,"請求地址爲空，不支持");
            }
        }else{
            returnMap.put(ReturnConstant.ERROR,"發送數據爲空，不支持");
        }
        return returnMap;
    }

    /**
     * @Description 批量發送數據
     * @Author SuXingYong
     * @Date 2020/7/11 23:35
     * @Param [url, dataList]
     * @Return java.util.Map<java.lang.String,java.lang.String>
     **/
    public static Map<String,String> sendDataToTargetServerForList(String url, List<Map<String,String>> dataList) throws Exception{
        // 返回結果集
        Map<String, String> returnMap = new LinkedHashMap<>();
        // 請求參數集合
        Map<String, String>  requestMap = new LinkedHashMap<>();
        if (dataList != null && dataList.size() >0){
            // 緩存列表
            List<Map<String, String>> cacheList = new ArrayList<>();
            for (int i = 0 ; i < dataList.size() ; i++){
                // 對參數進行編碼以後的新集合
                Map<String, String> newDataMap = new LinkedHashMap<>();
                Map<String, String> dataMap = dataList.get(i);
                // 對參數集合的值進行url編碼
                for (Map.Entry<String, String> data : dataMap.entrySet()){
                    newDataMap.put(data.getKey(),URLEncoder.encode(data.getValue(),"UTF-8"));
                }
                if (newDataMap != null && newDataMap.size() >0){
                    // 將編碼後的新集合放到緩存數組中
                    cacheList.add(newDataMap);
                }
            }
            if (cacheList != null && cacheList.size() >0){
                // 重置數據列表
                dataList = new ArrayList<>();
                dataList = cacheList;
            }

            // 將數據轉化爲json字符串
            String dataJson = JSON.toJSONString(dataList);
            log.info("send==》 dataJson: "+dataJson);
            // 將數據json字符串放到請求參數中
            //requestMap.put("originalTextData",dataJson);


            // 密鑰對
            Map<String,Object> keyMap = RsaUtils.getLastingKeyPair();

            // 使用持久化公鑰對數據進行加密
            String cipherTextData = RsaUtils.encryptByPublicKey(dataJson, CastUtils.castString(keyMap.get(RsaUtils.PUBLIC_KEY)));
            log.info("send==》  cipherTextData: "+cipherTextData);
            // 發送密文數據
            requestMap.put("data",cipherTextData);

            // 使用持久化私鑰生成簽名
            String sign = RsaUtils.generatorSign(cipherTextData, CastUtils.castString(keyMap.get(RsaUtils.PRIVATE_KEY)));
            //
            log.info("send==》  sign: "+sign);

            // 請求參數中需帶上簽名字符串
            requestMap.put(SERVER_SIGN_KEY, sign);

            // 將請求參數轉化爲json字符串
            String requestJson = JSON.toJSONString(requestMap);
            log.info("send==》  requestJson："+requestJson);
            // 請求地址 沒有傳入的時候就使用默認值
            String requestUrl = CLIENT_URL_01;
            if (url != null && url != ""){
                requestUrl = url;
                log.info("send==》 requestUrl："+requestUrl);
            }
            if (requestUrl != null && requestUrl != ""){
                if (requestJson != null && requestJson != ""){
                    // 發送POST請求 json模式
                    returnMap = HttpClientUtils.sendPostRequest(requestUrl,requestJson);
                }else{
                    returnMap.put(ReturnConstant.ERROR,"請求數據參數爲空，不支持");
                }
            }else {
                returnMap.put(ReturnConstant.ERROR, "請求地址爲空，不支持");
            }
        }else{
            returnMap.put(ReturnConstant.ERROR,"數據爲空，不支持");
        }
        return returnMap;
    }

    /**
     * @Description 發送POST請求 parameterMap模式
     * @Author SuXingYong
     * @Date 2020/7/11 23:35
     * @Param [url, json]
     * @Return java.util.Map<java.lang.String,java.lang.String>
     **/
    public static Map<String, String> sendPostRequest(String url,Map<String, String> parameterMap){
        // 返回結果
        Map<String, String> returnMap = new LinkedHashMap<>();
        OutputStream out = null;
        BufferedReader in = null;
        HttpURLConnection conn = null;
        String result = "";
        try {
            StringBuilder data = new StringBuilder();
            for (Map.Entry<String, String> dataKeyValue : parameterMap.entrySet()) {
                String dataName = dataKeyValue.getKey();
                String dataValue = dataKeyValue.getValue();
                data.append(dataName).append("=");
                //data.append(dataValue);
                // 轉換爲UTF-8編碼
                data.append(URLEncoder.encode(dataValue, "UTF-8"));
                data.append("&");
            }
            data.append("sendTime=").append(System.currentTimeMillis());
           log.info("send==》 parameterMapStr: "+data.toString());
            byte[] entity = data.toString().getBytes();
            conn = (HttpURLConnection)new URL(url).openConnection();
            conn.setUseCaches(false);
            // 10000
            conn.setConnectTimeout(10000);
            // POST
            conn.setRequestMethod("POST");
            // 發送POST請求必須設置以下兩行
            conn.setDoOutput(true);
            conn.setDoInput(true);
            conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
            conn.setRequestProperty("Content-Length", String.valueOf(entity.length));

            out = conn.getOutputStream();
            // 獲取URLConnection對象對應的輸出流
            out = conn.getOutputStream();
            // 發送請求參數
            out.write(entity);
            // flush輸出流的緩衝
            out.flush();
            in = new BufferedReader(new InputStreamReader(conn.getInputStream()));
            String line;
            while ((line = in.readLine()) != null) {
                result += line;
            }
            returnMap.put(ReturnConstant.SUCCESS,result);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (out != null) {
                    out.close();
                }
                if (in != null) {
                    in.close();
                }
            } catch (Exception e2) {
                e2.printStackTrace();
            }

        }
        return returnMap;
    }

    /**
     * @Description 發送POST請求 json字符串模式
     * @Author SuXingYong
     * @Date 2020/7/11 23:35
     * @Param [url, json]
     * @Return java.util.Map<java.lang.String,java.lang.String>
     **/
    public static Map<String, String> sendPostRequest(String url,String json){
        // 返回結果集
        Map<String, String> returnMap = new LinkedHashMap<>();
        // 建立HttpClient對象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        try {
            // 建立Http Post請求
            HttpPost httpPost = new HttpPost(url);
           log.info("send==》 json："+json);
            // 建立請求內容
            StringEntity entity = new StringEntity(json, ContentType.APPLICATION_JSON);
            httpPost.setEntity(entity);
            // 執行http請求
            response = httpClient.execute(httpPost);
            returnMap.put(ReturnConstant.SUCCESS, EntityUtils.toString(response.getEntity(), "utf-8"));
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return returnMap;
    }

    /**
     * 獲取sendPostRequest請求的Json數據
     */
    private String getRequestPostData(HttpServletRequest request) throws IOException {
        int contentLength = request.getContentLength();
        if (contentLength < 0) {
            return null;
        }
        byte buffer[] = new byte[contentLength];
        for (int i = 0; i < contentLength;) {
            int len = request.getInputStream().read(buffer, i, contentLength - i);
            if (len == -1) {
                break;
            }
            i += len;
        }
        return new String(buffer, "utf-8");
    }

}

HttpClientUtils.java

SpringBoot項目運行入口類：

package com.sxy.rsademo;

import com.sxy.rsademo.rsa.RsaUtils;
import com.sxy.rsademo.utils.HttpClientUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import java.util.Map;

@Slf4j
@SpringBootApplication
public class RsaDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(RsaDemoApplication.class, args);
        // 初始化密鑰對,並持久化存儲
        RsaUtils.initKey();
        try {
            // 獲取持久化密鑰對
            Map<String,Object> keyMap =  RsaUtils.getLastingKeyPair();
            for (Map.Entry<String,Object> entry :keyMap.entrySet()){
                log.info("keyMap==》 "+entry.getKey()+": "+entry.getValue());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 發送數據進行測試
        HttpClientUtils.main(args);
    }

}

RsaDemoApplication.java

pom.xml  maven依賴文件：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.sxy</groupId>
    <artifactId>rsa-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>rsa-demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <fastjson.version>1.2.62</fastjson.version>
        <httpClient.version>4.5.12</httpClient.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>${fastjson.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>${httpClient.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

pom.xml

運行結果：

 

 密鑰對生成成功：

私鑰持久化文件：

 

 公鑰持久化文件：

 

 至此，RSA算法的密鑰對的初始化，持久化保存、讀取，數據簽名、加密、發送等基本功能已完成；

 關於數據如何接收、驗證簽名以及解密將在下一篇文章中繼續分享；