关于Java的PKCS8EcodedKeySpec类，为何提示未定义？

Question

如题，已经引入相关包（import java.security.spec.PKCS8EncodedKeySpec;），依然这么提示（已在代码中标出）
源代码如下（功能未完成）：

 package test;
import org.apache.common.code.binary.*;
import java.security.KeyPairGenerator;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.*;
public class TestRSA {
    public static void main(String[] args) {
        //初始化密钥
        try {
            KeyPairGenerator KeyPairGenerators=KeyPairGenerator.getInstance("RSA");
            KeyPairGenerators.initialize(512);
            KeyPair keypair=KeyPairGenerators.generateKeyPair();
            RSAPublicKey PublicKey=(RSAPublicKey)keypair.getPublic();
            RSAPrivateKey PrivateKey=(RSAPrivateKey)keypair.getPrivate();
            System.out.println("PublicKey"+Base64.encodeBase64String(PublicKey.getEncoded()));
            System.out.println("PrivateKey"+Base64.encodeBase64String(PrivateKey.getEncoded()));
            //公钥加密、私钥解密
            PKCS8EcodedKeySpec pkcs8encodedkey=new PKCS8EncodedKeySpec(PrivateKey.getEncoded());//     提示PKCS8EcodedKeySpec cannot be resolved to type
        } catch (NoSuchAlgorithmException e) {
            System.out.println("密钥算法生成错误！");
        }
    }
}

Answer 1

public class RSAEncrypt {

/**
* 字节数据转字符串专用集合
*/

private static final char[] HEX_CHAR = { '0', '1', '2', '3', '4', '5', '6',

'7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };

/** 
 * 随机生成密钥对 
 */  
public static void genKeyPair(String filePath) {  
    // KeyPairGenerator类用于生成公钥和私钥对，基于RSA算法生成对象  
    KeyPairGenerator keyPairGen = null;  
    try {  
        keyPairGen = KeyPairGenerator.getInstance("RSA");  
    } catch (NoSuchAlgorithmException e) {  
        // TODO Auto-generated catch block  
        e.printStackTrace();  
    }  
    // 初始化密钥对生成器，密钥大小为96-1024位  
    keyPairGen.initialize(1024,new SecureRandom());  
    // 生成一个密钥对，保存在keyPair中  
    KeyPair keyPair = keyPairGen.generateKeyPair();  
    // 得到私钥  
    RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();  
    // 得到公钥  
    RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();  
    try {  
        // 得到公钥字符串  
        String publicKeyString = Base64.encode(publicKey.getEncoded());  
        // 得到私钥字符串  
        String privateKeyString = Base64.encode(privateKey.getEncoded());  
        // 将密钥对写入到文件  
        FileWriter pubfw = new FileWriter(filePath + "/publicKey.keystore");  
        FileWriter prifw = new FileWriter(filePath + "/privateKey.keystore");  
        BufferedWriter pubbw = new BufferedWriter(pubfw);  
        BufferedWriter pribw = new BufferedWriter(prifw);  
        pubbw.write(publicKeyString);  
        pribw.write(privateKeyString);  
        pubbw.flush();  
        pubbw.close();  
        pubfw.close();  
        pribw.flush();  
        pribw.close();  
        prifw.close();  
    } catch (Exception e) {  
        e.printStackTrace();  
    }  
}  

/** 
 * 从文件中输入流中加载公钥 
 *  
 * @param in 
 *            公钥输入流 
 * @throws Exception 
 *             加载公钥时产生的异常 
 */  
public static String loadPublicKeyByFile(String path) throws Exception {  
    try {  
        BufferedReader br = new BufferedReader(new FileReader(path  
                + "/publicKey.keystore"));  
        String readLine = null;  
        StringBuilder sb = new StringBuilder();  
        while ((readLine = br.readLine()) != null) {  
            sb.append(readLine);  
        }  
        br.close();  
        return sb.toString();  
    } catch (IOException e) {  
        throw new Exception("公钥数据流读取错误");  
    } catch (NullPointerException e) {  
        throw new Exception("公钥输入流为空");  
    }  
}  

/** 
 * 从字符串中加载公钥 
 *  
 * @param publicKeyStr 
 *            公钥数据字符串 
 * @throws Exception 
 *             加载公钥时产生的异常 
 */  
public static RSAPublicKey loadPublicKeyByStr(String publicKeyStr)  
        throws Exception {  
    try {  
        byte[] buffer = Base64.decode(publicKeyStr);  
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");  
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);  
        return (RSAPublicKey) keyFactory.generatePublic(keySpec);  
    } catch (NoSuchAlgorithmException e) {  
        throw new Exception("无此算法");  
    } catch (InvalidKeySpecException e) {  
        throw new Exception("公钥非法");  
    } catch (NullPointerException e) {  
        throw new Exception("公钥数据为空");  
    }  
}  

/** 
 * 从文件中加载私钥 
 *  
 * @param keyFileName 
 *            私钥文件名 
 * @return 是否成功 
 * @throws Exception 
 */  
public static String loadPrivateKeyByFile(String path) throws Exception {  
    try {  
        BufferedReader br = new BufferedReader(new FileReader(path  
                + "/privateKey.keystore"));  
        String readLine = null;  
        StringBuilder sb = new StringBuilder();  
        while ((readLine = br.readLine()) != null) {  
            sb.append(readLine);  
        }  
        br.close();  
        return sb.toString();  
    } catch (IOException e) {  
        throw new Exception("私钥数据读取错误");  
    } catch (NullPointerException e) {  
        throw new Exception("私钥输入流为空");  
    }  
}  

public static RSAPrivateKey loadPrivateKeyByStr(String privateKeyStr)  
        throws Exception {  
    try {  
        byte[] buffer = Base64.decode(privateKeyStr);  
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer);  
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");  
        return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);  
    } catch (NoSuchAlgorithmException e) {  
        throw new Exception("无此算法");  
    } catch (InvalidKeySpecException e) {  
        throw new Exception("私钥非法");  
    } catch (NullPointerException e) {  
        throw new Exception("私钥数据为空");  
    }  
}  

