java序列化之protobuf
package com.book.core.test;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import com.book.core.model.Type;
import com.book.core.serializable.SerializationUtil;
import com.dyuproject.protostuff.LinkedBuffer;
import com.dyuproject.protostuff.ProtobufIOUtil;
import com.dyuproject.protostuff.ProtostuffIOUtil;
import com.dyuproject.protostuff.Schema;
import com.dyuproject.protostuff.runtime.RuntimeSchema;
/**
* ProtoStuff測試
* @author liweihan
*
*/
public class TestProtoStuff {
public static void main(String[] args) throws Exception {
/**
* *********** 測試1 : 原始的序列化對象 ************
*/
//序列化
System.out.println(" ========= 序列化開始:" );
Schema<Type> schema = RuntimeSchema.getSchema(Type.class);
Type type = new Type();
type.setCityId(1);
type.setPrice(new BigDecimal(100));
type.setTypeName("韓超");
LinkedBuffer buffer = LinkedBuffer.allocate(1024);
byte[] data = ProtobufIOUtil.toByteArray(type, schema, buffer);
System.out.println("序列化後的大小:" + data.length + " 字節 !");
//反序列化
System.out.println(" ========= 反序列化開始:" );
Type type2 = new Type();
ProtobufIOUtil.mergeFrom(data, type2, schema);
System.out.println(" ====== 反序列化後的結果爲：cityId:" + type2.getCityId()
+ " ,typeName:" + type2.getTypeName()
+ " , price:" + type2.getPrice());
/**
* ************ 測試2 ：單獨序列化集合 **************
*/
Type t1 = new Type();
t1.setId(1);
t1.setCityId(1);
t1.setPrice(new BigDecimal(1));
t1.setTypeName("TestHan");
List<Type> list1 = new ArrayList<Type>();
list1.add(t1);
list1.add(type);
System.out.println(" *********** 序列化開始： ");
List<byte[]> result = serializeProtoStuffTypeList(list1);
System.out.println("序列化後集合的大小:" + result.size());
System.out.println(" *********** 反序列化開始： ");
List<Type> l = deserializeProtoStuffToTypeList(result);
System.out.println(" 反序列化後的集合大小爲:" + l.size() + " , name1:" + l.get(0).getTypeName());
/*********** 測試 3 *****************/
Type type1 = new Type();
type1.setCityId(2);
type1.setPrice(new BigDecimal(100));
type1.setTypeName("太");
System.out.println(" ------ 序列化開始：");
byte[] type1Ser = SerializationUtil.object2Bytes_obj(type1);
System.out.println(" ------- 序列化後的大小：" + type1Ser.length);
System.out.println(" ------ 反序列化開始：");
Type type1Result = (Type)SerializationUtil.bytes2Object(type1Ser);
System.out.println(" ====== 反序列化後的結果爲：cityId:" + type1Result.getCityId()
+ " ,typeName:" + type1Result.getTypeName()
+ " , price:" + type1Result.getPrice());
/******************** 測試4 :序列化集合 **********************/
Type t2 = new Type();
t2.setId(2);
t2.setCityId(2);
t2.setPrice(new BigDecimal(23));
t2.setTypeName("ZHANG");
ArrayList<Type> list2 = new ArrayList<Type>();
list2.add(t2);
list2.add(t1);
System.out.println(" ++++++++++++++ 序列化開始： ");
byte[] result2 = SerializationUtil.object2Bytes(list2);
System.out.println(" 序列化的大小： " + result2.length);
System.out.println(" ++++++++++++++ 序列化結束： ");
List<Type> listResult = (List<Type>)SerializationUtil.bytes2Object(result2);
for (Type t: listResult) {
System.out.println(t.getTypeName());
}
}
/**
* 序列化Type的List集合
* @param tList
* @return
*/
public static List<byte[]> serializeProtoStuffTypeList(List<Type> tList) {
if (tList == null || tList.size() <= 0) {
return null;
}
List<byte[]> bytes = new ArrayList<byte[]>();
Schema<Type> schema = RuntimeSchema.getSchema(Type.class);
LinkedBuffer buffer = LinkedBuffer.allocate(1024);
byte[] protostuff = null;
for(Type t: tList) {
try {
protostuff = ProtostuffIOUtil.toByteArray(t, schema, buffer);
bytes.add(protostuff);
} catch (Exception e) {
e.printStackTrace();
} finally {
buffer.clear();
}
}
return bytes;
}
/**
* 反序列化Type的List集合
* @param bytesList
* @return
*/
public static List<Type> deserializeProtoStuffToTypeList(List<byte[]> bytesList) {
if (bytesList == null || bytesList.size() <= 0) {
return null;
}
Schema<Type> schema = RuntimeSchema.getSchema(Type.class);
List<Type> list = new ArrayList<Type>();
for (byte[] bs : bytesList) {
Type type = new Type();
ProtostuffIOUtil.mergeFrom(bs, type, schema);
list.add(type);
}
return list;
}
}
package com.book.core.serializable;
import java.io.Serializable;
public class SerializationUtil {
public static ProtostuffSerializer protostuffSerializer;
static {
protostuffSerializer = new ProtostuffSerializer();
}
public static byte[] object2Bytes(Serializable obj) throws Exception {
if (obj == null) {
return null;
}
return protostuffSerializer.serialize(obj);
/* ByteArrayOutputStream bo = new ByteArrayOutputStream();
ObjectOutputStream oo = new ObjectOutputStream(bo);
oo.writeObject(obj);
bo.close();
oo.close();
return bo.toByteArray();*/
}
/**
* 序列化【序列化對象不須要實現Serializable】
* @param obj
* @return
* @throws Exception
*/
public static byte[] object2Bytes_obj(Object obj) throws Exception {
if (obj == null) {
return null;
}
return protostuffSerializer.serialize(obj);
}
public static byte[][] objects2Bytes(Serializable[] obj) throws Exception {
if (obj == null) {
return null;
}
byte[][] many = new byte[obj.length][];
for(int i=0;i<obj.length;i++){
many[i] = object2Bytes(obj[i]);
}
return many;
}
public static Object bytes2Object(byte[] objBytes) throws Exception {
if (objBytes == null || objBytes.length == 0) {
return null;
}
Object obj = protostuffSerializer.deserialize(objBytes);
return obj;
/*ByteArrayInputStream bi = new ByteArrayInputStream(objBytes);
ObjectInputStream oi = new ObjectInputStream(bi);
obj = oi.readObject();
bi.close();
oi.close();
return obj;*/
}
}
package com.book.core.serializable;
import com.dyuproject.protostuff.LinkedBuffer;
import com.dyuproject.protostuff.ProtostuffIOUtil;
import com.dyuproject.protostuff.Schema;
import com.dyuproject.protostuff.runtime.RuntimeSchema;
import java.util.concurrent.ConcurrentHashMap;
public class ProtostuffSerializer {
private static ConcurrentHashMap<Class<?>, Schema<?>> cachedSchema = new ConcurrentHashMap<Class<?>, Schema<?>>();
public <T> byte[] serialize(final T source) {
VO<T> vo = new VO<T>(source);
final LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);
try {
final Schema<VO> schema = getSchema(VO.class);
return serializeInternal(vo, schema, buffer);
} catch (final Exception e) {
throw new IllegalStateException(e.getMessage(), e);
} finally {
buffer.clear();
}
}
public <T> T deserialize(final byte[] bytes) {
try {
Schema<VO> schema = getSchema(VO.class);
VO vo = deserializeInternal(bytes, schema.newMessage(), schema);
if (vo != null && vo.getValue() != null) {
return (T) vo.getValue();
}
} catch (final Exception e) {
throw new IllegalStateException(e.getMessage(), e);
}
return null;
}
private <T> byte[] serializeInternal(final T source, final Schema<T> schema, final LinkedBuffer buffer) {
return ProtostuffIOUtil.toByteArray(source, schema, buffer);
}
private <T> T deserializeInternal(final byte[] bytes, final T result, final Schema<T> schema) {
ProtostuffIOUtil.mergeFrom(bytes, result, schema);
return result;
}
private static <T> Schema<T> getSchema(Class<T> clazz) {
@SuppressWarnings("unchecked")
Schema<T> schema = (Schema<T>) cachedSchema.get(clazz);
if (schema == null) {
schema = RuntimeSchema.createFrom(clazz);
cachedSchema.put(clazz, schema);
}
return schema;
}
}
package com.book.core.serializable;
import java.io.Serializable;
/**
* Created by yijunzhang on 14-4-2.
*/
public class VO<T> implements Serializable {
private T value;
public VO(T value) {
this.value = value;
}
public VO() {
}
public T getValue() {
return value;
}
@Override
public String toString() {
return "VO{" +
"value=" + value +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof VO)) return false;
VO vo = (VO) o;
if (value != null ? !value.equals(vo.value) : vo.value != null) return false;
return true;
}
@Override
public int hashCode() {
return value != null ? value.hashCode() : 0;
}
}
package com.book.core.model;
import java.math.BigDecimal;
public class Type {
private Integer id;
private String typeName;
private BigDecimal price;
private Integer cityId;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getTypeName() {
return typeName;
}
public void setTypeName(String typeName) {
this.typeName = typeName == null ? null : typeName.trim();
}
public BigDecimal getPrice() {
return price;
}
public void setPrice(BigDecimal price) {
this.price = price;
}
public Integer getCityId() {
return cityId;
}
public void setCityId(Integer cityId) {
this.cityId = cityId;
}
}
<dependency>
<groupId>com.dyuproject.protostuff</groupId>
<artifactId>protostuff-core</artifactId>
<version>${protostuff.version}</version>
</dependency>
<dependency>
<groupId>com.dyuproject.protostuff</groupId>
<artifactId>protostuff-runtime</artifactId>
<version>${protostuff.version}</version>
</dependency>
<dependency>
<groupId>com.dyuproject.protostuff</groupId>
<artifactId>protostuff-api</artifactId>
<version>${protostuff.version}</version>
</dependency>
<dependency>
<groupId>com.dyuproject.protostuff</groupId>
<artifactId>protostuff-collectionschema</artifactId>
<version>${protostuff.version}</version>
</dependency>
<protostuff.version>1.0.8</protostuff.version>
序列化的幾種方式html
http://my-corner.iteye.com/blog/1776512 java
Java序列化簡單瞭解git
http://hanchaohan.blog.51cto.com/2996417/922470 github
jprotobuf的簡單瞭解redis
https://github.com/jhunters/jprotobuf json
java序列化/反序列化之xstream、protobuf、protostuff 的比較與使用例子api
http://www.cnblogs.com/xiaoMzjm/p/4555209.html 緩存
注意事項:String對象要不要序列化的問題，我的建議不要。ide
返回一個JSON類型的字符串。
咱們須要把字符串存入redis緩存中,咱們有3中方式緩存
1:直接存儲String對象
2:序列化String對象後，存入redis
3:轉爲JSON對象,序列化JSON對象後,存入redis
下面咱們打印一下三種方式,所佔用的空間大小,咱們發現序列化後，對象大小都普通增大了。
這樣，會多佔用咱們緩存的空間。
【若是是json string類型的 能夠不序列化 redis的客戶端會作getbytes作字節流的轉換 其實就是作string的序列化】
相關文章
- 1. netty序列化之protoBuf
- 2. c++ protobuf序列化
- 3. protobuf-net序列化反序列化
- 4. java序列化/反序列化之xstream、protobuf、protostuff 的比較與使用例子
- 5. google protobuf序列化原理
- 6. java之序列化與反序列化
- 7. 透過byte數組簡單分析Java序列化、Kryo、ProtoBuf序列化
- 8. Java數據通信中使用Googgle Protobuf 序列化與反序列化
- 9. protobuf-net的序列化與反序列化（本地存儲）
- 10. protobuf--數據序列化及反序列化
- 更多相關文章...
- • C# 排序列表（SortedList） - C#教程
- • 在Java程序中使用Redis - Redis教程
- • 算法總結-歸併排序
- • Java 8 Stream 教程
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. eclipse設置粘貼字符串自動轉義
- 2. android客戶端學習-啓動模擬器異常Emulator: failed to initialize HAX: Invalid argument
- 3. android.view.InflateException: class com.jpardogo.listbuddies.lib.views.ListBuddiesLayout問題
- 4. MYSQL8.0數據庫恢復 MYSQL8.0ibd數據恢復 MYSQL8.0恢復數據庫
- 5. 你本是一個肉體，是什麼驅使你前行【1】
- 6. 2018.04.30
- 7. 2018.04.30
- 8. 你本是一個肉體，是什麼驅使你前行【3】
- 9. 你本是一個肉體，是什麼驅使你前行【2】
- 10. 【資訊】LocalBitcoins達到每週交易比特幣的7年低點
歡迎關注本站公眾號,獲取更多信息
相關文章