pom
<dependency>
<groupId>com.esotericsoftware</groupId>
<artifactId>kryo</artifactId>
<version>5.0.3</version>
</dependency>
代码
import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.io.Input;
import com.esotericsoftware.kryo.io.Output;
import com.esotericsoftware.kryo.serializers.BeanSerializer;
import java.io.*;
import java.util.HashMap;
import java.util.Map;
/**
* 自定义对象序列化
* 将对象与字符串互转
*/
public class Serialization<T> {
public static void main(String[] args) throws Exception {
HashMap<String, String> map = new HashMap<>();
map.put("k1", "v1");
map.put("k2", "v2");
map.put("k3", "v3");
//标准序列化
byte[] bytes = objectToByte(map);//转字节
String toHexString = byteArrayToHexString(bytes);//转字符串
System.out.println("16进制字符串内容"+toHexString);
byte[] newBytes = hexStringToByteArray(toHexString);//转字节
Object obj = byteToObject(newBytes);//字节还原对象
HashMap<String, String> newMap = (HashMap<String, String>) obj;//验证
for (Map.Entry<String, String> entry : newMap.entrySet()) {
System.out.println(entry.getKey() + ":" + entry.getValue());
}
//最小序列化与反序列化(java自带的序列化比较大)
MyData data = new MyData(12);
byte[] bytes1 = objectToByte(data);//转字节
System.out.println(bytes1.length);
byte[] bytes2 = kryoObjectToByte(data);
System.out.println(bytes2.length);
MyData data1 = new Serialization<MyData>().kryoByteToObject(bytes2, MyData.class);
System.out.println(data1);
}
/**
* 对象转字节
*
* @param obj 对象
* @return 字节信息
* @throws Exception
*/
public static byte[] objectToByte(Object obj) throws Exception {
try {
ByteArrayOutputStream bo = new ByteArrayOutputStream();
ObjectOutputStream oo = new ObjectOutputStream(bo);
oo.writeObject(obj);
byte[] bytes = bo.toByteArray();
bo.close();
oo.close();
return (bytes);
} catch (Exception e) {
e.printStackTrace();
throw e;
}
}
/**
* 字节还原对象
*
* @param bytes
* @return
* @throws Exception
*/
public static Object byteToObject(byte[] bytes) throws Exception {
try {
ByteArrayInputStream bi = new ByteArrayInputStream(bytes);
ObjectInputStream oi = new ObjectInputStream(bi);
Object obj = oi.readObject();
bi.close();
oi.close();
return obj;
} catch (Exception e) {
throw e;
}
}
private static final char[] Chars = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
private static final String HexString = "0123456789abcdef";
/**
* 字节数组转换成16进制字符串
*
* @param arr
* @return content
*/
public static String byteArrayToHexString(byte[] arr) {
char[] c = new char[arr.length * 2];
int index = 0;
for (byte a : arr) {
c[index++] = Chars[a & 0xf];
c[index++] = Chars[a >>> 4 & 0xf];
}
String content = new String(c);
return content;
}
/**
* 16进制字符串转换成字节数组
*
* @param content
* @return
*/
public static byte[] hexStringToByteArray(String content) {
byte[] arr = new byte[content.length() / 2];
char[] crr = content.toCharArray();
int index = 0;
for (int i = 0; i < crr.length; ) {
int low = HexString.indexOf(crr[i++]);
int high = HexString.indexOf(crr[i++]);
arr[index++] = (byte) (high << 4 | low);
}
return arr;
}
/**
* 最小序列化kryo 对象转化为字节
*
* @param obj 需要转化的对象
* @return
* @throws Exception
*/
public static byte[] kryoObjectToByte(Object obj) throws Exception {
Kryo kryo = new Kryo();
kryo.register(obj.getClass(), new BeanSerializer(kryo, obj.getClass()));
ByteArrayOutputStream bo = new ByteArrayOutputStream();
ObjectOutputStream oo = new ObjectOutputStream(bo);
Output out = new Output(oo);
kryo.writeObject(out, obj);
out.flush();
out.close();
byte[] bytes = bo.toByteArray();
return bytes;
}
/**
* 最小反序列化kryo 将序列化的字节对象还原为对象
*
* @param bytes 字节对象
* @param type 泛型类型 泛型对象必须要有get/set/空构造函数
* @return
* @throws Exception
*/
public T kryoByteToObject(byte[] bytes, Class<T> type) throws Exception {
try {
Kryo kryo = new Kryo();
kryo.register(type, new BeanSerializer(kryo, type));
ByteArrayInputStream bi = new ByteArrayInputStream(bytes);
ObjectInputStream oi = new ObjectInputStream(bi);
Input input = new Input(oi);
T obj = (T) kryo.readObject(input, type);
input.close();
return obj;
} catch (Exception e) {
throw e;
}
}
}