参考了下面这个博主的文章，很有收获，简单处理后记录一下

RSA加密、解密、签名、验签的原理及方法 - PC君 - 博客园

工具类自带生成秘钥的方法，也可以用第三方工具生成秘钥

package com.example.performance_analysis.utils;

import org.apache.tomcat.util.codec.binary.Base64;

import java.io.ByteArrayOutputStream;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import javax.crypto.Cipher;

public class RSAUtil {
/**
* RSA最大加密明文大小
*/
private static final int MAX_ENCRYPT_BLOCK = 117;

/\*\*  
 \* RSA最大解密密文大小  
 \*/  
private static final int MAX\_DECRYPT\_BLOCK = 128;

/\*\*  
 \* // 生成密钥对  
 \* KeyPair keyPair = getKeyPair();  
 \* String privateKey = new String(Base64.encodeBase64(keyPair.getPrivate().getEncoded()));  
 \* String publicKey = new String(Base64.encodeBase64(keyPair.getPublic().getEncoded()));  
 \*/

/\*\*  
 \* 获取密钥对  
 \*  
 \* @return 密钥对  
 \*/  
public static KeyPair getKeyPair() throws Exception {  
    KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA");  
    generator.initialize(1024);  
    return generator.generateKeyPair();  
}

/\*\*  
 \* 获取私钥  
 \*  
 \* @param privateKey 私钥字符串  
 \* @return  
 \*/  
public static PrivateKey getPrivateKey(String privateKey) throws Exception {  
    KeyFactory keyFactory = KeyFactory.getInstance("RSA");  
    byte\[\] decodedKey = Base64.decodeBase64(privateKey.getBytes());  
    PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(decodedKey);  
    return keyFactory.generatePrivate(keySpec);  
}

/\*\*  
 \* 获取公钥  
 \*  
 \* @param publicKey 公钥字符串  
 \* @return  
 \*/  
public static PublicKey getPublicKey(String publicKey) throws Exception {  
    KeyFactory keyFactory = KeyFactory.getInstance("RSA");  
    byte\[\] decodedKey = Base64.decodeBase64(publicKey.getBytes());  
    X509EncodedKeySpec keySpec = new X509EncodedKeySpec(decodedKey);  
    return keyFactory.generatePublic(keySpec);  
}

/\*\*  
 \* RSA加密  
 \*  
 \* @param data      待加密数据  
 \* @param publicKey 公钥  
 \* @return  
 \*/  
public static String encrypt(String data, String publicKey) throws Exception {  
    return encrypt(data, getPublicKey(publicKey));  
}

/\*\*  
 \* RSA加密  
 \*  
 \* @param data      待加密数据  
 \* @param publicKey 公钥  
 \* @return  
 \*/  
public static String encrypt(String data, PublicKey publicKey) throws Exception {  
    Cipher cipher = Cipher.getInstance("RSA");  
    cipher.init(Cipher.ENCRYPT\_MODE, publicKey);  
    int inputLen = data.getBytes().length;  
    ByteArrayOutputStream out = new ByteArrayOutputStream();  
    int offset = 0;  
    byte\[\] cache;  
    int i = 0;  
    // 对数据分段加密  
    while (inputLen - offset > 0) {  
        if (inputLen - offset > MAX\_ENCRYPT\_BLOCK) {  
            cache = cipher.doFinal(data.getBytes(), offset, MAX\_ENCRYPT\_BLOCK);  
        } else {  
            cache = cipher.doFinal(data.getBytes(), offset, inputLen - offset);  
        }  
        out.write(cache, 0, cache.length);  
        i++;  
        offset = i \* MAX\_ENCRYPT\_BLOCK;  
    }  
    byte\[\] encryptedData = out.toByteArray();  
    out.close();  
    // 获取加密内容使用base64进行编码,并以UTF-8为标准转化成字符串  
    // 加密后的字符串  
    return new String(Base64.encodeBase64String(encryptedData));  
}

/\*\*  
 \* RSA解密  
 \*  
 \* @param data       待解密数据  
 \* @param privateKey 私钥  
 \* @return  
 \*/  
public static String decrypt(String data, String privateKey) throws Exception {  
    return decrypt(data, getPrivateKey(privateKey));  
}

/\*\*  
 \* RSA解密  
 \*  
 \* @param data       待解密数据  
 \* @param privateKey 私钥  
 \* @return  
 \*/  
public static String decrypt(String data, PrivateKey privateKey) throws Exception {  
    Cipher cipher = Cipher.getInstance("RSA");  
    cipher.init(Cipher.DECRYPT\_MODE, privateKey);  
    byte\[\] dataBytes = Base64.decodeBase64(data);  
    int inputLen = dataBytes.length;  
    ByteArrayOutputStream out = new ByteArrayOutputStream();  
    int offset = 0;  
    byte\[\] cache;  
    int i = 0;  
    // 对数据分段解密  
    while (inputLen - offset > 0) {  
        if (inputLen - offset > MAX\_DECRYPT\_BLOCK) {  
            cache = cipher.doFinal(dataBytes, offset, MAX\_DECRYPT\_BLOCK);  
        } else {  
            cache = cipher.doFinal(dataBytes, offset, inputLen - offset);  
        }  
        out.write(cache, 0, cache.length);  
        i++;  
        offset = i \* MAX\_DECRYPT\_BLOCK;  
    }  
    byte\[\] decryptedData = out.toByteArray();  
    out.close();  
    // 解密后的内容  
    return new String(decryptedData, "UTF-8");  
}

/\*\*  
 \* 签名  
 \*  
 \* @param data       待签名数据  
 \* @param privateKey 私钥  
 \* @return 签名  
 \*/  
public static String sign(String data, String privateKey) throws Exception {  
    return sign(data, getPrivateKey(privateKey));  
}

/\*\*  
 \* 签名  
 \*  
 \* @param data       待签名数据  
 \* @param privateKey 私钥  
 \* @return 签名  
 \*/  
public static String sign(String data, PrivateKey privateKey) throws Exception {  
    byte\[\] keyBytes = privateKey.getEncoded();  
    PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);  
    KeyFactory keyFactory = KeyFactory.getInstance("RSA");  
    PrivateKey key = keyFactory.generatePrivate(keySpec);  
    Signature signature = Signature.getInstance("MD5withRSA");  
    signature.initSign(key);  
    signature.update(data.getBytes());  
    return new String(Base64.encodeBase64(signature.sign()));  
}

/\*\*  
 \* 验签  
 \*  
 \* @param srcData   原始字符串  
 \* @param publicKey 公钥  
 \* @param sign      签名  
 \* @return 是否验签通过  
 \*/  
public static boolean verify(String srcData, String publicKey, String sign) throws Exception {  
    return verify(srcData, publicKey, sign);  
}

/\*\*  
 \* 验签  
 \*  
 \* @param srcData   原始字符串  
 \* @param publicKey 公钥  
 \* @param sign      签名  
 \* @return 是否验签通过  
 \*/  
public static boolean verify(String srcData, PublicKey publicKey, String sign) throws Exception {  
    byte\[\] keyBytes = publicKey.getEncoded();  
    X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);  
    KeyFactory keyFactory = KeyFactory.getInstance("RSA");  
    PublicKey key = keyFactory.generatePublic(keySpec);  
    Signature signature = Signature.getInstance("MD5withRSA");  
    signature.initVerify(key);  
    signature.update(srcData.getBytes());  
    return signature.verify(Base64.decodeBase64(sign.getBytes()));  
}  

}