序列化工具類

序列化即將對象序列化為字節數組，反序列化就是將字節數組恢復成對象。

主要的目的是方便傳輸和存儲。

序列化工具類：

public class SerializeUtil {

private static Map, Schema>> cachedSchema = new ConcurrentHashMap<>();

private static Objenesis objenesis = new ObjenesisStd(true);

/**

* jdk 序列化工具的序列化與反序列化

*

* @param object

* @return

* @throws IOException

*/

public static byte[] JDKObjectToBytes(Object object) throws IOException {

ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

ObjectOutput objectOutput = new ObjectOutputStream(byteArrayOutputStream);

objectOutput.writeObject(object);

return byteArrayOutputStream.toByteArray();

}

public static T JDKBytesToObject(byte[] bytes, Class clazz) throws Exception {

ObjectInputStream objectInputStream = new ObjectInputStream(new ByteArrayInputStream(bytes));

Object object = objectInputStream.readObject();

return (T) object;

}

/**

* 使用fastjson實現序列化和反序列化

*

* @param object

* @return

*/

public static byte[] FastJsonObjectToBytes(Object object) {

byte[] bytes = JSON.toJSONBytes(object);

return bytes;

}

/**

* fastjosn反序列化時，class必須要有默認構造函數，否則報錯

* @param bytes

* @param clazz

* @param

* @return

*/

public static T FastJsonBytesToObject(byte[] bytes, Class clazz) {

return (T) JSON.parseObject(bytes, clazz);

}

/**

* 使用protostuff序列化

* @param obj

* @param

* @return

*/

public static byte[] serialize(T obj) {

Class cls = (Class) obj.getClass();

LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);

try {

Schema schema = getSchema(cls);

return ProtostuffIOUtil.toByteArray(obj, schema, buffer);

} catch (Exception e) {

throw new IllegalStateException(e.getMessage(), e);

} finally {

buffer.clear();

}

}

public static T deserialize(byte[] data, Class cls) {

try {

T message = objenesis.newInstance(cls);

Schema schema = getSchema(cls);

ProtostuffIOUtil.mergeFrom(data, message, schema);

return message;

} catch (Exception e) {

throw new IllegalStateException(e.getMessage(), e);

}

}

/**

* 緩存schema

* @param cls

* @param

* @return

*/

private static Schema getSchema(Class cls) {

Schema schema = (Schema) cachedSchema.get(cls);

if (schema == null) {

schema = RuntimeSchema.createFrom(cls);

if (schema != null) {

cachedSchema.put(cls, schema);

}

}

return schema;

}

}

此類分別包含jdk序列化、fastjson序列化、protobuf序列化三種序列化方式。

注意prostuff需要包含maven依賴：

org.objenesis

objenesis

2.6

io.protostuff

protostuff-core

1.4.0

io.protostuff

protostuff-runtime

1.4.0

com.alibaba

fastjson

1.2.31

使用

首先定義一個類用于測試,注意此類沒有默認構造函數。

public class Monster implements Serializable{

Integer hp;

Integer mp;

String name;

Integer level;

public Monster(String name,Integer level){

this.name=name;

this.level=level;

}

//省略getter、setter、hashCode、equals...

}

測試類：

public class SerializeUtilTest {

Monster monster = new Monster("boss", 100);

Class clazz = Monster.class;

@Test

public void jdkSerializeTest() throws Exception {

byte[] bytes = SerializeUtil.JDKObjectToBytes(monster);

System.out.println(bytes.length);

Monster object = SerializeUtil.JDKBytesToObject(bytes,clazz);

Assert.assertEquals(object, monster);

}

@Test(expected = com.alibaba.fastjson.JSONException.class)

public void fastJsonSerializeTest(){

byte[] bytes = SerializeUtil.FastJsonObjectToBytes(monster);

System.out.println(bytes.length);

Monster object = SerializeUtil.FastJsonBytesToObject(bytes,clazz);

Assert.assertEquals(object, monster);

}

@Test

public void serialize(){

byte[] serialize = SerializeUtil.serialize(monster);

System.out.println(serialize.length);

Object deserialize = SerializeUtil.deserialize(serialize, clazz);

Assert.assertEquals(deserialize,monster);

}

}

輸出分別為199、27、8。

可以看出jdk默認序列化方式的效率極低，protobuf效率和字節都非常高效。

特別注意：fastjson反序列化的對象必須要有默認構造函數，否則會報錯。protostuff使用objenesis不需要默認構函數創建對象。但是json格式可讀性好，性能也還可以，推薦性能不高的場景優先json格式，對性能要求高的場景使用protostuff。

與50位技術專家面對面20年技術見證，附贈技術全景圖

總結

以上是生活随笔為你收集整理的java get方法不序列化_java常用序列化与反序列化方法的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。