java对象的序列化和反序列化

 初始化UserVo的实例src：

Java代码  

1. UserVo src = new UserVo();  
2. src.setName("Yaoming");  
3. src.setAge(30);  
4. src.setPhone(13789878978L);  
5.       
6. UserVo f1 = new UserVo();  
7. f1.setName("tmac");  
8. f1.setAge(32);  
9. f1.setPhone(138999898989L);  
10. UserVo f2 = new UserVo();  
11. f2.setName("liuwei");  
12. f2.setAge(29);  
13. f2.setPhone(138999899989L);  
14.           
15. List<UserVo> friends = new ArrayList<UserVo>();  
16. friends.add(f1);  
17. friends.add(f2);  
18. src.setFriends(friends);  

JSON格式

采用Google的gson-2.2.2.jar 进行转义

Java代码  

1. Gson gson = new Gson();  
2. String json = gson.toJson(src);  

 得到的字符串：

Js代码  

1. {"name":"Yaoming","age":30,"phone":13789878978,"friends":[{"name":"tmac","age":32,"phone":138999898989},{"name":"liuwei","age":29,"phone":138999899989}]}  

 字节数为153

Json的优点：明文结构一目了然，可以跨语言，属性的增加减少对解析端影响较小。缺点：字节数过多，依赖于不同的第三方类库。

Object Serialize

UserVo实现Serializalbe接口，提供唯一的版本号：

Java代码  

1. public class UserVo implements Serializable{  
2.   
3.     private static final long serialVersionUID = -5726374138698742258L;  
4.     private String name;  
5.     private int age;  
6.     private long phone;  
7.       
8.     private List<UserVo> friends;  

序列化方法：

Java代码  

1. ByteArrayOutputStream bos = new ByteArrayOutputStream();  
2. ObjectOutputStream os = new ObjectOutputStream(bos);  
3. os.writeObject(src);  
4. os.flush();  
5. os.close();  
6. byte[] b = bos.toByteArray();  
7. bos.close();  

 字节数是238

反序列化：

Java代码  

1. ObjectInputStream ois = new ObjectInputStream(fis);  
2. vo = (UserVo) ois.readObject();  
3. ois.close();  
4. fis.close();  

Object Serializalbe 优点：java原生支持，不需要提供第三方的类库，使用比较简单。缺点：无法跨语言，字节数占用比较大，某些情况下对于对象属性的变化比较敏感。 

对象在进行序列化和反序列化的时候，必须实现Serializable接口，但并不强制声明唯一的serialVersionUID

是否声明serialVersionUID对于对象序列化的向上向下的兼容性有很大的影响。我们来做个测试：

思路一

把UserVo中的serialVersionUID去掉，序列化保存。反序列化的时候，增加或减少个字段，看是否成功。

Java代码  

1. public class UserVo implements Serializable{  
2.     private String name;  
3.     private int age;  
4.     private long phone;  
5.       
6.     private List<UserVo> friends;  

保存到文件中：

Java代码  

1. ByteArrayOutputStream bos = new ByteArrayOutputStream();  
2. ObjectOutputStream os = new ObjectOutputStream(bos);  
3. os.writeObject(src);  
4. os.flush();  
5. os.close();  
6. byte[] b = bos.toByteArray();  
7. bos.close();  
8.   
9. FileOutputStream fos = new FileOutputStream(dataFile);  
10. fos.write(b);  
11. fos.close();  

增加或者减少字段后，从文件中读出来，反序列化：

Java代码  

1. FileInputStream fis = new FileInputStream(dataFile);  
2. ObjectInputStream ois = new ObjectInputStream(fis);  
3. vo = (UserVo) ois.readObject();  
4. ois.close();  
5. fis.close();  

结果：抛出异常信息

Java代码  

1. Exception in thread "main" java.io.InvalidClassException: serialize.obj.UserVo; local class incompatible: stream classdesc serialVersionUID = 3305402508581390189, local class serialVersionUID = 7174371419787432394  
2.     at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:560)  
3.     at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1582)  
4.     at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1495)  
5.     at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1731)  
6.     at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1328)  
7.     at java.io.ObjectInputStream.readObject(ObjectInputStream.java:350)  
8.     at serialize.obj.ObjectSerialize.read(ObjectSerialize.java:74)  
9.     at serialize.obj.ObjectSerialize.main(ObjectSerialize.java:27)  

