Protostuff一键序列化工具、Protobuf JAVA实现
2017-11-01 11:09
435 查看
摘要: Protobuf JAVA实现,一键序列化,兼容Map、List、Set等
前言:由于搜集网络,发现Protostuff相关内容较少,故此发布这篇文章
序列化使其他代码可以查看或修改那些不序列化便无法访问的对象实例数据。确切地说,代码执行序列化需要特殊的权限:即指定了 SerializationFormatter 标志的 SecurityPermission。在默认策略下,通过 Internet 下载的代码或 Internet 代码不会授予该权限;只有本地计算机上的代码才被授予该权限。
通常,对象实例的所有字段都会被序列化,这意味着数据会被表示为实例的序列化数据。这样,能够解释该格式的代码有可能能够确定这些数据的值,而不依赖于该成员的可访问性。类似地,反序列化从序列化的表示形式中提取数据,并直接设置对象状态,这也与可访问性规则无关。
对于任何可能包含重要的安全性数据的对象,如果可能,应该使该对象不可序列化。如果它必须为可序列化的,请尝试生成特定字段来保存不可序列化的重要数据。如果无法实现这一点,则应注意该数据会被公开给任何拥有序列化权限的代码,并确保不让任何恶意代码获得该权限。
其中在某些特殊场景下,Json可能大于Jdk,Xml可能大于或小于Jdk。
原理分析:传统的Xml序列化,以字段名开头,字段名结尾,存在一个字段冗余,在某些特定的级别格式下,Xml报文长度过量冗余。
:Json序列化,某些Json序列化可能将空字段也序列化出来,如:{“user”:”null”},在过滤空的场景下,Json序列化内容比Jdk传统序列化体积小
:Jdk传统序列化,即实现Serializable接口的对象或数据模型转化为Byte数组,内容包含类信息、字段信息等,故此体积较大
:Protobuf序列化,讲对象或数据模型中有效的内容转化成Byte数组,不包括类信息与数据模型,再反序列化时需要指定目标数据结构,根据数据结构类型对应反序列化,由于仅仅包含内容,故此体积最小
由于json序列化和反序列化是完全基于反射,故此,json效率低于Jdk原生序列化
Jdk原生序列化属于基于半反射完成,效率高于Json
而Protobuf,相比jdk原生序列化来说,少做了很多事情,故此Protobuf效率较jdk原生序列化高出很多(排除谷歌对Protobuf的特定算法带来的优势)。
来源:http://blog.csdn.net/antgan/article/details/52103966
详细评测:http://www.52im.net/thread-772-1-1.html
工具类:
测试图:
前言:由于搜集网络,发现Protostuff相关内容较少,故此发布这篇文章
1. 何为序列化
序列化 (Serialization)将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间,对象将其当前状态写入到临时或持久性存储区。以后,可以通过从存储区中读取或反序列化对象的状态,重新创建该对象。序列化使其他代码可以查看或修改那些不序列化便无法访问的对象实例数据。确切地说,代码执行序列化需要特殊的权限:即指定了 SerializationFormatter 标志的 SecurityPermission。在默认策略下,通过 Internet 下载的代码或 Internet 代码不会授予该权限;只有本地计算机上的代码才被授予该权限。
通常,对象实例的所有字段都会被序列化,这意味着数据会被表示为实例的序列化数据。这样,能够解释该格式的代码有可能能够确定这些数据的值,而不依赖于该成员的可访问性。类似地,反序列化从序列化的表示形式中提取数据,并直接设置对象状态,这也与可访问性规则无关。
对于任何可能包含重要的安全性数据的对象,如果可能,应该使该对象不可序列化。如果它必须为可序列化的,请尝试生成特定字段来保存不可序列化的重要数据。如果无法实现这一点,则应注意该数据会被公开给任何拥有序列化权限的代码,并确保不让任何恶意代码获得该权限。
2. 常见的序列化有哪些
Xml、Json、JDK传统序列化、Protobuf序列化 (随口举例,笔者也懒得去收集了)3. 序列化体积对比
理论分析结论:Xml >或< Jdk原生> Json > Protobuf其中在某些特殊场景下,Json可能大于Jdk,Xml可能大于或小于Jdk。
原理分析:传统的Xml序列化,以字段名开头,字段名结尾,存在一个字段冗余,在某些特定的级别格式下,Xml报文长度过量冗余。
:Json序列化,某些Json序列化可能将空字段也序列化出来,如:{“user”:”null”},在过滤空的场景下,Json序列化内容比Jdk传统序列化体积小
:Jdk传统序列化,即实现Serializable接口的对象或数据模型转化为Byte数组,内容包含类信息、字段信息等,故此体积较大
:Protobuf序列化,讲对象或数据模型中有效的内容转化成Byte数组,不包括类信息与数据模型,再反序列化时需要指定目标数据结构,根据数据结构类型对应反序列化,由于仅仅包含内容,故此体积最小
4. 序列效率对比
根据第3点理论原理分析我们不难看出来,xml和json实际效率相差不多,可能就在于xml稍多的内容读写,故此xml效率低于json由于json序列化和反序列化是完全基于反射,故此,json效率低于Jdk原生序列化
Jdk原生序列化属于基于半反射完成,效率高于Json
而Protobuf,相比jdk原生序列化来说,少做了很多事情,故此Protobuf效率较jdk原生序列化高出很多(排除谷歌对Protobuf的特定算法带来的优势)。
5. 图标分析
笔者并非传说中的那么蛋疼,故此在网络收集相关评测结果。来源:http://blog.csdn.net/antgan/article/details/52103966
详细评测:http://www.52im.net/thread-772-1-1.html
6. 在JAVA中如何使用
maven引入:<dependency> <groupId>com.dyuproject.protostuff</groupId> <artifactId>protostuff-core</artifactId> <version>1.0.12</version> </dependency> <dependency> <groupId>com.dyuproject.protostuff</groupId> <artifactId>protostuff-runtime</artifactId> <version>1.0.12</version> </dependency>
工具类:
package com.protobuf.util; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.Serializable; import java.lang.reflect.Field; import java.util.ArrayList; import java.util.Collection; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; import java.util.concurrent.ConcurrentHashMap; import com.dyuproject.protostuff.LinkedBuffer; import com.dyuproject.protostuff.ProtostuffIOUtil; import com.dyuproject.protostuff.Schema; import com.dyuproject.protostuff.runtime.RuntimeSchema; @SuppressWarnings("unchecked") public class ProtobufUtil { private static Map<Class<?>, Schema<?>> cachedSchema = new ConcurrentHashMap<Class<?>, Schema<?>>(); private static Map<Class<?>, Field> wrapperMap = new ConcurrentHashMap<Class<?>, Field>(); private static Map<Class<?>, Object> unWrapperMap = new ConcurrentHashMap<Class<?>, Object>(); private static <T> Schema<T> getSchema(Class<T> cls) { Schema<T> schema = (Schema<T>) cachedSchema.get(cls); if (schema == null) { schema = RuntimeSchema.createFrom(cls); if (schema != null) { cachedSchema.put(cls, schema); } } return schema; } /** * 序列化 * * @param obj * @return */ public static <T> byte[] serialize(T obj) { if (isNullOrEmpty(obj)) { return null; } try { if(List.class.isAssignableFrom(obj.getClass())){ List<T> list=(List<T>)obj; Class<?> clazz=list.get(0).getClass(); byte [] data=serializeList(list); CustomWrapper wrapper=new CustomWrapper(clazz,data); return serializeT(wrapper); } if(Set.class.isAssignableFrom(obj.getClass())){ List<T> list=new ArrayList<T>((Set<T>)obj); Class<?> clazz=list.get(0).getClass(); byte [] data=serializeList(list); CustomWrapper wrapper=new CustomWrapper(clazz,data); return serializeT(wrapper); } if(ValueWrapper.isSpecialType(obj.getClass())){ ValueWrapper wrapper=new ValueWrapper(obj); return serializeT(wrapper); } return serializeT(obj); } catch (Exception e) { e.printStackTrace(); return null; } } public static <T> byte[] serializeList(List<T> objList) { if (objList == null || objList.isEmpty()) { throw new RuntimeException("序列化对象列表(" + objList + ")参数异常!"); } Schema<T> schema = (Schema<T>) RuntimeSchema.getSchema(objList.get(0).getClass()); LinkedBuffer buffer = LinkedBuffer.allocate(1024 * 1024); byte[] protostuff = null; ByteArrayOutputStream bos = null; try { bos = new ByteArrayOutputStream(); ProtostuffIOUtil.writeListTo(bos, objList, schema, buffer); protostuff = bos.toByteArray(); } catch (Exception e) { throw new RuntimeException("序列化对象列表(" + objList + ")发生异常!", e); } finally { buffer.clear(); try { if(bos!=null){ bos.close(); } } catch (IOException e) { e.printStackTrace(); } } return protostuff; } private static <T> byte[] serializeT(T obj) { Class<T> cls = (Class<T>) obj.getClass(); LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.MIN_BUFFER_SIZE); try { Schema<T> schema = getSchema(cls); return ProtostuffIOUtil.toByteArray(obj, schema, buffer); } catch (Exception e) { throw new IllegalStateException(e.getMessage(), e); } finally { buffer.clear(); } } /** * 反序列化 * * @param data * @param cls * @return */ public static <T> T unSerialize(byte[] data,Class<?> clazz) { if (isNullOrEmpty(data)) { return null; } try { if(List.class.isAssignableFrom(clazz)){ CustomWrapper wrapper= unSerializeT(data, CustomWrapper.class); return (T) unSerializeList(data, wrapper.getClazz()); } if(Set.class.isAssignableFrom(clazz)){ CustomWrapper wrapper= unSerializeT(data, CustomWrapper.class); return (T) unSerializeSet(data, wrapper.getClazz()); } if(ValueWrapper.isSpecialType(clazz)){ ValueWrapper wrapper= unSerializeT(data, ValueWrapper.class); if(wrapper==null||isNullOrEmpty(wrapper)){ return null; } return wrapper.getValue(); } return (T) unSerializeT(data, clazz); } catch (Exception e) { e.printStackTrace(); return null; } } public static <T> Set<T> unSerializeSet(byte[] data, Class<T> clazz) { if (data == null || data.length == 0) { throw new RuntimeException("反序列化对象发生异常,byte序列为空!"); } Schema<T> schema = RuntimeSchema.getSchema(clazz); try { List<T> list = ProtostuffIOUtil.parseListFrom(new ByteArrayInputStream(data), schema); return new HashSet<T>(list); } catch (IOException e) { throw new RuntimeException("反序列化对象列表发生异常!",e); } } public static <T> List<T> unSerializeList(byte[] data, Class<T> clazz) { if (data == null || data.length == 0) { throw new RuntimeException("反序列化对象发生异常,byte序列为空!"); } Schema<T> schema = RuntimeSchema.getSchema(clazz); List<T> result = null; try { result = ProtostuffIOUtil.parseListFrom(new ByteArrayInputStream(data), schema); } catch (IOException e) { throw new RuntimeException("反序列化对象列表发生异常!",e); } return result; } private static <T> T unSerializeT(byte[] data, Class<T> cls) { try { T message = cls.newInstance(); Schema<T> schema = getSchema(cls); ProtostuffIOUtil.mergeFrom(data, message, schema); return message; } catch (Exception e) { throw new IllegalStateException(e.getMessage(), e); } } public static boolean isNullOrEmpty(Object obj) { try { if (obj == null) return true; if (obj instanceof CharSequence) { return ((CharSequence) obj).length() == 0; } if (obj instanceof Collection) { return ((Collection<?>) obj).isEmpty(); } if (obj instanceof Map) { return ((Map<?, ?>) obj).isEmpty(); } if (obj instanceof Object[]) { Object[] object = (Object[]) obj; if (object.length == 0) { return true; } boolean empty = true; for (int i = 0; i < object.length; i++) { if (!isNullOrEmpty(object[i])) { empty = false; break; } } return empty; } return false; } catch (Exception e) { e.printStackTrace(); return true; } } @SuppressWarnings({ "serial" }) public static class CustomWrapper implements Serializable{ private Class<?> clazz; private byte []data; public CustomWrapper(){} public CustomWrapper(Class<?> clazz,byte[] data){ this.clazz=clazz; this.data=data; } public byte[] getData() { return data; } public void setData(byte[] data) { this.data = data; } public Class<?> getClazz() { return clazz; } public void setClazz(Class<?> clazz) { this.clazz = clazz; } } @SuppressWarnings({ "rawtypes", "serial", "unused" }) public static class ValueWrapper implements Serializable{ private Map mapValue; private List listValue; private Collection collectionValue; private Iterable iterableValue; private Set setValue; private String stringValue; private Byte byteValue; private Short shortValue; private Long longValue; private Integer integerValue; private Double doubleValue; private Float floatValue; private Character characterValue; private Boolean booleanValue; public ValueWrapper(){} public ValueWrapper(Object data) throws IllegalArgumentException, IllegalAccessException { if (data == null) { return; } if (isNullOrEmpty(wrapperMap)) { initFiledType(); } if (wrapperMap.containsKey(data.getClass())) { Field f = wrapperMap.get(data.getClass()); f.setAccessible(true); f.set(this, data); } for (Class<?> clazz : wrapperMap.keySet()) { if (!clazz.isAssignableFrom(data.getClass())) { continue; } Field f = wrapperMap.get(clazz); f.setAccessible(true); f.set(this, data); wrapperMap.put(data.getClass(), f); return; } } public static boolean isSpecialType(Class<?> clazz){ if (isNullOrEmpty(wrapperMap)) { initFiledType(); } if(unWrapperMap.containsKey(clazz)){ return false; } if(wrapperMap.containsKey(clazz)){ return true; } for (Class<?> clazzTmp : wrapperMap.keySet()) { if (!clazzTmp.isAssignableFrom(clazz)) { continue; } Field f = wrapperMap.get(clazzTmp); f.setAccessible(true); wrapperMap.put(clazz, f); return true; } unWrapperMap.put(clazz, clazz); return false; } private static void initFiledType() { Field[] fields = ValueWrapper.class.getDeclaredFields(); for (Field f : fields) { wrapperMap.put(f.getType(), f); } } public <T> T getValue() throws IllegalArgumentException, IllegalAccessException { for (Class<?> clazz : wrapperMap.keySet()) { T result = (T) wrapperMap.get(clazz).get(this); if (isNullOrEmpty(result)) { continue; } return result; } return null; } } }
测试图:
相关文章推荐
- java序列化/反序列化之xml、protobuf、protostuff 的比较与使用例子
- java序列化/反序列化之xstream、protobuf、protostuff 的比较与使用例子
- java序列化/反序列化之xstream、protobuf、protostuff 的比较与使用例子
- java序列化/反序列化之xstream、protobuf、protostuff 的比较与使用例子
- java序列化/反序列化之xml、protobuf、protostuff 的比较与使用例子
- google protobuf 升级版 com.dyuproject.protostuff java 序列化
- java序列化/反序列化之xstream、protobuf、protostuff 的比较与使用例子
- Java数据通讯中使用Google Protobuf实现序列化与反序列化
- Java利用protostuff实现高效序列化
- 序列化框架性能对比(kryo、hessian、java、protostuff)
- Simple-Spring-Memcached使用Protobuf序列化Java对象
- c#序列化与反序列化通用方法, 使用protobuf-net实现
- protobuf实现c++与java之间的数据传递,beancopy数据到前台
- [java]序列化框架性能对比(kryo、hessian、java、protostuff)
- 关于数据序列化(1)protobuf 示例(目前不支持Java8貌似)
- 序列化框架的使用及性能对比Kryo、Hessian、Protostuff、java原生
- Unity3D & Java 基于 Protobuf 通信实现
- c++ java中关于protobuf反序列化对象实体和实体处理(函数)关系 (一)
- 序列化框架性能对比(kryo、hessian、java、protostuff)
- Google Protobuf——实现跨平台跨语言的序列化/反序列化