RSA加密解密实现（JAVA）

1.关于RSA算法的原理解析参考：http://www.ruanyifeng.com/blog/2013/06/rsa_algorithm_part_one.html

2.RSA密钥长度、明文长度和密文长度参考：https://blog.csdn.net/liuhuabai100/article/details/7585879

3.以下示例代码可以将密钥Base64转码之后保存到文本文件内，也可以从文本文件中读取密钥。

public class RSAGenerator {

	/**
	 * 算法
	 */
	private String ALGORITHM_RSA = "RSA";
	private String DEFAULT_ENCODING = "UTF-8";

	public static final String KEY_TYPE_PUBLIC = "PUBLIC";
	public static final String KEY_TYPE_PRIVATE = "PRIVATE";

	/**
	 * 公钥
	 */
	private RSAPublicKey publicKey;

	private String publicKeyStr;

	/**
	 * 私钥
	 */
	private RSAPrivateKey privateKey;

	private String privateKeyStr;

	/**
	 * 用于加解密
	 */
	private Cipher cipher;

	/**
	 * 明文块的长度 它必须小于密文块的长度 - 11
	 */
	private int originLength = 128;
	/**
	 * 密文块的长度
	 */
	private int encrytLength = 256;

	/**
	 * 生成密钥对
	 * @return
	 */
	public RSAGenerator generateKeyPair() {
		try {
			// RSA加密算法
			KeyPairGenerator keyPairGenerator = KeyPairGenerator
					.getInstance(ALGORITHM_RSA);
			// 创建密钥对，长度采用2048
			keyPairGenerator.initialize(2048);
			KeyPair keyPair = keyPairGenerator.generateKeyPair();
			// 分别得到公钥和私钥
			publicKey = (RSAPublicKey) keyPair.getPublic();
			privateKey = (RSAPrivateKey) keyPair.getPrivate();

			// 使用 Base64编码
			publicKeyStr = Base64Util.encode(publicKey.getEncoded());
			privateKeyStr = Base64Util.encode(privateKey.getEncoded());
			
			//将BASE64编码的结果保存到文件内
		    String classPath = this.getClass().getClassLoader().getResource("").toString();
		    String prefix = classPath.substring(classPath.indexOf(":") + 1);
            String publicFilePath = prefix+"public.txt";
		    File publicFile= new File(publicFilePath);
		    saveBase64KeyToFile(publicFile, publicKeyStr);
		    
		    String privateFilePath = prefix+"private.txt";
		    File privateFile= new File(privateFilePath);
		    saveBase64KeyToFile(privateFile, privateKeyStr);

		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		}
		return this;
	}
	
	