/** 
 * 公钥加密过程 
 *  
 * @param publicKey 
 *            公钥 
 * @param plainTextData 
 *            明文数据 
 * @return 
 * @throws Exception 
 *             加密过程中的异常信息 
 */  
public static byte[] encrypt(RSAPublicKey publicKey, byte[] plainTextData)  
        throws Exception {  
    if (publicKey == null) {  
        throw new Exception("加密公钥为空, 请设置");  
    }  
    Cipher cipher = null;  
    try {  
        // 使用默认RSA  
        cipher = Cipher.getInstance("RSA");  
        // cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());  
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);  
        byte[] output = cipher.doFinal(plainTextData);  
        return output;  
    } catch (NoSuchAlgorithmException e) {  
        throw new Exception("无此加密算法");  
    } catch (NoSuchPaddingException e) {  
        e.printStackTrace();  
        return null;  
    } catch (InvalidKeyException e) {  
        throw new Exception("加密公钥非法,请检查");  
    } catch (IllegalBlockSizeException e) {  
        throw new Exception("明文长度非法");  
    } catch (BadPaddingException e) {  
        throw new Exception("明文数据已损坏");  
    }  
}  

/** 
 * 私钥加密过程 
 *  
 * @param privateKey 
 *            私钥 
 * @param plainTextData 
 *            明文数据 
 * @return 
 * @throws Exception 
 *             加密过程中的异常信息 
 */  
