Java序列化的几种方式以及序列化的作用
2015-10-08 15:48
741 查看
一.Java序列化的作用
有的时候我们想要把一个Java对象变成字节流的形式传出去,有的时候我们想要从一个字节流中恢复一个Java对象。例如,有的时候我们想要
把一个Java对象写入到硬盘或者传输到网路上面的其它计算机,这时我们就需要自己去通过java把相应的对象写成转换成字节流。对于这种通用
的操作,我们为什么不使用统一的格式呢?没错,这里就出现了java的序列化的概念。在Java的OutputStream类下面的子类ObjectOutput-
Stream类就有对应的WriteObject(Object object) 其中要求对应的object实现了java的序列化的接口。
为了更好的理解java序列化的应用,我举两个自己在开发项目中遇到的例子:
1)在使用tomcat开发JavaEE相关项目的时候,我们关闭tomcat后,相应的session中的对象就存储在了硬盘上,如果我们想要在tomcat重启的
时候能够从tomcat上面读取对应session中的内容,那么保存在session中的内容就必须实现相关的序列化操作。
2)如果我们使用的java对象要在分布式中使用或者在rmi远程调用的网络中使用的话,那么相关的对象必须实现java序列化接口。
亲爱的小伙伴,大概你已经了解了java序列化相关的作用,接下来们来看看如何实现java的序列化吧。~
二.实现java对象的序列化和反序列化。
Java对象的序列化有两种方式。
a.是相应的对象实现了序列化接口Serializable,这个使用的比较多,对于序列化接口Serializable接口是一个空的接口,它的主要作用就是
标识这个对象时可序列化的,jre对象在传输对象的时候会进行相关的封装。这里就不做过多的介绍了。
下面是一个实现序列化接口的Java序列化的例子:非常简单
b.实现序列化的第二种方式为实现接口Externalizable,Externlizable的部分源代码如下:
没错,Externlizable接口继承了java的序列化接口,并增加了两个方法:
void writeExternal(ObjectOutput out) throws IOException;
void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
首先,我们在序列化对象的时候,由于这个类实现了Externalizable 接口,在writeExternal()方法里定义了哪些属性可以序列化,
哪些不可以序列化,所以,对象在经过这里就把规定能被序列化的序列化保存文件,不能序列化的不处理,然后在反序列的时候自动调
用readExternal()方法,根据序列顺序挨个读取进行反序列,并自动封装成对象返回,然后在测试类接收,就完成了反序列。
所以说Exterinable的是Serializable的一个扩展。
为了更好的理解相关内容,请看下面的例子:
首先,我们在序列化UserInfo对象的时候,由于这个类实现了Externalizable 接口,在writeExternal()方法里定义了哪些属性可
以序列化,哪些不可以序列化,所以,对象在经过这里就把规定能被序列化的序列化保存文件,不能序列化的不处理,然后在反序列
的时候自动调用readExternal()方法,根据序列顺序挨个读取进行反序列,并自动封装成对象返回,然后在测试类接收,就完成了反
序列。
***对于实现Java的序列化接口需要注意一下几点:
1.java中的序列化时transient变量(这个关键字的作用就是告知JAVA我不可以被序列化)和静态变量不会被序列
化(下面是一个测试的例子)
2.也是最应该注意的,如果你先序列化对象A后序列化B,那么在反序列化的时候一定记着JAVA规定先读到的对象
是先被序列化的对象,不要先接收对象B,那样会报错.尤其在使用上面的Externalizable的时候一定要注意读取
的先后顺序。
3.实现序列化接口的对象并不强制声明唯一的serialVersionUID,是否声明serialVersionUID对于对象序列化的向
上向下的兼容性有很大的影响。我们来做个测试:
思路一
把User中的serialVersionUID去掉,序列化保存。反序列化的时候,增加或减少个字段,看是否成功。
Java代码
保存到文件中:
增加或者减少字段后,从文件中读出来,反序列化:
结果:抛出异常信息
Java代码
思路二
eclipse指定生成一个serialVersionUID,序列化保存,修改字段后反序列化
略去代码
结果:反序列化成功
结论
如果没有明确指定serialVersionUID,序列化的时候会根据字段和特定的算法生成一个serialVersionUID,当属性有变化时这个id发生了变化,所以反序列化的时候
就会失败。抛出“本地classd的唯一id和流中class的唯一id不匹配”。
jdk文档关于serialVersionUID的描述:
写道
如果可序列化类未显式声明 serialVersionUID,则序列化运行时将基于该类的各个方面计算该类的默认 serialVersionUID 值,如“Java(TM) 对象序列化规范”中所述。不过,强 烈建议 所有可序列化类都显式声明 serialVersionUID 值,原因是计算默认的 serialVersionUID 对类的详细信息具有较高的敏感性,根据编译器实现的不同可能千差万别,这样在反序列化过程中可能会导致意外的 InvalidClassException。因此,为保证 serialVersionUID 值跨不同 java 编译器实现的一致性,序列化类必须声明一个明确的 serialVersionUID 值。还强烈建议使用 private 修饰符显示声明 serialVersionUID(如果可能),原因是这种声明仅应用于直接声明类 -- serialVersionUID 字段作为继承成员没有用处。数组类不能声明一个明确的 serialVersionUID,因此它们总是具有默认的计算值,但是数组类没有匹配 serialVersionUID 值的要求。
三.实现序列化的其它方式 (这是一个扩展内容,感兴趣的可以扩展一下)
1)是把对象包装成JSON字符串传输。
这里采用JSON格式同时使用采用Google的gson-2.2.2.jar 进行转义
2)采用谷歌的ProtoBuf
随着Google工具protoBuf的开源,protobuf也是个不错的选择。对JSON,Object Serialize(Java的序列化和反序列化),
ProtoBuf 做个对比。
定义一个通用的待传输的对象UserVo:
初始化User的实例src:
1.首先使用JOSN来实现序列化。
字节数为153
Json的优点:明文结构一目了然,可以跨语言,属性的增加减少对解析端影响较小。缺点:字节数过多,依赖于不同的第三方类库。
序列化方法:
Java代码
字节数是238
反序列化:
Java代码
ObjectInputStream ois = new ObjectInputStream(fis);
vo = (UserVo) ois.readObject();
ois.close();
fis.close();
Object Serializalbe 优点:java原生支持,不需要提供第三方的类库,使用比较简单。
缺点:无法跨语言,字节数占用比较大,某些情况下对于对象属性的变化比较敏感。
对象在进行序列化和反序列化的时候,必须实现Serializable接口,但并不强制声明唯一的serialVersionUID
是否声明serialVersionUID对于对象序列化的向上向下的兼容性有很大的影响。
它定义了一种紧凑得可扩展得二进制协议格式,适合网络传输,并且针对多个语言有不同得版本可供选择。
以protobuf-2.5.0rc1为例,准备工作:
下载源码,解压,编译,安装
Shell代码
tar zxvf protobuf-2.5.0rc1.tar.gz ./configure ./make ./make install
测试:
Shell代码
MacBook-Air:~ ming$ protoc --version libprotoc 2.5.0
安装成功!
进入源码得java目录,用mvn工具编译生成所需得jar包,protobuf-java-2.5.0rc1.jar
1、编写.proto文件,命名UserVo.proto
2、在命令行利用protoc 工具生成builder类
Shell代码
protoc -IPATH=.proto文件所在得目录 --java_out=java文件的输出路径 .proto的名称
得到UserProtos类
3、编写序列化代码
字节数53
反序列化
结果:tmac,反序列化成功
google protobuf 优点:字节数很小,适合网络传输节省io,跨语言 。
缺点:需要依赖于工具生成代码。
工作机制
proto 文件是对数据的一个描述,包括字段名称,类型,字节中的位置。protoc工具读取proto文件生成对应builder代码的类库。protoc xxxxx --java_out=xxxxxx 生成java类库。builder类根据自己的算法把数据序列化成字节流,或者把字节流根据反射的原理反序列化成对象。官方的示 例:https://developers.google.com/protocol-buffers/docs/javatutorial。
proto文件中的字段类型和java中的对应关系:
详见:https://developers.google.com/protocol-buffers/docs/proto
字段属性的描述:
写道
required: a well-formed message must have exactly one of this field. optional: a well-formed message can have zero or one of this field (but not more than one). repeated: this field can be repeated any number of times (including zero) in a well-formed message. The order of the repeated values will be preserved.
protobuf 在序列化和反序列化的时候,是依赖于.proto文件生成的builder类完成,字段的变化如果不表现在.proto文件中就不会影响反序列化,比较适合字段变化的情况。
做个测试:把UserVo序列化到文件中:
成功得到结果。
三种方式对比传输同样的数据,google protobuf只有53个字节是最少的。结论:
有的时候我们想要把一个Java对象变成字节流的形式传出去,有的时候我们想要从一个字节流中恢复一个Java对象。例如,有的时候我们想要
把一个Java对象写入到硬盘或者传输到网路上面的其它计算机,这时我们就需要自己去通过java把相应的对象写成转换成字节流。对于这种通用
的操作,我们为什么不使用统一的格式呢?没错,这里就出现了java的序列化的概念。在Java的OutputStream类下面的子类ObjectOutput-
Stream类就有对应的WriteObject(Object object) 其中要求对应的object实现了java的序列化的接口。
为了更好的理解java序列化的应用,我举两个自己在开发项目中遇到的例子:
1)在使用tomcat开发JavaEE相关项目的时候,我们关闭tomcat后,相应的session中的对象就存储在了硬盘上,如果我们想要在tomcat重启的
时候能够从tomcat上面读取对应session中的内容,那么保存在session中的内容就必须实现相关的序列化操作。
2)如果我们使用的java对象要在分布式中使用或者在rmi远程调用的网络中使用的话,那么相关的对象必须实现java序列化接口。
亲爱的小伙伴,大概你已经了解了java序列化相关的作用,接下来们来看看如何实现java的序列化吧。~
二.实现java对象的序列化和反序列化。
Java对象的序列化有两种方式。
a.是相应的对象实现了序列化接口Serializable,这个使用的比较多,对于序列化接口Serializable接口是一个空的接口,它的主要作用就是
标识这个对象时可序列化的,jre对象在传输对象的时候会进行相关的封装。这里就不做过多的介绍了。
下面是一个实现序列化接口的Java序列化的例子:非常简单
package com.shop.domain; import java.util.Date; public class Article implements java.io.Serializable { private static final long serialVersionUID = 1L; private Integer id; private String title; //文章标题 private String content; // 文章内容 private String faceIcon;//表情图标 private Date postTime; //文章发表的时间 private String ipAddr; //用户的ip private User author; //回复的用户 public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getTitle() { return title; } public void setTitle(String title) { this.title = title; } public String getContent() { return content; } public void setContent(String content) { this.content = content; } public String getFaceIcon() { return faceIcon; } public void setFaceIcon(String faceIcon) { this.faceIcon = faceIcon; } public Date getPostTime() { return postTime; } public void setPostTime(Date postTime) { this.postTime = postTime; } public User getAuthor() { return author; } public void setAuthor(User author) { this.author = author; } public String getIpAddr() { return ipAddr; } public void setIpAddr(String ipAddr) { this.ipAddr = ipAddr; } }
b.实现序列化的第二种方式为实现接口Externalizable,Externlizable的部分源代码如下:
* @see java.io.ObjectInput * @see java.io.Serializable * @since JDK1.1 */ public interface Externalizable extends java.io.Serializable { /** * The object implements the writeExternal method to save its contents * by calling the methods of DataOutput for its primitive values or
没错,Externlizable接口继承了java的序列化接口,并增加了两个方法:
void writeExternal(ObjectOutput out) throws IOException;
void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
首先,我们在序列化对象的时候,由于这个类实现了Externalizable 接口,在writeExternal()方法里定义了哪些属性可以序列化,
哪些不可以序列化,所以,对象在经过这里就把规定能被序列化的序列化保存文件,不能序列化的不处理,然后在反序列的时候自动调
用readExternal()方法,根据序列顺序挨个读取进行反序列,并自动封装成对象返回,然后在测试类接收,就完成了反序列。
所以说Exterinable的是Serializable的一个扩展。
为了更好的理解相关内容,请看下面的例子:
package com.xiaohao.test; import java.io.Externalizable; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectInput; import java.io.ObjectInputStream; import java.io.ObjectOutput; import java.io.ObjectOutputStream; import java.text.SimpleDateFormat; import java.util.Date; /** * 测试实体类 * @author 小浩 * @创建日期 2015-3-12 */ class Person implements Externalizable{ private static final long serialVersionUID = 1L;<br> String userName; String password; String age; public Person(String userName, String password, String age) { super(); this.userName = userName; this.password = password; this.age = age; } public Person() { super(); } public String getAge() { return age; } public void setAge(String age) { this.age = age; } public String getUserName() { return userName; } public void setUserName(String userName) { this.userName = userName; } public String getPassword() { return password; } public void setPassword(String password) { this.password = password; } /** * 序列化操作的扩展类 */ @Override public void writeExternal(ObjectOutput out) throws IOException { //增加一个新的对象 Date date=new Date(); out.writeObject(userName); out.writeObject(password); out.writeObject(date); } /** * 反序列化的扩展类 */ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { //注意这里的接受顺序是有限制的哦,否则的话会出错的 // 例如上面先write的是A对象的话,那么下面先接受的也一定是A对象... userName=(String) in.readObject(); password=(String) in.readObject(); SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd"); Date date=(Date)in.readObject(); System.out.println("反序列化后的日期为:"+sdf.format(date)); } @Override public String toString() { //注意这里的年龄是不会被序列化的,所以在反序列化的时候是读取不到数据的 return "用户名:"+userName+"密 码:"+password+"年龄:"+age; } } /** * 序列化和反序列化的相关操作类 * @author 小浩 * @创建日期 2015-3-12 */ class Operate{ /** * 序列化方法 * @throws IOException * @throws FileNotFoundException */ public void serializable(Person person) throws FileNotFoundException, IOException{ ObjectOutputStream outputStream=new ObjectOutputStream(new FileOutputStream("a.txt")); outputStream.writeObject(person); } /** * 反序列化的方法 * @throws IOException * @throws FileNotFoundException * @throws ClassNotFoundException */ public Person deSerializable() throws FileNotFoundException, IOException, ClassNotFoundException{ ObjectInputStream ois=new ObjectInputStream(new FileInputStream("a.txt")); return (Person) ois.readObject(); } } /** * 测试实体主类 * @author 小浩 * @创建日期 2015-3-12 */ public class Test{ public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException { Operate operate=new Operate(); Person person=new Person("小浩","123456","20"); System.out.println("为序列化之前的相关数据如下:\n"+person.toString()); operate.serializable(person); Person newPerson=operate.deSerializable(); System.out.println("-------------------------------------------------------"); System.out.println("序列化之后的相关数据如下:\n"+newPerson.toString()); } }
首先,我们在序列化UserInfo对象的时候,由于这个类实现了Externalizable 接口,在writeExternal()方法里定义了哪些属性可
以序列化,哪些不可以序列化,所以,对象在经过这里就把规定能被序列化的序列化保存文件,不能序列化的不处理,然后在反序列
的时候自动调用readExternal()方法,根据序列顺序挨个读取进行反序列,并自动封装成对象返回,然后在测试类接收,就完成了反
序列。
***对于实现Java的序列化接口需要注意一下几点:
1.java中的序列化时transient变量(这个关键字的作用就是告知JAVA我不可以被序列化)和静态变量不会被序列
化(下面是一个测试的例子)
import java.io.*; class Student1 implements Serializable { private static final long serialVersionUID = 1L; private String name; private transient String password; private static int count = 0; public Student1(String name, String password) { System.out.println("调用Student的带参的构造方法"); this.name = name; this.password = password; count++; } public String toString() { return "人数: " + count + " 姓名: " + name + " 密码: " + password; } } public class ObjectSerTest1 { public static void main(String args[]) { try { FileOutputStream fos = new FileOutputStream("test.obj"); ObjectOutputStream oos = new ObjectOutputStream(fos); Student1 s1 = new Student1("张三", "12345"); Student1 s2 = new Student1("王五", "54321"); oos.writeObject(s1); oos.writeObject(s2); oos.close(); FileInputStream fis = new FileInputStream("test.obj"); ObjectInputStream ois = new ObjectInputStream(fis); Student1 s3 = (Student1) ois.readObject(); Student1 s4 = (Student1) ois.readObject(); System.out.println(s3); System.out.println(s4); ois.close(); } catch (IOException e) { e.printStackTrace(); } catch (ClassNotFoundException e1) { e1.printStackTrace(); } } }
2.也是最应该注意的,如果你先序列化对象A后序列化B,那么在反序列化的时候一定记着JAVA规定先读到的对象
是先被序列化的对象,不要先接收对象B,那样会报错.尤其在使用上面的Externalizable的时候一定要注意读取
的先后顺序。
3.实现序列化接口的对象并不强制声明唯一的serialVersionUID,是否声明serialVersionUID对于对象序列化的向
上向下的兼容性有很大的影响。我们来做个测试:
思路一
把User中的serialVersionUID去掉,序列化保存。反序列化的时候,增加或减少个字段,看是否成功。
Java代码
public class User implements Serializable{ private String name; private int age; private long phone; private List<UserVo> friends; ...<br>}
保存到文件中:
Java代码 ByteArrayOutputStream bos = new ByteArrayOutputStream(); ObjectOutputStream os = new ObjectOutputStream(bos); os.writeObject(src); os.flush(); os.close(); byte[] b = bos.toByteArray(); bos.close(); FileOutputStream fos = new FileOutputStream(dataFile); fos.write(b); fos.close();
增加或者减少字段后,从文件中读出来,反序列化:
Java代码 ByteArrayOutputStream bos = new ByteArrayOutputStream(); ObjectOutputStream os = new ObjectOutputStream(bos); os.writeObject(src); os.flush(); os.close(); byte[] b = bos.toByteArray(); bos.close(); FileOutputStream fos = new FileOutputStream(dataFile); fos.write(b); fos.close();
结果:抛出异常信息
Java代码
Exception in thread "main" java.io.InvalidClassException: serialize.obj.UserVo; local class incompatible: stream classdesc serialVersionUID = 3305402508581390189, local class serialVersionUID = 7174371419787432394 at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:560) at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1582) at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1495) at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1731) at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1328) at java.io.ObjectInputStream.readObject(ObjectInputStream.java:350) at serialize.obj.ObjectSerialize.read(ObjectSerialize.java:74) at serialize.obj.ObjectSerialize.main(ObjectSerialize.java:27)
思路二
eclipse指定生成一个serialVersionUID,序列化保存,修改字段后反序列化
略去代码
结果:反序列化成功
结论
如果没有明确指定serialVersionUID,序列化的时候会根据字段和特定的算法生成一个serialVersionUID,当属性有变化时这个id发生了变化,所以反序列化的时候
就会失败。抛出“本地classd的唯一id和流中class的唯一id不匹配”。
jdk文档关于serialVersionUID的描述:
写道
如果可序列化类未显式声明 serialVersionUID,则序列化运行时将基于该类的各个方面计算该类的默认 serialVersionUID 值,如“Java(TM) 对象序列化规范”中所述。不过,强 烈建议 所有可序列化类都显式声明 serialVersionUID 值,原因是计算默认的 serialVersionUID 对类的详细信息具有较高的敏感性,根据编译器实现的不同可能千差万别,这样在反序列化过程中可能会导致意外的 InvalidClassException。因此,为保证 serialVersionUID 值跨不同 java 编译器实现的一致性,序列化类必须声明一个明确的 serialVersionUID 值。还强烈建议使用 private 修饰符显示声明 serialVersionUID(如果可能),原因是这种声明仅应用于直接声明类 -- serialVersionUID 字段作为继承成员没有用处。数组类不能声明一个明确的 serialVersionUID,因此它们总是具有默认的计算值,但是数组类没有匹配 serialVersionUID 值的要求。
三.实现序列化的其它方式 (这是一个扩展内容,感兴趣的可以扩展一下)
1)是把对象包装成JSON字符串传输。
这里采用JSON格式同时使用采用Google的gson-2.2.2.jar 进行转义
2)采用谷歌的ProtoBuf
随着Google工具protoBuf的开源,protobuf也是个不错的选择。对JSON,Object Serialize(Java的序列化和反序列化),
ProtoBuf 做个对比。
定义一个通用的待传输的对象UserVo:
public class User <span style="white-space: pre;">private static final long serialVersionUID = -5726374138698742258L;</span> { private String name; private int age; private long phone; private List<User> friends; ...set和get方法 }
初始化User的实例src:
Java代码 User user1 = new UserVo(); user1 .setName("user1 "); user1 .setAge(30); user1 .setPhone(13789126278L); UserVo f1 = new UserVo(); f1.setName("tmac"); f1.setAge(32); f1.setPhone(123L); User user2 = new User(); user2 .setName("user2 "); user2 .setAge(29); user2 .setPhone(123L); <br> List<User> friends = new ArrayList<User>(); friends.add(user1 ); friends.add(user2 ); user1 .setFriends(friends);
1.首先使用JOSN来实现序列化。
Js代码 {"name":"user1 ","age":30,"phone":123,"friends":[{"name":"user1 ","age":32,"phone":123},{"name":"user2 ","age":29,"phone":123}]}
字节数为153
Json的优点:明文结构一目了然,可以跨语言,属性的增加减少对解析端影响较小。缺点:字节数过多,依赖于不同的第三方类库。
Object Serialize(Java的序列化和反序列化)
UserVo实现Serializalbe接口,提供唯一的版本号:序列化方法:
Java代码
ByteArrayOutputStream bos = new ByteArrayOutputStream(); ObjectOutputStream os = new ObjectOutputStream(bos); os.writeObject(src); os.flush(); os.close(); byte[] b = bos.toByteArray(); bos.close();
字节数是238
反序列化:
Java代码
ObjectInputStream ois = new ObjectInputStream(fis);
vo = (UserVo) ois.readObject();
ois.close();
fis.close();
Object Serializalbe 优点:java原生支持,不需要提供第三方的类库,使用比较简单。
缺点:无法跨语言,字节数占用比较大,某些情况下对于对象属性的变化比较敏感。
对象在进行序列化和反序列化的时候,必须实现Serializable接口,但并不强制声明唯一的serialVersionUID
是否声明serialVersionUID对于对象序列化的向上向下的兼容性有很大的影响。
Google ProtoBuf
protocol buffers 是google内部得一种传输协议,目前项目已经开源(http://code.google.com/p/protobuf/)。它定义了一种紧凑得可扩展得二进制协议格式,适合网络传输,并且针对多个语言有不同得版本可供选择。
以protobuf-2.5.0rc1为例,准备工作:
下载源码,解压,编译,安装
Shell代码
tar zxvf protobuf-2.5.0rc1.tar.gz ./configure ./make ./make install
测试:
Shell代码
MacBook-Air:~ ming$ protoc --version libprotoc 2.5.0
安装成功!
进入源码得java目录,用mvn工具编译生成所需得jar包,protobuf-java-2.5.0rc1.jar
1、编写.proto文件,命名UserVo.proto
Text代码 package serialize; option java_package = "serialize"; option java_outer_classname="UserVoProtos"; message User{ optional string name = 1; optional int32 age = 2; optional int64 phone = 3; repeated serialize.UserVo friends = 4; }
2、在命令行利用protoc 工具生成builder类
Shell代码
protoc -IPATH=.proto文件所在得目录 --java_out=java文件的输出路径 .proto的名称
得到UserProtos类
3、编写序列化代码
Java代码 UserVoProtos.User.Builder builder = UserVoProtos.User.newBuilder(); builder.setName("Yaoming"); builder.setAge(30); builder.setPhone(13789878978L); UserVoProtos.UserVo.Builder builder1 = UserVoProtos.UserVo.newBuilder(); builder1.setName("tmac"); builder1.setAge(32); builder1.setPhone(138999898989L); UserVoProtos.UserVo.Builder builder2 = UserVoProtos.UserVo.newBuilder(); builder2.setName("liuwei"); builder2.setAge(29); builder2.setPhone(138999899989L); builder.addFriends(builder1); builder.addFriends(builder2); UserVoProtos.UserVo vo = builder.build(); byte[] v = vo.toByteArray();
字节数53
反序列化
Java代码 UserVoProtos.UserVo uvo = UserVoProtos.UserVo.parseFrom(dstb); System.out.println(uvo.getFriends(0).getName());
结果:tmac,反序列化成功
google protobuf 优点:字节数很小,适合网络传输节省io,跨语言 。
缺点:需要依赖于工具生成代码。
工作机制
proto 文件是对数据的一个描述,包括字段名称,类型,字节中的位置。protoc工具读取proto文件生成对应builder代码的类库。protoc xxxxx --java_out=xxxxxx 生成java类库。builder类根据自己的算法把数据序列化成字节流,或者把字节流根据反射的原理反序列化成对象。官方的示 例:https://developers.google.com/protocol-buffers/docs/javatutorial。
proto文件中的字段类型和java中的对应关系:
详见:https://developers.google.com/protocol-buffers/docs/proto
.proto Type | java Type | c++ Type |
double | double | double |
float | float | float |
int32 | int | int32 |
int64 | long | int64 |
uint32 | int | uint32 |
unint64 | long | uint64 |
sint32 | int | int32 |
sint64 | long | int64 |
fixed32 | int | uint32 |
fixed64 | long | uint64 |
sfixed32 | int | int32 |
sfixed64 | long | int64 |
bool | boolean | bool |
string | String | string |
bytes | byte | string |
写道
required: a well-formed message must have exactly one of this field. optional: a well-formed message can have zero or one of this field (but not more than one). repeated: this field can be repeated any number of times (including zero) in a well-formed message. The order of the repeated values will be preserved.
protobuf 在序列化和反序列化的时候,是依赖于.proto文件生成的builder类完成,字段的变化如果不表现在.proto文件中就不会影响反序列化,比较适合字段变化的情况。
做个测试:把UserVo序列化到文件中:
Java代码 UserProtos.User vo = builder.build(); byte[] v = vo.toByteArray(); FileOutputStream fos = new FileOutputStream(dataFile); fos.write(vo.toByteArray()); fos.close(); 为User增加字段,对应的.proto文件: Text代码 package serialize; option java_package = "serialize"; option java_outer_classname="UserVoProtos"; message User{ optional string name = 1; optional int32 age = 2; optional int64 phone = 3; repeated serialize.UserVo friends = 4; optional string address = 5; } 从文件中反序列化回来: Java代码 FileInputStream fis = new FileInputStream(dataFile); byte[] dstb = new byte[fis.available()]; for(int i=0;i<dstb.length;i++){ dstb[i] = (byte)fis.read(); } fis.close(); UserProtos.User uvo = UserProtos.User.parseFrom(dstb); System.out.println(uvo.getFriends(0).getName());
成功得到结果。
三种方式对比传输同样的数据,google protobuf只有53个字节是最少的。结论:
方式 | 优点 | 缺点 |
JSON | 跨语言、格式清晰一目了然 | 字节数比较大,需要第三方类库 |
Object Serialize | java原生方法不依赖外部类库 | 字节数比较大,不能跨语言 |
Google protobuf | 跨语言、字节数比较少 | 编写.proto配置用protoc工具生成对应的代码 |
相关文章推荐
- java标准标签库JSTL详解
- Java和MySQL数据库的连接
- java的动态代理机制详解
- Java下获取可用CPU数
- Java对象的创建及访问
- java观察者模式(转)
- java回调机制及其实现(转)
- 关于java中static关键字的读书笔记
- spring 生命周期
- mysql/Java服务端对emoji的支持
- java基础总结
- 接口和抽象类的区别
- Spring中Singleton模式的线程安全
- (转)Spring中Singleton模式的线程安全
- Struts2原理解析(结合源码)
- JMS之ActiveMQ
- spring mvc 中 静态资源的处理
- 史上最全的maven pom.xml文件教程详解
- J360-cloud SpringCloud系列一:分布式配置服务器ConfigServer
- 7. Spring验证、数据绑定和类型转换