	/**
	 * 用公钥加密
	 * @param content
	 * @return 加密后的16进制字符串
	 */
	public String encryptByPublic(String content) {
		String encode = "";
		try {
			cipher = Cipher.getInstance(ALGORITHM_RSA);
			cipher.init(Cipher.ENCRYPT_MODE, publicKey);
			// 该密钥能够加密的最大字节长度
			int splitLength = publicKey.getModulus().bitLength() / 8 - 11;
			byte[][] arrays = splitBytes(content.getBytes(), splitLength);
			// 加密
			StringBuffer buffer = new StringBuffer();
			for (byte[] array : arrays) {
				buffer.append(bytesToHexString(cipher.doFinal(array)));
			}
			encode = buffer.toString();

		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (NoSuchPaddingException e) {
			e.printStackTrace();
		} catch (InvalidKeyException e) {
			e.printStackTrace();
		} catch (IllegalBlockSizeException e) {
			e.printStackTrace();
		} catch (BadPaddingException e) {
			e.printStackTrace();
		}
		return encode;
	}

	/**
	 * 用私钥加密
	 * 
	 * @param content
	 * @return 加密后的16进制字符串
	 */
	public String encryptByPrivate(String content) {
		try {
			Cipher cipher = Cipher.getInstance(ALGORITHM_RSA);
			cipher.init(Cipher.ENCRYPT_MODE, privateKey);
			// 该密钥能够加密的最大字节长度
			int splitLength = ((RSAPrivateKey) privateKey).getModulus()
					.bitLength() / 8 - 11;
			byte[][] arrays = splitBytes(content.getBytes(), splitLength);
			StringBuffer stringBuffer = new StringBuffer();
			for (byte[] array : arrays) {
				stringBuffer.append(bytesToHexString(cipher.doFinal(array)));
			}
			return stringBuffer.toString();
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (NoSuchPaddingException e) {
			e.printStackTrace();
		} catch (InvalidKeyException e) {
			e.printStackTrace();
		} catch (BadPaddingException e) {
			e.printStackTrace();
		} catch (IllegalBlockSizeException e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 用私钥解密
	 * @param content
	 * @return 解密后的原文
	 */
	public String decryptByPrivate(String content) {
		String decode = "";
		try {
			cipher = Cipher.getInstance(ALGORITHM_RSA);
			cipher.init(Cipher.DECRYPT_MODE, privateKey);

			// 该密钥能够加密的最大字节长度
			int splitLength = privateKey.getModulus().bitLength() / 8;
			byte[] contentBytes = hexStringToBytes(content);

			byte[][] arrays = splitBytes(contentBytes, splitLength);
			StringBuffer stringBuffer = new StringBuffer();
			for (byte[] array : arrays) {
				stringBuffer.append(new String(cipher.doFinal(array)));
			}
			decode = stringBuffer.toString();

		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (NoSuchPaddingException e) {
			e.printStackTrace();
		} catch (InvalidKeyException e) {
			e.printStackTrace();
		} catch (IllegalBlockSizeException e) {
			e.printStackTrace();
		} catch (BadPaddingException e) {
			e.printStackTrace();
		}
		return decode;
	}

	/**
	 * 用私钥解密
	 * 
	 * @param content
	 * @return 解密后的原文
	 */
	public String decryptByPublic(String content) {
		String decode = "";
		try {
			cipher = Cipher.getInstance(ALGORITHM_RSA);
			cipher.init(Cipher.DECRYPT_MODE, publicKey);
			// 该密钥能够加密的最大字节长度
			int splitLength = publicKey.getModulus().bitLength() / 8;
			byte[] contentBytes = hexStringToBytes(content);

			byte[][] arrays = splitBytes(contentBytes, splitLength);
			StringBuffer stringBuffer = new StringBuffer();
			for (byte[] array : arrays) {
				stringBuffer.append(new String(cipher.doFinal(array)));
			}
			decode = stringBuffer.toString();

		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (NoSuchPaddingException e) {
			e.printStackTrace();
		} catch (InvalidKeyException e) {
			e.printStackTrace();
		} catch (IllegalBlockSizeException e) {
			e.printStackTrace();
		} catch (BadPaddingException e) {
			e.printStackTrace();
		}
		return decode;
	}

	/**
	 * 根据限定的每组字节长度，将字节数组分组
	 * @param bytes 等待分组的字节组
	 * @param splitLength 每组长度
	 * @return 分组后的字节组
	 */
	public static byte[][] splitBytes(byte[] bytes, int splitLength) {
		// bytes与splitLength的余数
		int remainder = bytes.length % splitLength;
		// 数据拆分后的组数，余数不为0时加1
		int quotient = remainder > 0 ? bytes.length / splitLength + 1
				: bytes.length / splitLength;
		byte[][] arrays = new byte[quotient][];
		byte[] array = null;
		for (int i = 0; i < quotient; i++) {
			// 如果是最后一组（quotient-1）,同时余数不等于0，就将最后一组设置为remainder的长度
			if (i == quotient - 1 && remainder != 0) {
				array = new byte[remainder];
				System.arraycopy(bytes, i * splitLength, array, 0, remainder);
			} else {
				array = new byte[splitLength];
				System.arraycopy(bytes, i * splitLength, array, 0, splitLength);
			}
			arrays[i] = array;
		}
		return arrays;
	}

	/**
	 * 将字节数组转换成16进制字符串
	 * @param bytes  即将转换的数据
	 * @return 16进制字符串
	 */
	public static String bytesToHexString(byte[] bytes) {
		StringBuffer sb = new StringBuffer(bytes.length);
		String temp = null;
		for (int i = 0; i < bytes.length; i++) {
			temp = Integer.toHexString(0xFF & bytes[i]);
			if (temp.length() < 2) {
				sb.append(0);
			}
			sb.append(temp);
		}
		return sb.toString();
	}

	/**
	 * 将16进制字符串转换成字节数组
	 * 
	 * @param hex
	 *            16进制字符串
	 * @return byte[]
	 */
	public static byte[] hexStringToBytes(String hex) {
		int len = (hex.length() / 2);
		hex = hex.toUpperCase();
		byte[] result = new byte[len];
		char[] chars = hex.toCharArray();
		for (int i = 0; i < len; i++) {
			int pos = i * 2;
			result[i] = (byte) (toByte(chars[pos]) << 4 | toByte(chars[pos + 1]));
		}
		return result;
	}

	/**
	 * 将char转换为byte
	 * 
	 * @param c
	 *            char
	 * @return byte
	 */
	private static byte toByte(char c) {
		return (byte) "0123456789ABCDEF".indexOf(c);
	}

	/**
	 * 保存公钥到文件
	 * 
	 * @param file
	 * @return
	 */
	public boolean savePublicKey(File file) {
		return saveKeyToFile(publicKey, file);
	}

	/**
	 * 保存私钥到文件
	 * 
	 * @param file
	 * @return
	 */
	public boolean savePrivateKey(File file) {
		return saveKeyToFile(privateKey, file);
	}

	/**
	 * 保存密钥到文件
	 * @param key 密钥
	 * @param file 文件
	 * @return
	 */
	private boolean saveKeyToFile(Key key, File file) {
		boolean result = false;
		FileOutputStream fos = null;
		try {
			fos = new FileOutputStream(file);
			ObjectOutputStream oos = new ObjectOutputStream(fos);
			// 公钥默认使用的是X.509编码，私钥默认采用的是PKCS #8编码
			byte[] encode = key.getEncoded();
			// 注意，此处采用writeObject方法，读取时也要采用readObject方法
			oos.writeObject(encode);
			oos.close();
			result = true;
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				fos.close();
			} catch (IOException e) {
				
				e.printStackTrace();
			}
		}
		return result;
	}

	private boolean saveBase64KeyToFile(File file, String key) {

		boolean result = false;
		FileOutputStream fos = null;
		try {
			fos = new FileOutputStream(file);
			fos.write(key.getBytes());
			fos.close();
			result = true;
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				fos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return result;
	}
	
	/**
	 * 从BASE64文件中读取KEY值
	 * @param fileName
	 * @param keyType
	 */
	public void getKeyFromBase64File(String fileName,String keyType) {
		try {
			InputStream inputStream = this.getClass().getClassLoader().getResource(fileName).openStream();
			ByteArrayOutputStream outStream = new ByteArrayOutputStream();
			byte[] subByte = new byte[1024];
			int len = 0;
			while((len=inputStream.read(subByte))>0) {
				outStream.write(subByte,0,len);
			}
			inputStream.close();
			outStream.close();
			String base64Key = new String(outStream.toByteArray(), DEFAULT_ENCODING);
			byte[] keybyte = Base64Util.decode(base64Key);
			
			// 默认编码
			KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM_RSA);
			
			if (KEY_TYPE_PUBLIC.equals(keyType)) {
				X509EncodedKeySpec x509eks = new X509EncodedKeySpec(keybyte);
				publicKey = (RSAPublicKey) keyFactory.generatePublic(x509eks);
				System.out.println(publicKey.getAlgorithm());
			} else {
				PKCS8EncodedKeySpec pkcs8eks = new PKCS8EncodedKeySpec(keybyte);
				privateKey = (RSAPrivateKey) keyFactory
						.generatePrivate(pkcs8eks);
			}
				
			 
		} catch (IOException e) {
			e.printStackTrace();
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (InvalidKeySpecException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 从文件中得到公钥
	 * 
	 * @param file
	 */
	public void getPublicKey(File file) {
		getKey(file, KEY_TYPE_PUBLIC);
	}

	/**
	 * 从文件中得到私钥
	 * 
	 * @param file
	 */
	public void getPrivateKey(File file) {
		getKey(file, KEY_TYPE_PRIVATE);
	}

	/**
	 * 从文件中得到密钥
	 * 
	 * @param file
	 * @param keyType
	 */
	private void getKey(File file, String keyType) {
		FileInputStream fis = null;
		try {
			fis = new FileInputStream(file);
			ObjectInputStream ois = new ObjectInputStream(fis);
			byte[] keybyte = (byte[]) ois.readObject();
			// 关闭资源
			ois.close();
			// 默认编码
			KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM_RSA);
			if (KEY_TYPE_PUBLIC.equals(keyType)) {
				X509EncodedKeySpec x509eks = new X509EncodedKeySpec(keybyte);
				publicKey = (RSAPublicKey) keyFactory.generatePublic(x509eks);
				System.out.println(publicKey.getAlgorithm());
			} else {
				PKCS8EncodedKeySpec pkcs8eks = new PKCS8EncodedKeySpec(keybyte);
				privateKey = (RSAPrivateKey) keyFactory
						.generatePrivate(pkcs8eks);
			}

		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (InvalidKeySpecException e) {
			e.printStackTrace();
		} finally {
			try {
				fis.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

}　　

代码中涉及到的Base64Util如下：

public class Base64Util
{
    
    private static final char S_BASE64CHAR[] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
                                                'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b',
                                                'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p',
                                                'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3',
                                                '4', '5', '6', '7', '8', '9', '+', '/' };
    private static final byte S_DECODETABLE[];
    
    static
    {
        S_DECODETABLE = new byte[128];
        for (int i = 0; i < S_DECODETABLE.length; i++)
            S_DECODETABLE[i] = 127;
        
        for (int i = 0; i < S_BASE64CHAR.length; i++)
            S_DECODETABLE[S_BASE64CHAR[i]] = (byte) i;
        
    }
    
    /**
     * 
     * @param ibuf
     * @param obuf
     * @param wp
     * @return
     */
    private static int decode0(char ibuf[], byte obuf[], int wp)
    {
        int outlen = 3;
        if (ibuf[3] == '=')
            outlen = 2;
        if (ibuf[2] == '=')
            outlen = 1;
        int b0 = S_DECODETABLE[ibuf[0]];
        int b1 = S_DECODETABLE[ibuf[1]];
        int b2 = S_DECODETABLE[ibuf[2]];
        int b3 = S_DECODETABLE[ibuf[3]];
        switch (outlen)
        {
            case 1: // '01'
                obuf[wp] = (byte) (b0 << 2 & 252 | b1 >> 4 & 3);
                return 1;
                
            case 2: // '02'
                obuf[wp++] = (byte) (b0 << 2 & 252 | b1 >> 4 & 3);
                obuf[wp] = (byte) (b1 << 4 & 240 | b2 >> 2 & 15);
                return 2;
                
            case 3: // '03'
                obuf[wp++] = (byte) (b0 << 2 & 252 | b1 >> 4 & 3);
                obuf[wp++] = (byte) (b1 << 4 & 240 | b2 >> 2 & 15);
                obuf[wp] = (byte) (b2 << 6 & 192 | b3 & 63);
                return 3;
        }
        throw new RuntimeException("Internal error");
    }
    
    /**
     * 
     * @param data
     * @param off
     * @param len
     * @return
     */
    public static byte[] decode(char data[], int off, int len)
    {
        char ibuf[] = new char[4];
        int ibufcount = 0;
        byte obuf[] = new byte[(len / 4) * 3 + 3];
        int obufcount = 0;
        for (int i = off; i < off + len; i++)
        {
            char ch = data[i];
            if (ch != '=' && (ch >= S_DECODETABLE.length || S_DECODETABLE[ch] == 127))
                continue;
            ibuf[ibufcount++] = ch;
            if (ibufcount == ibuf.length)
            {
                ibufcount = 0;
                obufcount += decode0(ibuf, obuf, obufcount);
            }
        }
        
        if (obufcount == obuf.length)
        {
            return obuf;
        }
        else
        {
            byte ret[] = new byte[obufcount];
            System.arraycopy(obuf, 0, ret, 0, obufcount);
            return ret;
        }
    }
    
    /**
     * 
     * @param data
     * @return
     */
    public static byte[] decode(String data)
    {
        char ibuf[] = new char[4];
        int ibufcount = 0;
        byte obuf[] = new byte[(data.length() / 4) * 3 + 3];
        int obufcount = 0;
        for (int i = 0; i < data.length(); i++)
        {
            char ch = data.charAt(i);
            if (ch != '=' && (ch >= S_DECODETABLE.length || S_DECODETABLE[ch] == 127))
                continue;
            ibuf[ibufcount++] = ch;
            if (ibufcount == ibuf.length)
            {
                ibufcount = 0;
                obufcount += decode0(ibuf, obuf, obufcount);
            }
        }
        
        if (obufcount == obuf.length)
        {
            return obuf;
        }
        else
        {
            byte ret[] = new byte[obufcount];
            System.arraycopy(obuf, 0, ret, 0, obufcount);
            return ret;
        }
    }
    
    /**
     * 
     * @param data
     * @param off
     * @param len
     * @param ostream
     * @throws IOException
     */
    public static void decode(char data[], int off, int len, OutputStream ostream) throws IOException
    {
        char ibuf[] = new char[4];
        int ibufcount = 0;
        byte obuf[] = new byte[3];
        for (int i = off; i < off + len; i++)
        {
            char ch = data[i];
            if (ch != '=' && (ch >= S_DECODETABLE.length || S_DECODETABLE[ch] == 127))
                continue;
            ibuf[ibufcount++] = ch;
            if (ibufcount == ibuf.length)
            {
                ibufcount = 0;
                int obufcount = decode0(ibuf, obuf, 0);
                ostream.write(obuf, 0, obufcount);
            }
        }
        
    }
    
    /**
     * 
     * @param data
     * @param ostream
     * @throws IOException
     */
    public static void decode(String data, OutputStream ostream) throws IOException
    {
        char ibuf[] = new char[4];
        int ibufcount = 0;
        byte obuf[] = new byte[3];
        for (int i = 0; i < data.length(); i++)
        {
            char ch = data.charAt(i);
            if (ch != '=' && (ch >= S_DECODETABLE.length || S_DECODETABLE[ch] == 127))
                continue;
            ibuf[ibufcount++] = ch;
            if (ibufcount == ibuf.length)
            {
                ibufcount = 0;
                int obufcount = decode0(ibuf, obuf, 0);
                ostream.write(obuf, 0, obufcount);
            }
        }
        
    }
    
    /**
     * 
     * @param data
     * @return
     */
    public static String encode(byte data[])
    {
        return encode(data, 0, data.length);
    }
    
    /**
     * 
     * @param data
     * @param off
     * @param len
     * @return
     */
    public static String encode(byte data[], int off, int len)
    {
        if (len <= 0)
            return "";
        char out[] = new char[(len / 3) * 4 + 4];
        int rindex = off;
        int windex = 0;
        int rest;
        for (rest = len - off; rest >= 3; rest -= 3)
        {
            int i = ((data[rindex] & 255) << 16) + ((data[rindex + 1] & 255) << 8) + (data[rindex + 2] & 255);
            out[windex++] = S_BASE64CHAR[i >> 18];
            out[windex++] = S_BASE64CHAR[i >> 12 & 63];
            out[windex++] = S_BASE64CHAR[i >> 6 & 63];
            out[windex++] = S_BASE64CHAR[i & 63];
            rindex += 3;
        }
        
        if (rest == 1)
        {
            int i = data[rindex] & 255;
            out[windex++] = S_BASE64CHAR[i >> 2];
            out[windex++] = S_BASE64CHAR[i << 4 & 63];
            out[windex++] = '=';
            out[windex++] = '=';
        }
        else if (rest == 2)
        {
            int i = ((data[rindex] & 255) << 8) + (data[rindex + 1] & 255);
            out[windex++] = S_BASE64CHAR[i >> 10];
            out[windex++] = S_BASE64CHAR[i >> 4 & 63];
            out[windex++] = S_BASE64CHAR[i << 2 & 63];
            out[windex++] = '=';
        }
        return new String(out, 0, windex);
    }
    
    /**
     * 
     * @param data
     * @param off
     * @param len
     * @param ostream
     * @throws IOException
     */
    public static void encode(byte data[], int off, int len, OutputStream ostream) throws IOException
    {
        if (len <= 0)
            return;
        byte out[] = new byte[4];
        int rindex = off;
        int rest;
        for (rest = len - off; rest >= 3; rest -= 3)
        {
            int i = ((data[rindex] & 255) << 16) + ((data[rindex + 1] & 255) << 8) + (data[rindex + 2] & 255);
            out[0] = (byte) S_BASE64CHAR[i >> 18];
            out[1] = (byte) S_BASE64CHAR[i >> 12 & 63];
            out[2] = (byte) S_BASE64CHAR[i >> 6 & 63];
            out[3] = (byte) S_BASE64CHAR[i & 63];
            ostream.write(out, 0, 4);
            rindex += 3;
        }
        
        if (rest == 1)
        {
            int i = data[rindex] & 255;
            out[0] = (byte) S_BASE64CHAR[i >> 2];
            out[1] = (byte) S_BASE64CHAR[i << 4 & 63];
            out[2] = 61;
            out[3] = 61;
            ostream.write(out, 0, 4);
        }
        else if (rest == 2)
        {
            int i = ((data[rindex] & 255) << 8) + (data[rindex + 1] & 255);
            out[0] = (byte) S_BASE64CHAR[i >> 10];
            out[1] = (byte) S_BASE64CHAR[i >> 4 & 63];
            out[2] = (byte) S_BASE64CHAR[i << 2 & 63];
            out[3] = 61;
            ostream.write(out, 0, 4);
        }
    }
    
    /**
     * 
     * @param data
     * @param off
     * @param len
     * @param writer
     * @throws IOException
     */
    public static void encode(byte data[], int off, int len, Writer writer) throws IOException
    {
        if (len <= 0)
            return;
        char out[] = new char[4];
        int rindex = off;
        int rest = len - off;
        int output = 0;
        do
        {
            if (rest < 3)
                break;
            int i = ((data[rindex] & 255) << 16) + ((data[rindex + 1] & 255) << 8) + (data[rindex + 2] & 255);
            out[0] = S_BASE64CHAR[i >> 18];
            out[1] = S_BASE64CHAR[i >> 12 & 63];
            out[2] = S_BASE64CHAR[i >> 6 & 63];
            out[3] = S_BASE64CHAR[i & 63];
            writer.write(out, 0, 4);
            rindex += 3;
            rest -= 3;
            if ((output += 4) % 76 == 0)
                writer.write("
");
        }
        while (true);
        if (rest == 1)
        {
            int i = data[rindex] & 255;
            out[0] = S_BASE64CHAR[i >> 2];
            out[1] = S_BASE64CHAR[i << 4 & 63];
            out[2] = '=';
            out[3] = '=';
            writer.write(out, 0, 4);
        }
        else if (rest == 2)
        {
            int i = ((data[rindex] & 255) << 8) + (data[rindex + 1] & 255);
            out[0] = S_BASE64CHAR[i >> 10];
            out[1] = S_BASE64CHAR[i >> 4 & 63];
            out[2] = S_BASE64CHAR[i << 2 & 63];
            out[3] = '=';
            writer.write(out, 0, 4);
        }
    }
    
}

　　

测试类：

public class RSATest {
	@Test
	public void test() {
		RSAGenerator rsaGenerator = new RSAGenerator().generateKeyPair();
		String str="数表的质数又称素数。指整数在一个大于1的自然数中，除了1和此整数自身外，没法被其他自然数整除的数";
		String encode = rsaGenerator.encryptByPublic(str);
		System.out.println(encode);
		System.out.println(rsaGenerator.decryptByPrivate(encode));
		
		System.out.println("用私钥加密公钥解密");
		String encrypt = rsaGenerator.encryptByPrivate(str);
		System.out.println(encrypt);
		System.out.println(rsaGenerator.decryptByPublic(encrypt));
	}
	
	@Test
	public void readKeyFromBase64File(){
		//从BASE64文件中读取KEY值
		RSAGenerator rsaGenerator = new RSAGenerator();
		rsaGenerator.getKeyFromBase64File("private.txt", RSAGenerator.KEY_TYPE_PRIVATE);
		rsaGenerator.getKeyFromBase64File("public.txt", RSAGenerator.KEY_TYPE_PUBLIC);
		String str="数表的质数又称素数。指整数在一个大于1的自然数中，除了1和此整数自身外，没法被其他自然数整除的数";
		String encode = rsaGenerator.encryptByPublic(str);
		System.out.println(encode);
		System.out.println(rsaGenerator.decryptByPrivate(encode));
	}
}

　以上代码大部分都是参考自网络，感谢网友的分享