Encrypt and decrypt strings using RSA and Base64

1. Use RSA Public key encryption

    /**
     * RSA And base64 Encrypted string 
     * @param json  Data to be encrypted 
     * @param publicKey  Public key 
     * @return  Encrypted string 
     */
    String rsaKeyEncrypt(String json, String publicKey){
        String outStr = null;
        try {
            //base64 Encoded public key 
            byte[] decoded = org.apache.commons.codec.binary.Base64.decodeBase64(publicKey);
            RSAPublicKey pubKey = (RSAPublicKey) KeyFactory.getInstance("RSA").
                    generatePublic(new X509EncodedKeySpec(decoded));
            //RSA encryption 
            Cipher cipher = Cipher.getInstance("RSA");
            cipher.init(Cipher.ENCRYPT_MODE, pubKey);

            // When the length is too long , Encryption after splitting is required  117 Bytes 
            byte[] resultBytes = getMaxResultEncrypt(json, cipher);
            outStr = Base64.encodeBase64String(resultBytes);
        } catch (Exception e){
            e.printStackTrace();
        }

        return outStr;
    }

    //RSA And base64 Encrypted string 
    private static byte[] getMaxResultEncrypt(String str, Cipher cipher) throws IllegalBlockSizeException, BadPaddingException {
        byte[] inputArray = str.getBytes();
        int inputLength = inputArray.length;
        //  Maximum encrypted bytes , Exceeding the maximum number of bytes requires packet encryption 
        int MAX_ENCRYPT_BLOCK = 117;
        //  identification 
        int offSet = 0;
        byte[] resultBytes = {};
        byte[] cache = {};
        while (inputLength - offSet > 0) {
            if (inputLength - offSet > MAX_ENCRYPT_BLOCK) {
                cache = cipher.doFinal(inputArray, offSet, MAX_ENCRYPT_BLOCK);
                offSet += MAX_ENCRYPT_BLOCK;
            } else {
                cache = cipher.doFinal(inputArray, offSet, inputLength - offSet);
                offSet = inputLength;
            }
            resultBytes = Arrays.copyOf(resultBytes, resultBytes.length + cache.length);
            System.arraycopy(cache, 0, resultBytes, resultBytes.length - cache.length, cache.length);
        }
        return resultBytes;
    }

2. Use RSA Private key decryption

    /**
     * RSA Private key decryption 
     *
     * @param str         Encrypted string 
     * @param privateKey  Private key 
     * @return  Decrypted string 
     */
    public static String privateKeyDecrypt(String str, String privateKey) throws Exception {
        //64 Bit decode encrypted string 
        byte[] inputByte = Base64.decodeBase64(str.getBytes("UTF-8"));
        //base64 Encoded private key 
        byte[] decoded = Base64.decodeBase64(privateKey);
        RSAPrivateKey priKey = (RSAPrivateKey) KeyFactory.getInstance("RSA")
                .generatePrivate(new PKCS8EncodedKeySpec(decoded));
        //RSA Decrypt 
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, priKey);
//        String outStr = new String(cipher.doFinal(inputByte));
        // When the length is too long , Decryption after splitting is required  128 Bytes 
        String outStr = new String(getMaxResultDecrypt(str, cipher));
        return outStr;
    }

    /**
     * RSA Private key decryption 
     */
    private static byte[] getMaxResultDecrypt(String str, Cipher cipher) {

        byte[] resultBytes = {};
        try {
            byte[] inputArray = Base64.decodeBase64(str.getBytes("UTF-8"));
            int inputLength = inputArray.length;
            //  Maximum decryption bytes , Exceeding the maximum number of bytes requires packet encryption 
            int MAX_ENCRYPT_BLOCK = 128;
            //  identification 
            int offSet = 0;
            byte[] cache = {};
            while (inputLength - offSet > 0) {
                if (inputLength - offSet > MAX_ENCRYPT_BLOCK) {
                    cache = cipher.doFinal(inputArray, offSet, MAX_ENCRYPT_BLOCK);
                    offSet += MAX_ENCRYPT_BLOCK;
                } else {
                    cache = cipher.doFinal(inputArray, offSet, inputLength - offSet);
                    offSet = inputLength;
                }
                resultBytes = Arrays.copyOf(resultBytes, resultBytes.length + cache.length);
                System.arraycopy(cache, 0, resultBytes, resultBytes.length - cache.length, cache.length);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return resultBytes;
    }