安全检查中...
请打开浏览器的javascript，然后刷新浏览器
mamicode.com 浏览器安全检查中...
还剩 5 秒&51CTO旗下网站
关于 Java 对象序列化您不知道的 5 件事
数年前，当和一个软件团队一起用 Java 语言编写一个应用程序时，我体会到比一般程序员多知道一点关于 Java 对象序列化的知识所带来的好处。
作者：来源：developerWorks| 10:25
数年前，当和一个软件团队一起用 Java 语言编写一个应用程序时，我体会到比一般多知道一点关于 Java 对象序列化的知识所带来的好处。
关于本系列
您觉得自己懂 Java 编程？事实上，大多数程序员对于 Java 平台都是浅尝则止，只学习了足以完成手头上任务的知识而已。在本&系列&中，Ted Neward 深入挖掘 Java 平台的核心功能，揭示一些鲜为人知的事实，帮助您解决最棘手的编程挑战。
大约一年前，一个负责管理应用程序所有用户设置的开发人员，决定将用户设置存储在一个&Hashtable中，然后将这个&Hashtable&序列化到磁盘，以便持久化。当用户更改设置时，便重新将&Hashtable&写到磁盘。
这是一个优雅的、开放式的设置系统，但是，当团队决定从&Hashtable&迁移到 Java Collections 库中的HashMap&时，这个系统便面临崩溃。
Hashtable&和&HashMap&在磁盘上的格式是不相同、不兼容的。除非对每个持久化的用户设置运行某种类型的数据转换实用程序（极其庞大的任务），否则以后似乎只能一直用Hashtable&作为应用程序的存储格式。
团队感到陷入僵局，但这只是因为他们不知道关于 Java 序列化的一个重要事实：Java 序列化允许随着时间的推移而改变类型。当我向他们展示如何自动进行序列化替换后，他们终于按计划完成了向&HashMap&的转变。
本文是本系列的第一篇文章，这个系列专门揭示关于 Java 平台的一些有用的小知识 & 这些小知识不易理解，但对于解决 Java 编程挑战迟早有用。
将 Java 对象序列化 API 作为开端是一个不错的选择，因为它从一开始就存在于 JDK 1.1 中。本文介绍的关于序列化的 5 件事情将说服您重新审视那些标准 Java API。
关于本系列
Java 对象序列化是 JDK 1.1 中引入的一组开创性特性之一，用于作为一种将 Java 对象的状态转换为字节数组，以便存储或传输的机制，以后，仍可以将字节数组转换回 Java 对象原有的状态。
实际上，序列化的思想是 &冻结& 对象状态，传输对象状态（写到磁盘、通过网络传输等等），然后 &解冻& 状态，重新获得可用的 Java 对象。所有这些事情的发生有点像是魔术，这要归功于&ObjectInputStream/ObjectOutputStream&类、完全保真的元数据以及程序员愿意用Serializable&标识接口标记他们的类，从而 &参与& 这个过程。
清单 1 显示一个实现&Serializable&的&Person&类。
清单 1. Serializable Person
package com.
public class Person
implements java.io.Serializable
public Person(String fn, String ln, int a)
this.firstName = this.lastName = this.age =
public String getFirstName() { return firstN }
public String getLastName() { return lastN }
public int getAge() { }
public Person getSpouse() { }
public void setFirstName(String value) { firstName = }
public void setLastName(String value) { lastName = }
public void setAge(int value) { age = }
public void setSpouse(Person value) { spouse = }
public String toString()
return &[Person: firstName=& + firstName +
& lastName=& + lastName +
& age=& + age +
& spouse=& + spouse.getFirstName() +
private String firstN
private String lastN
将&Person&序列化后，很容易将对象状态写到磁盘，然后重新读出它，下面的 JUnit 4 单元测试对此做了演示。
清单 2. 对 Person 进行反序列化
public class SerTest
@Test public void serializeToDisk()
com.tedneward.Person ted = new com.tedneward.Person(&Ted&, &Neward&, 39);
com.tedneward.Person charl = new com.tedneward.Person(&Charlotte&,
&Neward&, 38);
ted.setSpouse(charl); charl.setSpouse(ted);
FileOutputStream fos = new FileOutputStream(&tempdata.ser&);
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(ted);
oos.close();
catch (Exception ex)
fail(&Exception thrown during test: & + ex.toString());
FileInputStream fis = new FileInputStream(&tempdata.ser&);
ObjectInputStream ois = new ObjectInputStream(fis);
com.tedneward.Person ted = (com.tedneward.Person) ois.readObject();
ois.close();
assertEquals(ted.getFirstName(）， &Ted&);
assertEquals(ted.getSpouse().getFirstName(）， &Charlotte&);
// Clean up the file
new File(&tempdata.ser&).delete();
catch (Exception ex)
fail(&Exception thrown during test: & + ex.toString());
到现在为止，还没有看到什么新鲜的或令人兴奋的事情，但是这是一个很好的出发点。我们将使用&Person&来发现您可能不&知道的关于&Java 对象序列化&的 5 件事。
1. 序列化允许重构
序列化允许一定数量的类变种，甚至重构之后也是如此，ObjectInputStream&仍可以很好地将其读出来。
Java Object Serialization&规范可以自动管理的关键任务是：
将新字段添加到类中
将字段从 static 改为非 static
将字段从 transient 改为非 transient
取决于所需的向后兼容程度，转换字段形式（从非 static 转换为 static 或从非 transient 转换为 transient）或者删除字段需要额外的消息传递。
重构序列化类
既然已经知道序列化允许重构，我们来看看当把新字段添加到&Person&类中时，会发生什么事情。
如清单 3 所示，PersonV2&在原先&Person&类的基础上引入一个表示性别的新字段。
清单 3. 将新字段添加到序列化的 Person 中
enum Gender
MALE, FEMALE
public class Person
implements java.io.Serializable
public Person(String fn, String ln, int a, Gender g)
this.firstName = this.lastName = this.age = this.gender =
public String getFirstName() { return firstN }
public String getLastName() { return lastN }
public Gender getGender() { }
public int getAge() { }
public Person getSpouse() { }
public void setFirstName(String value) { firstName = }
public void setLastName(String value) { lastName = }
public void setGender(Gender value) { gender = }
public void setAge(int value) { age = }
public void setSpouse(Person value) { spouse = }
public String toString()
return &[Person: firstName=& + firstName +
& lastName=& + lastName +
& gender=& + gender +
& age=& + age +
& spouse=& + spouse.getFirstName() +
private String firstN
private String lastN
序列化使用一个 hash，该 hash 是根据给定源文件中几乎所有东西 & 方法名称、字段名称、字段类型、访问修改方法等 & 计算出来的，序列化将该 hash 值与序列化流中的 hash 值相比较。
为了使 Java 运行时相信两种类型实际上是一样的，第二版和随后版本的&Person&必须与第一版有相同的序列化版本 hash（存储为 private static final&serialVersionUID&字段）。因此，我们需要&serialVersionUID&字段，它是通过对原始（或 V1）版本的&Person&类运行 JDK&serialver命令计算出的。
一旦有了&Person&的&serialVersionUID，不仅可以从原始对象&Person&的序列化数据创建&PersonV2&对象（当出现新字段时，新字段被设为缺省值，最常见的是&null&），还可以反过来做：即从&PersonV2&的数据通过反序列化得到&Person，这毫不奇怪。
2. 序列化并不安全
让 Java 开发人员诧异并感到不快的是，序列化二进制格式完全编写在文档中，并且完全可逆。实际上，只需将二进制序列化流的内容转储到控制台，就足以看清类是什么样子，以及它包含什么内容。
这对于安全性有着不良影响。例如，当通过 RMI 进行远程方法调用时，通过连接发送的对象中的任何 private 字段几乎都是以明文的方式出现在套接字流中，这显然容易招致哪怕最简单的安全问题。
幸运的是，序列化允许 &hook& 序列化过程，并在序列化之前和反序列化之后保护（或模糊化）字段数据。可以通过在&Serializable&对象上提供一个&writeObject&方法来做到这一点。
模糊化序列化数据
假设&Person&类中的敏感数据是 age 字段。毕竟，女士忌谈年龄。 我们可以在序列化之前模糊化该数据，将数位循环左移一位，然后在反序列化之后复位。（您可以开发更安全的算法，当前这个算法只是作为一个例子。）
为了 &hook& 序列化过程，我们将在&Person&上实现一个&writeObject&方法；为了 &hook& 反序列化过程，我们将在同一个类上实现一个readObject&方法。重要的是这两个方法的细节要正确 & 如果访问修改方法、参数或名称不同于清单 4 中的内容，那么代码将不被察觉地失败，Person&的 age 将暴露。
清单 4. 模糊化序列化数据
public class Person
implements java.io.Serializable
public Person(String fn, String ln, int a)
this.firstName = this.lastName = this.age =
public String getFirstName() { return firstN }
public String getLastName() { return lastN }
public int getAge() { }
public Person getSpouse() { }
public void setFirstName(String value) { firstName = }
public void setLastName(String value) { lastName = }
public void setAge(int value) { age = }
public void setSpouse(Person value) { spouse = }
private void writeObject(java.io.ObjectOutputStream stream)
throws java.io.IOException
// &Encrypt&/obscure the sensitive data
age = age && 2;
stream.defaultWriteObject();
private void readObject(java.io.ObjectInputStream stream)
throws java.io.IOException, ClassNotFoundException
stream.defaultReadObject();
// &Decrypt&/de-obscure the sensitive data
age = age && 2;
public String toString()
return &[Person: firstName=& + firstName +
& lastName=& + lastName +
& age=& + age +
& spouse=& + (spouse!=null ? spouse.getFirstName() : &[null]&) +
private String firstN
private String lastN
如果需要查看被模糊化的数据，总是可以查看序列化数据流/文件。而且，由于该格式被完全文档化，即使不能访问类本身，也仍可以读取序列化流中的内容。
3. 序列化的数据可以被签名和密封
上一个技巧假设您想模糊化序列化数据，而不是对其加密或者确保它不被修改。当然，通过使用&writeObject&和&readObject&可以实现密码加密和签名管理，但其实还有更好的方式。
如果需要对整个对象进行加密和签名，最简单的是将它放在一个&javax.crypto.SealedObject&和/或&java.security.SignedObject&包装器中。两者都是可序列化的，所以将对象包装在&SealedObject&中可以围绕原对象创建一种 &包装盒&。必须有对称密钥才能解密，而且密钥必须单独管理。同样，也可以将&SignedObject&用于数据验证，并且对称密钥也必须单独管理。
结合使用这两种对象，便可以轻松地对序列化数据进行密封和签名，而不必强调关于数字签名验证或加密的细节。很简洁，是吧？
4. 序列化允许将代理放在流中
很多情况下，类中包含一个核心数据元素，通过它可以派生或找到类中的其他字段。在此情况下，没有必要序列化整个对象。可以将字段标记为&transient，但是每当有方法访问一个字段时，类仍然必须显式地产生代码来检查它是否被初始化。
如果首要问题是序列化，那么最好指定一个 flyweight 或代理放在流中。为原始&Person&提供一个&writeReplace&方法，可以序列化不同类型的对象来代替它。类似地，如果反序列化期间发现一个&readResolve&方法，那么将调用该方法，将替代对象提供给调用者。
打包和解包代理
writeReplace&和&readResolve&方法使&Person&类可以将它的所有数据（或其中的核心数据）打包到一个&PersonProxy&中，将它放入到一个流中，然后在反序列化时再进行解包。
清单 5. 你完整了我，我代替了你
class PersonProxy
implements java.io.Serializable
public PersonProxy(Person orig)
data = orig.getFirstName() + &,& + orig.getLastName() + &,& + orig.getAge();
if (orig.getSpouse() != null)
Person spouse = orig.getSpouse();
data = data + &,& + spouse.getFirstName() + &,& + spouse.getLastName() + &,&
+ spouse.getAge();
private Object readResolve()
throws java.io.ObjectStreamException
String[] pieces = data.split(&,&);
Person result = new Person(pieces[0], pieces[1], Integer.parseInt(pieces[2]));
if (pieces.length & 3)
result.setSpouse(new Person(pieces[3], pieces[4], Integer.parseInt
(pieces[5])));
result.getSpouse().setSpouse(result);
public class Person
implements java.io.Serializable
public Person(String fn, String ln, int a)
this.firstName = this.lastName = this.age =
public String getFirstName() { return firstN }
public String getLastName() { return lastN }
public int getAge() { }
public Person getSpouse() { }
private Object writeReplace()
throws java.io.ObjectStreamException
return new PersonProxy(this);
public void setFirstName(String value) { firstName = }
public void setLastName(String value) { lastName = }
public void setAge(int value) { age = }
public void setSpouse(Person value) { spouse = }
public String toString()
return &[Person: firstName=& + firstName +
& lastName=& + lastName +
& age=& + age +
& spouse=& + spouse.getFirstName() +
private String firstN
private String lastN
注意，PersonProxy&必须跟踪&Person&的所有数据。这通常意味着代理需要是&Person&的一个内部类，以便能访问 private 字段。有时候，代理还需要追踪其他对象引用并手动序列化它们，例如&Person&的 spouse。
这种技巧是少数几种不需要读/写平衡的技巧之一。例如，一个类被重构成另一种类型后的版本可以提供一个&readResolve&方法，以便静默地将被序列化的对象转换成新类型。类似地，它可以采用&writeReplace&方法将旧类序列化成新版本。
5. 信任，但要验证
认为序列化流中的数据总是与最初写到流中的数据一致，这没有问题。但是，正如一位美国前总统所说的，&信任，但要验证&。
对于序列化的对象，这意味着验证字段，以确保在反序列化之后它们仍具有正确的值，&以防万一&。为此，可以实现&ObjectInputValidation接口，并覆盖&validateObject()&方法。如果调用该方法时发现某处有错误，则抛出一个&InvalidObjectException。
Java 对象序列化比大多数 Java 开发人员想象的更灵活，这使我们有更多的机会解决棘手的情况。
幸运的是，像这样的编程妙招在 JVM 中随处可见。关键是要知道它们，在遇到难题的时候能用上它们。
5 件事&系列下期预告：Java Collections。在此之前，好好享受按自己的想法调整序列化吧！
【编辑推荐】
【责任编辑： TEL：（010）】
大家都在看猜你喜欢
热点热点头条关注头条
24H热文一周话题本月最赞
讲师：32837人学习过
讲师：144744人学习过
讲师：81777人学习过
精选博文论坛热帖下载排行
本书是AJAX之父的经典之作。本书用简洁的语言系统化地诠释了设计、技术和商业融合是最重要的发展趋势。全书共8章，包括关于用户体验以及为...
订阅51CTO邮刊Java实现几种序列化方式总结
转载 & & 作者：皮斯特劳沃
本篇文章主要介绍了Java实现几种序列化方式总结，包括Java原生以流的方法进行的序列化、Json序列化、FastJson序列化、Protobuff序列化。有兴趣的可以了解一下。
本文主要对几种常见Java序列化方式进行实现。包括Java原生以流的方法进行的序列化、Json序列化、FastJson序列化、Protobuff序列化。
1、Java原生序列化
Java原生序列化方法即通过Java原生流(InputStream和OutputStream之间的转化)的方式进行转化。需要注意的是JavaBean实体类必须实现Serializable接口，否则无法序列化。Java原生序列化代码示例如下所示：
import java.io.BufferedInputS
import java.io.ByteArrayOutputS
import java.io.IOE
import java.io.ObjectInputS
import java.io.ObjectOutputS
import java.util.ArrayL
import java.util.L
* @author liqqc
public class JavaSerialize {
public static void main(String[] args) throws ClassNotFoundException, IOException {
new JavaSerialize().start();
public void start() throws IOException, ClassNotFoundException {
User u = new User();
List&User& friends = new ArrayList&&();
u.setUserName("张三");
u.setPassWord("123456");
u.setUserInfo("张三是一个很牛逼的人");
u.setFriends(friends);
User f1 = new User();
f1.setUserName("李四");
f1.setPassWord("123456");
f1.setUserInfo("李四是一个很牛逼的人");
User f2 = new User();
f2.setUserName("王五");
f2.setPassWord("123456");
f2.setUserInfo("王五是一个很牛逼的人");
friends.add(f1);
friends.add(f2);
Long t1 = System.currentTimeMillis();
ByteArrayOutputStream out = new ByteArrayOutputStream();
ObjectOutputStream obj = new ObjectOutputStream(out);
for(int i = 0; i&10; i++) {
obj.writeObject(u);
System.out.println("java serialize: " +(System.currentTimeMillis() - t1) + " 总大小：" + out.toByteArray().length );
Long t2 = System.currentTimeMillis();
ObjectInputStream ois = new ObjectInputStream(new BufferedInputStream(new java.io.ByteArrayInputStream(out.toByteArray())));
User user = (User) ois.readObject();
System.out.println("java deserialize: " + (System.currentTimeMillis() - t2) + " User: " + user);
运行结果：
java serialize: 8 总大小：420
java deserialize: 1 User: User [userId=null, userName=张三, passWord=123456, userInfo=张三是一个很牛逼的人, friends=[User [userId=null, userName=李四, passWord=123456, userInfo=李四是一个很牛逼的人, friends=null], User [userId=null, userName=王五, passWord=123456, userInfo=王五是一个很牛逼的人, friends=null]]]
2、Json序列化
Json序列化一般会使用jackson包，通过ObjectMapper类来进行一些操作，比如将对象转化为byte数组或者将json串转化为对象。现在的大多数公司都将json作为服务器端返回的数据格式。比如调用一个服务器接口，通常的请求为xxx.json?a=xxx&b=xxx的形式。Json序列化示例代码如下所示：
import java.io.IOE
import java.util.ArrayL
import java.util.L
import com.fasterxml.jackson.databind.ObjectM
* @author liqqc
public class JsonSerialize {
public static void main(String[] args) throws IOException {
new JsonSerialize().start();
public void start() throws IOException {
User u = new User();
List&User& friends = new ArrayList&&();
u.setUserName("张三");
u.setPassWord("123456");
u.setUserInfo("张三是一个很牛逼的人");
u.setFriends(friends);
User f1 = new User();
f1.setUserName("李四");
f1.setPassWord("123456");
f1.setUserInfo("李四是一个很牛逼的人");
User f2 = new User();
f2.setUserName("王五");
f2.setPassWord("123456");
f2.setUserInfo("王五是一个很牛逼的人");
friends.add(f1);
friends.add(f2);
ObjectMapper mapper = new ObjectMapper();
Long t1 = System.currentTimeMillis();
byte[] writeValueAsBytes =
for (int i = 0; i & 10; i++) {
writeValueAsBytes = mapper.writeValueAsBytes(u);
System.out.println("json serialize: " + (System.currentTimeMillis() - t1) + " 总大小：" + writeValueAsBytes.length);
Long t2 = System.currentTimeMillis();
User user = mapper.readValue(writeValueAsBytes, User.class);
System.out.println("json deserialize: " + (System.currentTimeMillis() - t2) + " User: " + user);
运行结果：
json serialize: 55 总大小：341
json deserialize: 35 User: User [userId=null, userName=张三, passWord=123456, userInfo=张三是一个很牛逼的人, friends=[User [userId=null, userName=李四, passWord=123456, userInfo=李四是一个很牛逼的人, friends=null], User [userId=null, userName=王五, passWord=123456, userInfo=王五是一个很牛逼的人, friends=null]]]
3、FastJson序列化
fastjson 是由阿里巴巴开发的一个性能很好的Java 语言实现的 Json解析器和生成器。特点：速度快，测试表明fastjson具有极快的性能，超越任其他的Java json parser。功能强大，完全支持java bean、集合、Map、日期、Enum，支持范型和自省。无依赖，能够直接运行在Java SE 5.0以上版本
支持Android。使用时候需引入FastJson第三方jar包。FastJson序列化代码示例如下所示：
import java.util.ArrayL
import java.util.L
import com.alibaba.fastjson.JSON;
* @author liqqc
public class FastJsonSerialize {
public static void main(String[] args) {
new FastJsonSerialize().start();
public void start(){
User u = new User();
List&User& friends = new ArrayList&&();
u.setUserName("张三");
u.setPassWord("123456");
u.setUserInfo("张三是一个很牛逼的人");
u.setFriends(friends);
User f1 = new User();
f1.setUserName("李四");
f1.setPassWord("123456");
f1.setUserInfo("李四是一个很牛逼的人");
User f2 = new User();
f2.setUserName("王五");
f2.setPassWord("123456");
f2.setUserInfo("王五是一个很牛逼的人");
friends.add(f1);
friends.add(f2);
Long t1 = System.currentTimeMillis();
String text =
for(int i = 0; i&10; i++) {
text = JSON.toJSONString(u);
System.out.println("fastJson serialize: " +(System.currentTimeMillis() - t1) + " 总大小：" + text.getBytes().length);
//反序列化
Long t2 = System.currentTimeMillis();
User user = JSON.parseObject(text, User.class);
System.out.println("fastJson serialize: " + (System.currentTimeMillis() -t2) + " User: " + user);
运行结果：
fastJson serialize: 284 总大小：269
fastJson serialize: 26 User: User [userId=null, userName=张三, passWord=123456, userInfo=张三是一个很牛逼的人, friends=[User [userId=null, userName=李四, passWord=123456, userInfo=李四是一个很牛逼的人, friends=null], User [userId=null, userName=王五, passWord=123456, userInfo=王五是一个很牛逼的人, friends=null]]]
4、ProtoBuff序列化
ProtocolBuffer是一种轻便高效的结构化数据存储格式，可以用于结构化数据序列化。适合做数据存储或 RPC 数据交换格式。可用于通讯协议、数据存储等领域的语言无关、平台无关、可扩展的序列化结构数据格式。
优点：跨语言；序列化后数据占用空间比JSON小，JSON有一定的格式，在数据量上还有可以压缩的空间。
缺点：它以二进制的方式存储，无法直接读取编辑，除非你有 .proto 定义，否则无法直接读出 Protobuffer的任何内容。
其与thrift的对比：两者语法类似，都支持版本向后兼容和向前兼容，thrift侧重点是构建跨语言的可伸缩的服务，支持的语言多，同时提供了全套RPC解决方案，可以很方便的直接构建服务，不需要做太多其他的工作。 Protobuffer主要是一种序列化机制，在数据序列化上进行性能比较，Protobuffer相对较好。
ProtoBuff序列化对象可以很大程度上将其压缩，可以大大减少数据传输大小，提高系统性能。对于大量数据的缓存，也可以提高缓存中数据存储量。原始的ProtoBuff需要自己写.proto文件，通过编译器将其转换为java文件，显得比较繁琐。百度研发的jprotobuf框架将Google原始的protobuf进行了封装，对其进行简化，仅提供序列化和反序列化方法。其实用上也比较简洁，通过对JavaBean中的字段进行注解就行，不需要撰写.proto文件和实用编译器将其生成.java文件，百度的jprotobuf都替我们做了这些事情了。
一个带有jprotobuf注解的JavaBean如下所示，如果你想深入学习可以参照。
import java.io.S
import java.util.L
import com.baidu.bjf.remoting.protobuf.FieldT
import com.baidu.bjf.remoting.protobuf.annotation.P
public class User implements Serializable {
private static final long serialVersionUID = -2864573L;
@Protobuf(fieldType = FieldType.INT32, required = false, order = 1)
private Integer userId;
@Protobuf(fieldType = FieldType.STRING, required = false, order = 2)
private String userN
@Protobuf(fieldType = FieldType.STRING, required = false, order = 3)
private String passW
@Protobuf(fieldType = FieldType.STRING, required = false, order = 4)
private String userI
@Protobuf(fieldType = FieldType.OBJECT, required = false, order = 5)
private List&User&
public Integer getUserId() {
return userId;
public void setUserId(Integer userId) {
this.userId = userId;
public String getUserName() {
return userN
public void setUserName(String userName) {
this.userName = userN
public String getPassWord() {
return passW
public void setPassWord(String passWord) {
this.passWord = passW
public String getUserInfo() {
return userI
public void setUserInfo(String userInfo) {
this.userInfo = userI
public List&User& getFriends() {
public void setFriends(List&User& friends) {
this.friends =
public String toString() {
return "User [userId=" + userId + ", userName=" + userName + ", passWord=" + passWord + ", userInfo=" + userInfo
+ ", friends=" + friends + "]";
jprotobuf序列化代码示例如下所示：
import java.io.IOE
import java.util.ArrayL
import java.util.L
import com.baidu.bjf.remoting.protobuf.C
import com.baidu.bjf.remoting.protobuf.ProtobufP
* @author liqqc
public class ProtoBuffSerialize {
public static void main(String[] args) throws IOException {
new ProtoBuffSerialize().start();
public void start() throws IOException {
Codec&User& studentClassCodec = ProtobufProxy.create(User.class, false);
User u2 = new User();
List&User& friends = new ArrayList&&();
u2.setUserName("张三");
u2.setPassWord("123456");
u2.setUserInfo("张三是一个很牛逼的人");
u2.setFriends(friends);
User f1 = new User();
f1.setUserName("李四");
f1.setPassWord("123456");
f1.setUserInfo("李四是一个很牛逼的人");
User f2 = new User();
f2.setUserName("王五");
f2.setPassWord("123456");
f2.setUserInfo("王五是一个很牛逼的人");
friends.add(f1);
friends.add(f2);
Long stime_jpb_encode = System.currentTimeMillis();
byte[] bytes =
for(int i = 0; i&10; i++) {
bytes = studentClassCodec.encode(u2);
System.out.println("jprotobuf序列化耗时：" + (System.currentTimeMillis() - stime_jpb_encode) + " 总大小：" + bytes.length);
Long stime_jpb_decode = System.currentTimeMillis();
User user = studentClassCodec.decode(bytes);
Long etime_jpb_decode = System.currentTimeMillis();
System.out.println("jprotobuf反序列化耗时："+ (etime_jpb_decode-stime_jpb_decode) + " User: " + user);
运行结果：
jprotobuf序列化耗时：9 总大小：148
jprotobuf反序列化耗时：0 User: User [userId=null, userName=张三, passWord=123456, userInfo=张三是一个很牛逼的人, friends=[User [userId=null, userName=李四, passWord=123456, userInfo=李四是一个很牛逼的人, friends=null], User [userId=null, userName=王五, passWord=123456, userInfo=王五是一个很牛逼的人, friends=null]]]
我们通过Main方法来进行对比测试，（但是通过测试发现少量数据无法准确显示每种序列化方式的优劣，故这里无法给出比较好的答案，仅供参考）。示例代码如下所示：
import java.io.IOE
* @author liqqc
public class Main {
public static void main(String[] args) throws IOException, ClassNotFoundException {
ProtoBuffSerialize protoBuffSerialize = new ProtoBuffSerialize();
protoBuffSerialize.start();
System.err.println();
System.err.println();
JavaSerialize javaSerialize = new JavaSerialize();
javaSerialize.start();
System.err.println();
JsonSerialize jsonSerialize = new JsonSerialize();
jsonSerialize.start();
System.err.println();
FastJsonSerialize fastJsonSerialize = new FastJsonSerialize();
fastJsonSerialize.start();
运行结果：
jprotobuf序列化耗时：7 总大小：148
jprotobuf反序列化耗时：0ms
java serialize: 6 总大小：420
java deserialize: 1ms
json serialize: 37 总大小：341
json deserialize: 27ms
fastJson serialize: 173 总大小：269
fastJson serialize: 35ms
上面的测试仅供参考，并不能代表通过大量数据进行测试的结果。可以发现：序列化后对象的所占大小上：protobuff序列化所占总大小是最少的；其次是fastJson序列化；最后是json序列化和java原生序列化。对于序列化耗时，上面的测试不准。
还是去看看专业测试分析吧，具体情况可以进去看看
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持脚本之家。
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具