之前曾经写了两篇java的序列的机制,一种是默认的java序列化机制,这种方式效率太低。另外一种是谷歌的protobuf,但是这种我们还要写proto文件,并且我们还要使用工具来编译生成java文件,实在太麻烦。但是protostuff却不一样,能够很好的解决上面两者的问题。这篇文章就研究一下如何去使用,并对其进行一个简单的分析。
一、认识protostuff
其实protostuff也是有局限性的,比如说在序列化的文件在10M以下的时候,还是使用java自带的序列化机制比较好,但是文件比较大的时候还是protostuff好一点,这里的10M不是严格的界限。
protostuff也是谷歌的产品,它是基于protobuf发展而来的,相对于protobuf提供了更多的功能和更简易的用法。
废话不多说,直接看一下protoStuff是如何使用的吧。
二、代码实现
环境准备:添加依赖或者是jar
<dependency>
<groupId>io.protostuff</groupId>
<artifactId>protostuff-core</artifactId>
<version>1.6.0</version>
</dependency>
<dependency>
<groupId>io.protostuff</groupId>
<artifactId>protostuff-runtime</artifactId>
<version>1.6.0</version>
</dependency>
这里我使用了maven,直接添加依赖即可,如果你没有使用maven,在百度上搜索相应的jar包就好了。
1、定义要序列化的bean
首先是学生类
public class Student {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
//getter和setter方法
//toString方法
}
然后是学校类
public class School {
private String schoolName;
private List<Student> students;
public School(String schoolName, List<Student> students) {
this.schoolName = schoolName;
this.students = students;
}
//getter和setter方法
//toString方法
}
在这里我们真正要序列化的是School,但是为了使得例子更有说服力,于是就在School里面定义了Student。
2、protoStuff序列化工具类
public class ProtostuffUtils {
//避免每次序列化都重新申请Buffer空间
private static LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);
//缓存Schema
private static Map<Class<?>, Schema<?>> schemaCache = new ConcurrentHashMap<Class<?>, Schema<?>>();
//序列化方法,把指定对象序列化成字节数组
@SuppressWarnings("unchecked")
public static <T> byte[] serialize(T obj) {
Class<T> clazz = (Class<T>) obj.getClass();
Schema<T> schema = getSchema(clazz);
byte[] data;
try {
data = ProtostuffIOUtil.toByteArray(obj, schema, buffer);
} finally {
buffer.clear();
}
return data;
}
//反序列化方法,将字节数组反序列化成指定Class类型
public static <T> T deserialize(byte[] data, Class<T> clazz) {
Schema<T> schema = getSchema(clazz);
T obj = schema.newMessage();
ProtostuffIOUtil.mergeFrom(data, obj, schema);
return obj;
}
@SuppressWarnings("unchecked")
private static <T> Schema<T> getSchema(Class<T> clazz) {
Schema<T> schema = (Schema<T>) schemaCache.get(clazz);
if (schema == null) {
schema = RuntimeSchema.getSchema(clazz);
if (schema != null) {
schemaCache.put(clazz, schema);
}
}
return schema;
}
}
这其实就是一个工具类,这里面的代码可以不用更改,直接拿过来就可以使用了。不过在这里有必要对里面的一些字段方法等进行一个说明。
(1)字段LinkedBuffer
这个字段表示,申请一个内存空间用户缓存,LinkedBuffer.DEFAULT_BUFFER_SIZE表示申请了默认大小的空间512个字节,我们也可以使用MIN_BUFFER_SIZE,表示256个字节。
(2)字段schemaCache
这个字段表示缓存的Schema。那这个Schema是什么呢?就是一个组织结构,就好比是数据库中的表、视图等等这样的组织机构,在这里表示的就是序列化对象的结构。
(3)方法serialize
public static <T> byte[] serialize(T obj) {
Class<T> clazz = (Class<T>) obj.getClass();
Schema<T> schema = getSchema(clazz);
byte[] data;
try {
data = ProtostuffIOUtil.toByteArray(obj, schema, buffer);
} finally {
buffer.clear();
}
return data;
}
它是序列化方法,里面的代码很容易理解,首先获得要序列化对象的类,然后为其分配一个缓存空间,其次获得这个类的Schema。最后一行代码ProtostuffIOUtil.toByteArray进行序列化。
(4)方法deserialize
//反序列化方法,将字节数组反序列化成指定Class类型
public static <T> T deserialize(byte[] data, Class<T> clazz) {
Schema<T> schema = getSchema(clazz);
T obj = schema.newMessage();
ProtostuffIOUtil.mergeFrom(data, obj, schema);
return obj;
}
表示反序列化,反序列里面的代码更简单了,首先根据序列化对象获取其组织结构Schema。然后根据byte直接mergeFrom成一个对象。
(5)方法getSchema
private static <T> Schema<T> getSchema(Class<T> clazz) {
Schema<T> schema = (Schema<T>) schemaCache.get(clazz);
if (schema == null) {
schema = RuntimeSchema.getSchema(clazz);
if (schema != null) {
schemaCache.put(clazz, schema);
}
}
return schema;
}
获取序列化对象的组织结构。
3、测试
public class Test {
public static void main(String[] args) {
Student stu1 = new Student("张三",20);
Student stu2 = new Student("李四",21);
List<Student> students = new ArrayList<Student>();
students.add(stu1);
students.add(stu2);
School school = new School("西工大",students);
//首先是序列化
byte[] bytes = ProtostuffUtils.serialize(school);
System.out.println("序列化后: " + bytes.length);
//然后是反序列化
School group1 = ProtostuffUtils.deserialize(bytes,School.class);
System.out.println("反序列化后: " + school.toString());
}
}
运行一下就能出现结果,很简单。上面的ProtostuffUtils是一个工具类,你可以保留下来,复制粘贴到任何地方使用。