//此处省略部分代码
 private static final String ALG = "RSA";

 private static final String PUBLIC_KEY_HEADER = "-----BEGIN PUBLIC KEY-----";

 private static final String PUBLIC_KEY_FOOTER = "-----END PUBLIC KEY-----";

 //此处省略部分代码

// 解析PublicKey
 public static Optional<PublicKey> getDERPublicKeyFromPEMString(String keyString) {
        String content = keyString
                .replace(PUBLIC_KEY_HEADER, "")
                .replace(PUBLIC_KEY_FOOTER, "")
                .replaceAll("\\s", "");   
        byte[] contentBytes = Base64.decodeBase64(content);

        try {
            KeyFactory keyFactory = KeyFactory.getInstance(ALG);
            return Optional.of(keyFactory.generatePublic(new X509EncodedKeySpec(contentBytes)));
        } catch (NoSuchAlgorithmException | InvalidKeySpecException e) {
            return Optional.empty();
        }
}

// 省略部分代码

private static final String UNENCRYPTED_PRIVATE_KEY_HEADER = "-----BEGIN PRIVATE KEY-----";

private static final String UNENCRYPTED_PRIVATE_KEY_FOOTER = "-----END PRIVATE KEY-----";

private static final String ENCRYPTED_PRIVATE_KEY_HEADER = "-----BEGIN ENCRYPTED PRIVATE KEY-----";

private static final String ENCRYPTED_PRIVATE_KEY_FOOTER = "-----END ENCRYPTED PRIVATE KEY-----";

// 省略部分代码

// 解析PrivateKey
public static Optional<PrivateKey> getDERPrivateKeyFromPEMString(String keyString, String password) {
        try {
            KeyFactory keyFactory = KeyFactory.getInstance(ALG);
            if (isEncrypted(keyString)) {
                return Optional.ofNullable(keyFactory.generatePrivate(getEncryptedPrivateKeySpec(keyString, password)));
            }
            return Optional.ofNullable(keyFactory.generatePrivate(getUnencryptedPrivateKeySpec(keyString)));
        } catch (NoSuchAlgorithmException | InvalidKeySpecException e) {
            return Optional.empty();
        }
}

// 未加密的PrivateKey
public static PKCS8EncodedKeySpec getUnencryptedPrivateKeySpec(String keyString) {
        String content = keyString
                .replace(UNENCRYPTED_PRIVATE_KEY_HEADER, "")
                .replace(UNENCRYPTED_PRIVATE_KEY_FOOTER, "")
                .replaceAll("\\s", "");
        byte[] contentBytes = Base64.decodeBase64(content);

        return new PKCS8EncodedKeySpec(contentBytes);
}

// 加密的PrivateKey
public static PKCS8EncodedKeySpec getEncryptedPrivateKeySpec(String keyString, String password) {
        String content = keyString
                .replace(ENCRYPTED_PRIVATE_KEY_HEADER, "")
                .replace(ENCRYPTED_PRIVATE_KEY_FOOTER, "")
                .replaceAll("\\s", "");
        byte[] contentBytes = Base64.decodeBase64(content);

        try {
            EncryptedPrivateKeyInfo epkInfo = new EncryptedPrivateKeyInfo(contentBytes);
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(epkInfo.getAlgName());
            PBEKeySpec pbeKeySpec = new PBEKeySpec(password.toCharArray());
            SecretKey secretKey = keyFactory.generateSecret(pbeKeySpec);

            Cipher cipher = Cipher.getInstance(epkInfo.getAlgName());
            cipher.init(Cipher.DECRYPT_MODE, secretKey, epkInfo.getAlgParameters());

            return epkInfo.getKeySpec(cipher);

        } catch (IOException | NoSuchAlgorithmException
                | InvalidKeySpecException | NoSuchPaddingException
                | InvalidKeyException | InvalidAlgorithmParameterException e) {
            return null;
        }
}

private static boolean isEncrypted(String keyString) {
        return keyString.contains(ENCRYPTED_PRIVATE_KEY_HEADER);
}