public static byte[] encrypt(RSAPrivateKey privateKey, byte[] plainTextData)  
        throws Exception {  
    if (privateKey == null) {  
        throw new Exception("加密私钥为空, 请设置");  
    }  
    Cipher cipher = null;  
    try {  
        // 使用默认RSA  
        cipher = Cipher.getInstance("RSA");  
        cipher.init(Cipher.ENCRYPT_MODE, privateKey);  
        byte[] output = cipher.doFinal(plainTextData);  
        return output;  
    } catch (NoSuchAlgorithmException e) {  
        throw new Exception("无此加密算法");  
    } catch (NoSuchPaddingException e) {  
        e.printStackTrace();  
        return null;  
    } catch (InvalidKeyException e) {  
        throw new Exception("加密私钥非法,请检查");  
    } catch (IllegalBlockSizeException e) {  
        throw new Exception("明文长度非法");  
    } catch (BadPaddingException e) {  
        throw new Exception("明文数据已损坏");  
    }  
}  

/** 
 * 私钥解密过程 
 *  
 * @param privateKey 
 *            私钥 
 * @param cipherData 
 *            密文数据 
 * @return 明文 
 * @throws Exception 
 *             解密过程中的异常信息 
 */  
public static byte[] decrypt(RSAPrivateKey privateKey, byte[] cipherData)  
        throws Exception {  
    if (privateKey == null) {  
        throw new Exception("解密私钥为空, 请设置");  
    }  
    Cipher cipher = null;  
    try {  
        // 使用默认RSA  
        cipher = Cipher.getInstance("RSA");  
        // cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());  
        cipher.init(Cipher.DECRYPT_MODE, privateKey);  
        byte[] output = cipher.doFinal(cipherData);  
        return output;  
    } catch (NoSuchAlgorithmException e) {  
        throw new Exception("无此解密算法");  
    } catch (NoSuchPaddingException e) {  
        e.printStackTrace();  
        return null;  
    } catch (InvalidKeyException e) {  
        throw new Exception("解密私钥非法,请检查");  
    } catch (IllegalBlockSizeException e) {  
        throw new Exception("密文长度非法");  
    } catch (BadPaddingException e) {  
        throw new Exception("密文数据已损坏");  
    }  
}  

/** 
 * 公钥解密过程 
 *  
 * @param publicKey 
 *            公钥 
 * @param cipherData 
 *            密文数据 
 * @return 明文 
 * @throws Exception 
 *             解密过程中的异常信息 
 */  
public static byte[] decrypt(RSAPublicKey publicKey, byte[] cipherData)  
        throws Exception {  
    if (publicKey == null) {  
        throw new Exception("解密公钥为空, 请设置");  
    }  
    Cipher cipher = null;  
    try {  
        // 使用默认RSA  
        cipher = Cipher.getInstance("RSA");  
        // cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());  
        cipher.init(Cipher.DECRYPT_MODE, publicKey);  
        byte[] output = cipher.doFinal(cipherData);  
        return output;  
    } catch (NoSuchAlgorithmException e) {  
        throw new Exception("无此解密算法");  
    } catch (NoSuchPaddingException e) {  
        e.printStackTrace();  
        return null;  
    } catch (InvalidKeyException e) {  
        throw new Exception("解密公钥非法,请检查");  
    } catch (IllegalBlockSizeException e) {  
        throw new Exception("密文长度非法");  
    } catch (BadPaddingException e) {  
        throw new Exception("密文数据已损坏");  
    }  
}  

/** 
 * 字节数据转十六进制字符串 
 *  
 * @param data 
 *            输入数据 
 * @return 十六进制内容 
 */  
public static String byteArrayToString(byte[] data) {  
    StringBuilder stringBuilder = new StringBuilder();  
    for (int i = 0; i < data.length; i++) {  
        // 取出字节的高四位 作为索引得到相应的十六进制标识符 注意无符号右移  
        stringBuilder.append(HEX_CHAR[(data[i] & 0xf0) >>> 4]);  
        // 取出字节的低四位 作为索引得到相应的十六进制标识符  
        stringBuilder.append(HEX_CHAR[(data[i] & 0x0f)]);  
        if (i < data.length - 1) {  
            stringBuilder.append(' ');  
        }  
    }  
    return stringBuilder.toString();  
}  

}