`
jbgtwang
  • 浏览: 21785 次
  • 性别: Icon_minigender_1
  • 来自: 长沙
社区版块
存档分类
最新评论

java对象序列化、gzip压缩解压缩、加密解密

 
阅读更多

有时在应用中需要将java对象序列化存储起来，有的需要压缩，有的需要加密

 

EncryptUtil.java

package org.test.demo;

import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
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;

public class EncryptUtil {
	private final static String ENCRYPTKEY="0123456789";
	/**
	 * 
	  * @Title: getEncryptKey
	  * @Description: 检验加密key 
	  * @param encryptKey
	  * @return
	  * String
	  *
	 */
	private static String getEncryptKey(String encryptKey){
		if(null==encryptKey || "".equals(encryptKey)) return ENCRYPTKEY;
		return encryptKey;
	}
	
	/**
	 * 
	  * @Title: encrypt
	  * @Description: 加密:普通java字串加密成16进制字串(String -> Byte -> HexStr)
	  * @param content 要加密处理的字串
	  * @param encryptKey 加密密钥
	  * @return
	  * String
	  *
	 */
	public static String encrypt(String content, String encryptKey){
		byte[] encryptResult = encryptStrToByte(content, getEncryptKey(encryptKey));
		return parseByte2HexStr(encryptResult);
	}
	/**
	 * 
	  * @Title: decrypt
	  * @Description: 加密:16进制字串解密成普通java字串(HexStr -> Byte ->String) 
	  * @param content 要解密处理的16进制字串
	  * @param encryptKey 解密密钥
	  * @return
	  * String
	  *
	 */
	public static String decrypt(String content, String encryptKey){
		byte[] decryptFrom = parseHexStr2Byte(content);
		byte[] decryptResult = decrypt(decryptFrom,getEncryptKey(encryptKey));
		return new String(decryptResult);
	}
	/**
	* 加密:字串 --> 二进制
	* @param content 需要加密的内容
	* @param password 加密密码
	* @return
	*/
	private static byte[] encryptStrToByte(String content, String password) {
		try {
			KeyGenerator kgen = KeyGenerator.getInstance("AES");
			kgen.init(128, new SecureRandom(password.getBytes()));
			SecretKey secretKey = kgen.generateKey();
			byte[] enCodeFormat = secretKey.getEncoded();
			SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");
			Cipher cipher = Cipher.getInstance("AES");// 创建密码器
			byte[] byteContent = content.getBytes("utf-8");
			cipher.init(Cipher.ENCRYPT_MODE, key);// 初始化
			byte[] result = cipher.doFinal(byteContent);
			return result; // 加密
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (NoSuchPaddingException e) {
			e.printStackTrace();
		} catch (InvalidKeyException e) {
			e.printStackTrace();
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		} catch (IllegalBlockSizeException e) {
			e.printStackTrace();
		} catch (BadPaddingException e) {
			e.printStackTrace();
		}
		return null;
	}
	
	/**解密
	* @param content 待解密内容
	* @param password 解密密钥
	* @return
	*/
	private static byte[] decrypt(byte[] content, String password) {
		try {
			KeyGenerator kgen = KeyGenerator.getInstance("AES");
			kgen.init(128, new SecureRandom(password.getBytes()));
			SecretKey secretKey = kgen.generateKey();
			byte[] enCodeFormat = secretKey.getEncoded();
			SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");
			Cipher cipher = Cipher.getInstance("AES");// 创建密码器
			cipher.init(Cipher.DECRYPT_MODE, key);// 初始化
			byte[] result = cipher.doFinal(content);
			return result; // 加密
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (NoSuchPaddingException e) {
			e.printStackTrace();
		} catch (InvalidKeyException e) {
			e.printStackTrace();
		} catch (IllegalBlockSizeException e) {
			e.printStackTrace();
		} catch (BadPaddingException e) {
			e.printStackTrace();
		}
		return null;
	}
	
	/**将二进制转换成16进制
	* @param buf
	* @return
	*/
	private static String parseByte2HexStr(byte buf[]) {
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < buf.length; i++) {
			String hex = Integer.toHexString(buf[i] & 0xFF);
			if (hex.length() == 1) {
				hex = '0' + hex;
			}
			sb.append(hex.toUpperCase());
		}
		return sb.toString();
	}

	/**
	 * 将16进制转换为二进制
	 * 
	 * @param hexStr
	 * @return
	 */
	private static byte[] parseHexStr2Byte(String hexStr) {
		if (hexStr.length() < 1)
			return null;
		byte[] result = new byte[hexStr.length() / 2];
		for (int i = 0; i < hexStr.length() / 2; i++) {
			int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
			int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2),
					16);
			result[i] = (byte) (high * 16 + low);
		}
		return result;
	}
	
}

 

GZipUtils.java

	
package org.test.demo;

import java.io.ByteArrayInputStream;  
import java.io.ByteArrayOutputStream;  
import java.io.File;  
import java.io.FileInputStream;  
import java.io.FileOutputStream;  
import java.io.IOException;
import java.io.InputStream;  
import java.io.OutputStream;  
import java.util.zip.GZIPInputStream;  
import java.util.zip.GZIPOutputStream;  
  
/** 
 * GZIP工具 
 *  
 */  
public abstract class GZipUtils {  
  
    public static final int BUFFER = 1024;  
    public static final String EXT = ".gz";  
  
    /** 
     * 数据压缩 
     *  
     * @param data 
     * @return 
     * @throws IOException 
     * @throws Exception 
     */  
    public static byte[] compress(byte[] data) throws IOException {  
        ByteArrayInputStream bais = new ByteArrayInputStream(data);  
        ByteArrayOutputStream baos = new ByteArrayOutputStream();  
  
        // 压缩  
        compress(bais, baos);  
  
        byte[] output = baos.toByteArray();  
  
        baos.flush();  
        baos.close();  
  
        bais.close();  
  
        return output;  
    }  
  
    /** 
     * 文件压缩 
     *  
     * @param file 
     * @throws Exception 
     */  
    public static void compress(File file) throws Exception {  
        compress(file, true);  
    }  
  
    /** 
     * 文件压缩 
     *  
     * @param file 
     * @param delete 
     *            是否删除原始文件 
     * @throws Exception 
     */  
    public static void compress(File file, boolean delete) throws Exception {  
        FileInputStream fis = new FileInputStream(file);  
        FileOutputStream fos = new FileOutputStream(file.getPath() + EXT);  
  
        compress(fis, fos);  
  
        fis.close();  
        fos.flush();  
        fos.close();  
  
        if (delete) {  
            file.delete();  
        }  
    }  
  
    /** 
     * 数据压缩 
     *  
     * @param is 
     * @param os 
     * @throws IOException 
     * @throws Exception 
     */  
    public static void compress(InputStream is, OutputStream os) throws IOException  
             {  
  
        GZIPOutputStream gos = new GZIPOutputStream(os);  
  
        int count;  
        byte data[] = new byte[BUFFER];  
        while ((count = is.read(data, 0, BUFFER)) != -1) {  
            gos.write(data, 0, count);  
        }  
  
        gos.finish();  
  
        gos.flush();  
        gos.close();  
    }  
  
    /** 
     * 文件压缩 
     *  
     * @param path 
     * @throws Exception 
     */  
    public static void compress(String path) throws Exception {  
        compress(path, true);  
    }  
  
    /** 
     * 文件压缩 
     *  
     * @param path 
     * @param delete 
     *            是否删除原始文件 
     * @throws Exception 
     */  
    public static void compress(String path, boolean delete) throws Exception {  
        File file = new File(path);  
        compress(file, delete);  
    }  
  
    /** 
     * 数据解压缩 
     *  
     * @param data 
     * @return 
     * @throws IOException 
     * @throws Exception 
     */  
    public static byte[] decompress(byte[] data) throws IOException {  
        ByteArrayInputStream bais = new ByteArrayInputStream(data);  
        ByteArrayOutputStream baos = new ByteArrayOutputStream();  
  
        // 解压缩  
  
        decompress(bais, baos);  
  
        data = baos.toByteArray();  
  
        baos.flush();  
        baos.close();  
  
        bais.close();  
  
        return data;  
    }  
  
    /** 
     * 文件解压缩 
     *  
     * @param file 
     * @throws Exception 
     */  
    public static void decompress(File file) throws Exception {  
        decompress(file, true);  
    }  
  
    /** 
     * 文件解压缩 
     *  
     * @param file 
     * @param delete 
     *            是否删除原始文件 
     * @throws Exception 
     */  
    public static void decompress(File file, boolean delete) throws Exception {  
        FileInputStream fis = new FileInputStream(file);  
        FileOutputStream fos = new FileOutputStream(file.getPath().replace(EXT,  
                ""));  
        decompress(fis, fos);  
        fis.close();  
        fos.flush();  
        fos.close();  
  
        if (delete) {  
            file.delete();  
        }  
    }  
  
    /** 
     * 数据解压缩 
     *  
     * @param is 
     * @param os 
     * @throws IOException 
     * @throws Exception 
     */  
    public static void decompress(InputStream is, OutputStream os) throws IOException  
             {  
  
        GZIPInputStream gis = new GZIPInputStream(is);  
  
        int count;  
        byte data[] = new byte[BUFFER];  
        while ((count = gis.read(data, 0, BUFFER)) != -1) {  
            os.write(data, 0, count);  
        }  
  
        gis.close();  
    }  
  
    /** 
     * 文件解压缩 
     *  
     * @param path 
     * @throws Exception 
     */  
    public static void decompress(String path) throws Exception {  
        decompress(path, true);  
    }  
  
    /** 
     * 文件解压缩 
     *  
     * @param path 
     * @param delete 
     *            是否删除原始文件 
     * @throws Exception 
     */  
    public static void decompress(String path, boolean delete) throws Exception {  
        File file = new File(path);  
        decompress(file, delete);  
    }  
  
}

 

SerializeUtil.java

	
package org.test.demo;

import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.UnsupportedEncodingException;
import java.util.Map;

/**
 * 于对java数据进行序列化和反序列化处理
 * @author: 
 * @update: 2012-4-12 上午8:34:47
 */

public class SerializeUtil {
	
	public final static String CHARSET_ISO88591="iso-8859-1";
	/**
	  * @Title: serialize
	  * @Description: java对象序列化 <br>
	  * eg:<br>
	  *   Map<String,String> map = new HashMap<String,String>();<br>
	  *   map.put("test","序列化");<br>
	  *   String serializedMapStr=SerializeUtil.serialize(map);
	  * @param original 要进行序列化的java对象
	  * @return String 序列化的后的值
	  * @throws IOException
	  * 
	  * 
	  */
	public static String serialize(Object original) throws IOException {
		if(null==original) return null;
		ByteArrayOutputStream baos = new ByteArrayOutputStream();  
		ObjectOutputStream oos = new ObjectOutputStream(baos);  
		oos.writeObject(original);  
		byte[] str = baos.toByteArray();
		oos.close();
		baos.close();
		return new String(str,CHARSET_ISO88591);
	}
	
	/**
	  * @Title: deserialize
	  * @Description: 序列化的String对象的反序列化<br>
	  * 需要自己进行强制转换得到最终类型<br> 
	  * eg:<br>
	  *   Map newmap = (Map)SerializeUtil.deserialize(serializedMapStr); 
	  * @param serializedstr 经序列化处理过的信息
	  * @return Object 反序列化后生成的Object。<br>
	  * @throws IOException
	  * @throws UnsupportedEncodingException
	  * @throws ClassNotFoundException
	  * 
	  * 
	  */
	public static Object deserialize(String serializedstr) throws UnsupportedEncodingException, IOException, ClassNotFoundException{
		if(null==serializedstr)return null;
		BufferedInputStream bis=new BufferedInputStream(new ByteArrayInputStream(serializedstr.getBytes(CHARSET_ISO88591)));
		ObjectInputStream ois = new ObjectInputStream(bis);
		Object obj = ois.readObject();
		ois.close();
		bis.close();
		return obj;
	}
	
	public static byte[] objectToByteArray(Object original) throws IOException {
		if (null == original)
			return null;
		ByteArrayOutputStream bout = new ByteArrayOutputStream();
        try (ObjectOutputStream oout = new ObjectOutputStream(bout);) {
        	oout.writeObject(original);
        }
        return bout.toByteArray();
	}
	
	
	@SuppressWarnings("unchecked")
	public static Map<String, Object> byteArrayToObject(byte[] bytearry) throws IOException, ClassNotFoundException {
		if (bytearry.length==0) return null;
		return (Map<String, Object>)new ObjectInputStream(new ByteArrayInputStream(bytearry)).readObject();
	}
}

当然你序列化的类型不一定就是map，也可能是其他类型，这个要根据你的实际需要来改写SerializeUtil.java，直接返回Object类型

 

测试类：

package org.util.test;

import java.util.Map;
import java.util.HashMap;
import javax.servlet.http.Cookie;
import junit.framework.TestCase;
import java.util.String;

import org.test.demo.EncryptUtil;
import org.test.demo.GZipUtils;
import org.test.demo.SerializeUtil;

public class MainTest extends TestCase{
	public void testToCookie() throws Exception{
			Map<String,Human> map = new HashMap<String,Human>();
			
			map.put("test", "test");
			map.put("test2", 123);
			map.put("test3", new Cookie("cookie","cookievalue"));

			String datatemp = new String(GZipUtils.compress(SerializeUtil.objectToByteArray(map)),SerializeUtil.CHARSET_ISO88591);
			String str = EncryptUtil.encrypt(datatemp, "123");
			System.out.println("加密后:"+str);
			String str2 = EncryptUtil.decrypt(str, "123");
			System.out.println("解密后"+SerializeUtil.byteArrayToObject(GZipUtils.decompress(str2.getBytes(SerializeUtil.CHARSET_ISO88591))));
        

	}

}
分享到：
| Scheduled Jobs in Spring 3
评论
2 楼 terry21 2012-10-19  
找了半天
发现加密时byte[] byteContent = content.getBytes("utf-8");
解密的时候需要new String(decryptResult,"utf-8");
不然反序列化读取对象时会报错。
1 楼 terry21 2012-10-19  
@SuppressWarnings("unchecked")
public static Map<String, Object> byteArrayToObject(byte[] bytearry)
throws IOException, ClassNotFoundException {
if (bytearry.length == 0)
return null;
return (Map<String, Object>) new ObjectInputStream(
new ByteArrayInputStream(bytearry)).readObject();
}
在return语句报错了。。
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Java中文件的压缩

    这些文件表明这个压缩包可能包含了一个Java项目的API文档或教程，涵盖了文件压缩、加密和解密的相关知识。 总的来说，Java提供了丰富的库和工具来处理文件的压缩。无论是通过源码自定义压缩流程，还是利用已有的...

    java源码包---java 源码 大量 实例

    　Java生成密钥、保存密钥的实例源码，通过本源码可以了解到Java如何产生单钥加密的密钥(myKey)、产生双钥的密钥对(keyPair)、如何保存公钥的字节数组、保存私钥到文件privateKey.dat、如何用Java对象序列化保存私钥...

    java源码包3

    　Java生成密钥、保存密钥的实例源码，通过本源码可以了解到Java如何产生单钥加密的密钥(myKey)、产生双钥的密钥对(keyPair)、如何保存公钥的字节数组、保存私钥到文件privateKey.dat、如何用Java对象序列化保存私钥...

    java源码包2

    　Java生成密钥、保存密钥的实例源码，通过本源码可以了解到Java如何产生单钥加密的密钥(myKey)、产生双钥的密钥对(keyPair)、如何保存公钥的字节数组、保存私钥到文件privateKey.dat、如何用Java对象序列化保存私钥...

    成百上千个Java 源码DEMO 4(1-4是独立压缩包)

    密钥 Java生成密钥、保存密钥的实例源码，通过本源码可以了解到Java如何产生单钥加密的密钥(myKey)、产生双钥的密钥对(keyPair)、如何保存公钥的字节数组、保存私钥到文件privateKey.dat、如何用Java对象序列化保存...

    java源码包4

    　Java生成密钥、保存密钥的实例源码，通过本源码可以了解到Java如何产生单钥加密的密钥(myKey)、产生双钥的密钥对(keyPair)、如何保存公钥的字节数组、保存私钥到文件privateKey.dat、如何用Java对象序列化保存私钥...

    成百上千个Java 源码DEMO 3(1-4是独立压缩包)

    密钥 Java生成密钥、保存密钥的实例源码，通过本源码可以了解到Java如何产生单钥加密的密钥(myKey)、产生双钥的密钥对(keyPair)、如何保存公钥的字节数组、保存私钥到文件privateKey.dat、如何用Java对象序列化保存...

    网络游戏-一种游戏中XML数据序列化的存储方法及其专用存储装置.zip

    2. 序列化过程：在游戏环境中，XML数据序列化是指将游戏运行时的对象转换为XML字符串，以便于存储或传输。这通常涉及将游戏对象的属性映射到XML元素和属性，然后将整个数据结构转换为文本格式。反序列化则是相反的...

    Java IO处理类的汇总

    此外，还有对象流如ObjectInputStream和ObjectOutputStream，用于序列化和反序列化Java对象。 Java IO还引入了缓冲区的概念，提高了读写效率。BufferedInputStream、BufferedOutputStream、BufferedReader和...

    Sqllite查询分析器.zip

    5. Newtonsoft.Json.dll是Json.NET库，用于JSON序列化和反序列化，常用于数据交换和配置文件的读写。 综上所述，SQLite查询分析器是一个功能齐全的SQLite数据库管理工具，集成了数据压缩、加密以及丰富的用户界面...

    zlib算法库，zlib算法库

    1. 初始化压缩和解压缩流对象。 2. 使用`deflate()`或`inflate()`函数处理数据流。 3. 检查错误并释放资源。 ```c #include int main() { z_stream stream; stream.zalloc = Z_NULL; stream.zfree = Z_NULL; ...

    将NetworkStream与原始序列化，GZipStream和CryptoStream一起使用

    首先，通过`BinaryFormatter`对对象进行序列化，然后用`GZipStream`压缩数据，减少网络传输的数据量。接着，创建一个`CryptoStream`，用它来包装`GZipStream`，以加密压缩后的数据。最后，通过`NetworkStream`将加密...

    C#基类库大全(2014)

    提供了对文件操作、网络通信、HTTP交互、多线程、用户界面控件、Office文档处理、输入/输出（IO）、JSON序列化与反序列化、压缩与解压缩、文本字符串处理、正则表达式匹配、HTML解析、邮件发送、操作系统交互、...

    viewstate 服务器端存储或者压缩

    - 使用`ViewStateEncoder`类来自定义`ViewState`的序列化和反序列化过程，以优化存储效率。 - 考虑使用其他机制（如`Session`或数据库）存储部分数据，以减少`ViewState`的大小。 总之，`ViewState`是ASP.NET中的...

    第八章：附带的ChannelHandler和Codec.pdf

    6. **序列化数据**：在跨进程或网络传输对象时，需要将对象序列化为字节流。Netty支持多种序列化方式，包括常用的JDK序列化、JBoss编组（Boss Marshalling）和Google的Protocol Buffers（ProtoBuf）。选择合适的序列...

    commons-io所有版本（0.1-2.4）.zip

    5. 对象序列化：提供了对象到字节流和字节流到对象的转换，便于存储和传输Java对象。 6. 回行处理：支持不同操作系统下的回行换行符转换，使得跨平台的文本处理更加简单。 7. 数据编码解码：提供了Base64、Hex等编码...

    多年积累的c#常用类库大全源码

    这个类库可能包含了序列化和反序列化的功能，能够将C#对象转换为JSON字符串，或将JSON文本解析为C#对象，方便在网络间传输数据或者保存数据到文件。 条码类库则为应用程序增加了生成和识别条形码的能力。这在物流...

    mongodb c#驱动最新驱动mongodb.driver.dll 版本2.12.0-beta1

    MongoDB.Bson.dll 文件是 Bson（Binary JSON）的实现，Bson 是一种二进制形式的 JSON，它提供了更高效的数据序列化和反序列化机制，是 MongoDB 内部数据交换的主要格式。 mongodb.driver.core.dll 是驱动的核心组件...

    C#常用类库最新版

    9. **压缩与解压缩**：System.IO.Compression命名空间中的GZipStream、DeflateStream和ZipArchive类，实现了GZIP、DEFLATE和ZIP格式的压缩和解压缩功能。 10. **文本处理**：String类提供了丰富的文本处理方法，如...

    C#流操作C#流操作C#流操作

    - 序列化与反序列化过程中，`BinaryFormatter`和`DataContractSerializer`等工具会用到流来读写对象的状态。 总的来说，C#流操作是处理数据的核心机制，理解和熟练运用流能够高效地实现各种数据操作，如文件处理、...

Magicbox
Global site tag (gtag.js) - Google Analytics