业务场景

通常项目中的密码等敏感信息 不希望直接明文存储在数据库表中，希望加密存储到数据库中。这里提供一种加密解密工具

添加依赖

<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.8.0</version>
</dependency>

工具类

import java.io.File;
import java.nio.charset.Charset;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;

import javax.crypto.Cipher;

import org.apache.commons.io.FileUtils;

public class RSAUtil {

    private static String algorithm = "RSA"; // 加密算法
    private static String pubPath = "C:\\key\\publickey";
    private static String priPath = "C:\\key\\privatekey";

    /**
     * 生成密钥对并保存在本地文件中
     *
     * @param algorithm : 算法
     * @param pubPath   : 公钥保存路径
     * @param priPath   : 私钥保存路径
     * @throws Exception
     */
    public static void generateKeyToFile(String algorithm, String pubPath, String priPath) throws Exception {
        // 创建密钥对生成器对象
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
        // 生成密钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        // 生成公钥 私钥
        PublicKey publicKey = keyPair.getPublic();
        PrivateKey privateKey = keyPair.getPrivate();
        // 获取公私钥字节数组
        byte[] publicKeyEncoded = publicKey.getEncoded();
        byte[] privateKeyEncoded = privateKey.getEncoded();
        // 对公私钥进行base64编码
        String publicKeyString = Base64.getEncoder().encodeToString(publicKeyEncoded);
        String privateKeyString = Base64.getEncoder().encodeToString(privateKeyEncoded);
        // 保存公私钥到文件
        FileUtils.writeStringToFile(new File(pubPath), publicKeyString, Charset.forName("UTF-8"));
        FileUtils.writeStringToFile(new File(priPath), privateKeyString, Charset.forName("UTF-8"));

    }

    /**解密
     * @param encrypted:密文
     * @return:原文
     * @throws Exception
     */
    public static String decryptRSA(String encrypted) throws Exception {

        // 将文件内容转为字符串
        String privateKeyString = FileUtils.readFileToString(new File(priPath), Charset.defaultCharset());
        // 获取密钥工厂
        KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
        // 构建密钥规范 进行Base64解码
        PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(Base64.getDecoder().decode(privateKeyString));
        // 生成私钥
        PrivateKey key = keyFactory.generatePrivate(spec);

        // 创建加密对象
        Cipher cipher = Cipher.getInstance(algorithm);
        // 进行解密
        cipher.init(Cipher.DECRYPT_MODE, key);
        // 由于密文进行了Base64编码, 在这里需要进行解码
        byte[] decode = Base64.getDecoder().decode(encrypted);
        // 对密文进行解密，不需要使用base64，因为原文不会乱码
        byte[] bytes1 = cipher.doFinal(decode);
        return new String(bytes1);

    }

    /**
     * 使用密钥加密数据
     * 
     * @param input :原文
     * @return :密文
     * @throws Exception
     */
    public static String encryptRSA(String input) throws Exception {

        // 将文件内容转为字符串
        String publicKeyString = FileUtils.readFileToString(new File(pubPath), Charset.defaultCharset());
        // 获取密钥工厂
        KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
        // 构建密钥规范 进行Base64解码
        X509EncodedKeySpec spec = new X509EncodedKeySpec(Base64.getDecoder().decode(publicKeyString));

        PublicKey key = keyFactory.generatePublic(spec);

        // 创建加密对象
        Cipher cipher = Cipher.getInstance(algorithm);
        // 初始化加密
        cipher.init(Cipher.ENCRYPT_MODE, key);
        // 私钥加密
        byte[] bytes = cipher.doFinal(input.getBytes());
        // 对密文进行Base64编码
        return Base64.getEncoder().encodeToString(bytes);
    }
}

调用

调用generateKeyToFile()方法一次，生成密钥并保存到C:\key 中

需要加密时，在项目中调用RSAUtil.decryptRSA("input") 返回密文

需要解密时，在项目中调用RSAUtil.encryptRSA("input")返回明文