思路二

eclipse指定生成一个serialVersionUID，序列化保存，修改字段后反序列化

略去代码

结果：反序列化成功

结论

如果没有明确指定serialVersionUID，序列化的时候会根据字段和特定的算法生成一个serialVersionUID，当属性有变化时这个id发生了变化，所以反序列化的时候就会失败。抛出“本地classd的唯一id和流中class的唯一id不匹配”。

jdk文档关于serialVersionUID的描述：

Google ProtoBuf

protocol buffers 是google内部得一种传输协议，目前项目已经开源（http://code.google.com/p/protobuf/）。它定义了一种紧凑得可扩展得二进制协议格式，适合网络传输，并且针对多个语言有不同得版本可供选择。

以protobuf-2.5.0rc1为例，准备工作：

下载源码，解压，编译，安装

Shell代码  

1. tar zxvf protobuf-2.5.0rc1.tar.gz  
2. ./configure  
3. ./make  
4. ./make install  

 测试：

Shell代码  

1. MacBook-Air:~ ming$ protoc --version  
2. libprotoc 2.5.0  

 安装成功！进入源码得java目录，用mvn工具编译生成所需得jar包，protobuf-java-2.5.0rc1.jar

1、编写.proto文件，命名UserVo.proto 

Text代码  

1. package serialize;  
2.   
3. option java_package = "serialize";  
4. option java_outer_classname="UserVoProtos";  
5.   
6. message UserVo{  
7.     optional string name = 1;  
8.     optional int32 age = 2;  
9.     optional int64 phone = 3;  
10.     repeated serialize.UserVo friends = 4;  
11. }  

2、在命令行利用protoc 工具生成builder类

Shell代码  

1. protoc -IPATH=.proto文件所在得目录 --java_out=java文件的输出路径  .proto的名称   

 得到UserVoProtos类

3、编写序列化代码

Java代码  

1. UserVoProtos.UserVo.Builder builder = UserVoProtos.UserVo.newBuilder();  
2. builder.setName("Yaoming");  
3. builder.setAge(30);  
4. builder.setPhone(13789878978L);  
5.           
6. UserVoProtos.UserVo.Builder builder1 = UserVoProtos.UserVo.newBuilder();  
7. builder1.setName("tmac");  
8. builder1.setAge(32);  
9. builder1.setPhone(138999898989L);  
10.           
11. UserVoProtos.UserVo.Builder builder2 = UserVoProtos.UserVo.newBuilder();  
12. builder2.setName("liuwei");  
13. builder2.setAge(29);  
14. builder2.setPhone(138999899989L);  
15.           
16. builder.addFriends(builder1);  
17. builder.addFriends(builder2);  
18.           
19. UserVoProtos.UserVo vo = builder.build();  
20.           
21. byte[] v = vo.toByteArray();  

 字节数53

4、反序列化

Java代码  

1. UserVoProtos.UserVo uvo = UserVoProtos.UserVo.parseFrom(dstb);  
2. System.out.println(uvo.getFriends(0).getName());  

google protobuf 优点：字节数很小，适合网络传输节省io，跨语言 。缺点：需要依赖于工具生成代码。

工作机制

proto文件是对数据的一个描述，包括字段名称，类型，字节中的位置。protoc工具读取proto文件生成对应builder代码的类库。protoc xxxxx  --java_out=xxxxxx 生成java类库。builder类根据自己的算法把数据序列化成字节流，或者把字节流根据反射的原理反序列化成对象。官方的示例：https://developers.google.com/protocol-buffers/docs/javatutorial。

proto文件中的字段类型和java中的对应关系：

详见：