SpingMVC（6）使用的AES对称加密工具类

对称加密工具类

package util;
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.io.UnsupportedEncodingException;
import java.math.BigInteger;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.security.InvalidKeyException;
/**
 * 对称加密，用于加密json并保存到cookie
 * @author Lenovo
 *
 */
import java.security.Key;
//import java.util.Base64;
import java.security.NoSuchAlgorithmException;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

import org.apache.commons.codec.binary.Base64;

import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;

import entity.Student;

//import org.bouncycastle.util.encoders.Base64;

/**
 * API地址：
 * https://nowjava.com/docs/java-api-11/java.base/javax/crypto/KeyGenerator.html
 * @author Lenovo
 *
 */
public class AESUtils {
	static {
		if(!isKeyExists()) {//true，key存在,!isKeyExit()=>true=>isKeyExit()false,key不存在
			writeKey(createKey());//创建key
		}
		
	}
	
	/**
	  * 系统自动创建一个key
	 * @return 
	 */
	private static Key createKey() {
		Key key =null;
		try {
			  //生成key
	          KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
	          //设置密钥长度
	          //初始化此密钥生成器，使其具有确定的密钥大小  
	          //AES 要求密钥长度为 128
	          keyGenerator.init(128);
	          //生成密钥对象
	          //SecretKey	generateKey()：生成密钥。
	          SecretKey secretKey = keyGenerator.generateKey();//系统自动生成，每次创建皆有不同
	          //获取密钥，返回一个字节数组
	          //getEncoded方法不是SecretKey类的，而是Key接口的方法
	          //以主编码格式返回密钥，如果此密钥不支持编码，则返回null。
	          byte[] keyBytes = secretKey.getEncoded();
	          
	          //key转换
	          //SecretKeySpec​(byte[] key,String algorithm)
	          //从给定的字节数组构造一个密钥。
	          //key - 密钥的密钥材料。 复制数组的内容以防止后续修改。
	          //algorithm - 与给定密钥材料关联的密钥算法的名称
	          key = new SecretKeySpec(keyBytes,"AES");
		} catch (NoSuchAlgorithmException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return key;
	}

	/**
	 * 附带json加密
	 * @param <T>
	 * @param key
	 * @return
	 */
	public static <T> String key2Json4Encode(T key) {
		ObjectMapper mapper=new ObjectMapper();
		String urlEncode = null;
		try {
			String mapJakcson =mapper.writeValueAsString(key);//编码为json
			String encodeBase64=Base64.encodeBase64String(mapJakcson.getBytes());//加密，encodeBase64String
			urlEncode = URLEncoder.encode(encodeBase64,"UTF-8");//加密，网络url
		} catch (JsonProcessingException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		} catch (UnsupportedEncodingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return urlEncode;
	}
	
	/**
	 * 转为json
	 * @param <T>
	 * @param key
	 * @return
	 */
	public static <T> String key2Json(T key) {
		ObjectMapper mapper=new ObjectMapper();
		String mapJackson = null;
		try {
			mapJackson =mapper.writeValueAsString(key);//编码为json
		} catch (JsonProcessingException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		} 
		return mapJackson;
	}
	
	/**
	 * 使用Class<T>定义返回值的类型
	 * <T>是关键
	 * @param keyJson
	 * @param clazz
	 * @return
	 */
	public static <T> T json4Decode2Key(String keyJson,Class<T> clazz) {//直接String无法还原，这里使用json
		ObjectMapper mapper=new ObjectMapper();
		T t = null;
		//T t = (T) clazz.getConstructor().newInstance();
		try {
			String urlDecode = URLDecoder.decode(keyJson,"UTF-8");//解码，网络url
			byte[] decodeBase64 = Base64.decodeBase64(urlDecode);//解码，decodeBase64
			t=mapper.readValue(decodeBase64, clazz);//json还原为对象
		} catch (UnsupportedEncodingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (JsonParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (JsonMappingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return t;
	}
	
	/**
	 * 使用Class<T>定义返回值的类型
	 * <T>是关键
	 * @param keyJson
	 * @param clazz
	 * @return
	 */
	public static <T> T json2Key(String keyJson,Class<T> clazz) {//直接String无法还原，这里使用json
		ObjectMapper mapper=new ObjectMapper();
		T t = null;
		try {
			t=mapper.readValue(keyJson, clazz);//将json还原为对象
		} catch (JsonParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (JsonMappingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return t;
	}

	/**
	 * 
	 * @param string
	 * @param key
	 * @return
	 */
	public static String encode(String string,Key key) {
		String urlEncode=null;
		try {
			//加密，"AES/ECB/PKCS5Padding"是一个转换的Cipher对象标准（默认这个即可）
	        Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
	        
	        //初始化，设置为加密
	        //init​(int opmode, Key key):使用密钥初始化此密码。
	        //密码初始化为以下四种操作之一：加密，解密，密钥包装或密钥解包，具体取决于opmode的值。
	        //opmode -此cipher的操作模式（这是下列之一： ENCRYPT_MODE ， DECRYPT_MODE ， WRAP_MODE或 UNWRAP_MODE ）
	        //key - 关键
	        //ENCRYPT_MODE常量用于将密码初始化为加密模式。
	        cipher.init(Cipher.ENCRYPT_MODE, key);
	        
	        //在单部分操作中加密或解密数据，或完成多部分操作。 
	        //数据经过加密或解密，具体取决于此密码的初始化方式。(此时为ENCRYPT_MODE加密)
	        byte[] result = cipher.doFinal(string.getBytes());//1.加密后的byte数组
	        
	        String encodeBase64=Base64.encodeBase64String(result);//2.加密后的字符串
	        urlEncode=URLEncoder.encode(encodeBase64,"UTF-8");//3.符合URL编码规则的字符串
		}catch (NoSuchAlgorithmException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (NoSuchPaddingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (UnsupportedEncodingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalBlockSizeException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (BadPaddingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InvalidKeyException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return urlEncode;
	}
	
	public static String decode(String urlEncode,Key key) {
		byte[] result = null;
		try {
			//加密，"AES/ECB/PKCS5Padding"是一个转换的Cipher对象标准（默认这个即可）
	        Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
	        
	        //初始化,设置为解密 
	        //DECRYPT_MODE常量用于将密码初始化为解密模式。
	        cipher.init(Cipher.DECRYPT_MODE, key);
	        
	        String urlDecode = URLDecoder.decode(urlEncode,"UTF-8");//1.将url编码解密
	        byte[] decodeBase64 = Base64.decodeBase64(urlDecode);//2.将Base64编码解密回byte数组
	        
	        //在单部分操作中加密或解密数据，或完成多部分操作。 
	        //数据经过加密或解密，具体取决于此密码的初始化方式。(此时为DECRYPT_MODE解密)
	        result = cipher.doFinal(decodeBase64);//3.将数组解密回为对称加密的数组
	    }catch (NoSuchAlgorithmException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (NoSuchPaddingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (UnsupportedEncodingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalBlockSizeException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (BadPaddingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InvalidKeyException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return new String(result);
	}

	//反序列化
    public static Key readKey(){
    	ObjectInputStream ois =null;
        Key key=null;
		try {
			ois = new ObjectInputStream(new FileInputStream("key.pem"));
			Object obj=ois.readObject();
			key=(Key)obj;
	        ois.close();
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			if(ois!=null) {
				try {
					ois.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
        
        return key;
    }

    //序列化
    private static void writeKey(Key key){
    	ObjectOutputStream oos=null;
        try {
        	oos=new ObjectOutputStream(new FileOutputStream("key.pem"));
			oos.writeObject(key);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			if(oos!=null) {
				try {
					oos.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
    }
    /**
     * key存在返回true
     * @return
     */
    private static boolean isKeyExists() {
		File file=new File("key.pem");
		if(file.exists()) {//key存在，返回true
			return true;
		}
		return false;
	}
}