Java非对称加密(公钥加密，私钥解密)详解编程语言

import java.io.ByteArrayOutputStream; 
import java.io.File; 
import java.io.FileInputStream; 
import java.io.FileNotFoundException; 
import java.io.FileOutputStream; 
import java.io.IOException; 
import java.io.ObjectInputStream; 
import java.io.ObjectOutputStream; 
import java.security.Key; 
import java.security.KeyPair; 
import java.security.KeyPairGenerator; 
import javax.crypto.Cipher; 
 
/** 
 * 公钥加密，私钥解密(非对称加密) 
 *  
 */ 
public class AsymmetricEncryption { 
 
    public static void main(String[] args) throws Exception { 
        publicEnrypy(); 
        privateEncode(); 
    } 
 
    /** 
     * 加密的方法,使用公钥进行加密 
     * @throws Exception 
     */ 
    public static void publicEnrypy() throws Exception { 
 
        Cipher cipher = Cipher.getInstance("RSA"); 
 
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA"); 
 
        // 生成钥匙对 
        KeyPair keyPair = keyPairGenerator.generateKeyPair(); 
 
        // 得到公钥 
        Key publicKey = keyPair.getPublic(); 
 
        // 得到私钥 
        Key privateKey = keyPair.getPrivate(); 
 
        // 设置为加密模式 
        cipher.init(Cipher.ENCRYPT_MODE, publicKey); 
 
        // 对数据进行加密 
        byte[] result = cipher.doFinal("aaa".getBytes()); 
 
        //把私钥保存到硬盘上 
        saveKey(privateKey); 
 
        //把加密后的数据保存到硬盘上 
        saveData(result); 
    } 
 
    /** 
     * 解密的方法，使用私钥进行解密 
     * @throws Exception 
     */ 
    public static void privateEncode() throws Exception { 
        Cipher cipher = Cipher.getInstance("RSA"); 
 
        // 从硬盘中读取私钥 
        Key privateKey = loadKey(); 
 
        //设置为解密模式，用私钥解密 
        cipher.init(Cipher.DECRYPT_MODE, privateKey); 
 
        // 从硬盘中读取加密后的数据 
        byte[] data = loadData(); 
 
        //对加密后的数据进行解密，返回解密后的结果 
        byte[] result = cipher.doFinal(data); 
 
        System.out.println(new String(result)); 
    } 
 
    /** 
     * 从硬盘中加载加密后的文件 
     * @return 
     * @throws FileNotFoundException 
     * @throws IOException 
     */ 
    private static byte[] loadData() throws FileNotFoundException, IOException { 
        FileInputStream fileInputStream = new FileInputStream(new File( 
                "E://data.data")); 
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); 
 
        byte[] buffer = new byte[1024]; 
        int len = 0; 
 
        while ((len = fileInputStream.read(buffer)) != -1) { 
            outputStream.write(buffer, 0, len); 
        } 
 
        fileInputStream.close(); 
 
        return outputStream.toByteArray(); 
    } 
 
    /** 
     * 从硬盘中加载私钥 
     * @return 
     * @throws IOException 
     * @throws FileNotFoundException 
     * @throws ClassNotFoundException 
     */ 
    private static Key loadKey() throws IOException, FileNotFoundException, 
            ClassNotFoundException { 
        ObjectInputStream inputStream = new ObjectInputStream( 
                new FileInputStream(new File("E://private_key"))); 
        Key privateKey = (Key) inputStream.readObject(); 
        return privateKey; 
    } 
 
    /** 
     * 把加密后的密文保存到硬盘上 
     * @param result 
     * @throws FileNotFoundException 
     * @throws IOException 
     */ 
    private static void saveData(byte[] result) throws FileNotFoundException, 
            IOException { 
        FileOutputStream fileOutputStream = new FileOutputStream(new File( 
                "E://data.data")); 
        fileOutputStream.write(result); 
    } 
 
    /** 
     * 把私钥保存到硬盘上 
     * @param privateKey 
     * @throws IOException 
     * @throws FileNotFoundException 
     */ 
    private static void saveKey(Key privateKey) throws IOException, 
            FileNotFoundException { 
        ObjectOutputStream outputStream = new ObjectOutputStream( 
                new FileOutputStream(new File("E://private_key"))); 
        outputStream.writeObject(privateKey); 
    } 
 
}