信息发布软件,b2b软件,广告发布软件

标题: Java对象序列化使用基础和实例教程 [打印本页]

作者: 信息发布软件 时间: 2016-10-20 15:27
标题: Java对象序列化使用基础和实例教程
所谓对象序列化就是将对象的状态转换成字节流，以后可以通过这些值再生成相同状态的对象。这个过程也可以通过网络实现，可以先在Windows机器上创建一个对象，对其序列化，然后通过网络发给一台Unix机器，然后在那里准确无误地重新"装配"。像RMI、Socket、JMS、EJB它们中的一种，彼此为什么能够传递Java对象，当然都是对象序列化机制的功劳。
Java对象序列化机制一般来讲有两种用途：
Java的JavaBeans： Bean的状态信息通常是在设计时配置的，Bean的状态信息必须被存起来，以便当程序运行时能恢复这些状态信息，这需要将对象的状态保存到文件中，而后能够通过读入对象状态来重新构造对象，恢复程序状态。
RMI允许象在本机上一样操作远程机器上的对象；或使用套接字在网络上传送对象的程序来说，这些都是需要实现serializaiton机制的。
我们通过让类实现Java.io.Serializable 接口可以将类序列化。这个接口是一个制造者（marker）接口。也就是说，对于要实现它的类来说，该接口不需要实现任何方法。它主要用来通知Java虚拟机（JVM），需要将一个对象序列化。
对于这个，有几点我们需要明确：
并非所有类都可以序列化，在cmd下，我们输入serialver Java.net.Socket，可以得到socket是否可序列化的信息，实际上socket是不可序列化的。
Java有很多基础类已经实现了serializable接口，比如string，vector等。但是比如hashtable就没有实现serializable接口。
将对象读出或者写入流的主要类有两个： ObjectOutputStream与ObjectInputStream .ObjectOutputStream 提供用来将对象写入输出流的writeObject方法， ObjectInputStream提供从输入流中读出对象的readObject方法。使用这些方法的对象必须已经被序列化的。也就是说，必须已经实现 Serializable接口。如果你想writeobject一个hashtable对象，那么，会得到一个异常。
序列化的过程就是对象写入字节流和从字节流中读取对象。将对象状态转换成字节流之后，可以用Java.io包中的各种字节流类将其保存到文件中，管道到另一线程中或通过网络连接将对象数据发送到另一主机。对象序列化功能非常简单、强大，在RMI、Socket、JMS、EJB都有应用。对象序列化问题在网络编程中并不是最激动人心的课题，但却相当重要，具有许多实用意义。
对象序列化可以实现分布式对象。主要应用例如：RMI要利用对象序列化运行远程主机上的服务，就像在本地机上运行对象时一样。
Java对象序列化不仅保留一个对象的数据，而且递归保存对象引用的每个对象的数据。可以将整个对象层次写入字节流中，可以保存在文件中或在网络连接上传递。利用对象序列化可以进行对象的“深复制”，即复制对象本身及引用的对象本身。序列化一个对象可能得到整个对象序列。
Java序列化比较简单，通常不需要编写保存和恢复对象状态的定制代码。实现Java.io.Serializable接口的类对象可以转换成字节流或从字节流恢复，不需要在类中增加任何代码。只有极少数情况下才需要定制代码保存或恢复对象状态。这里要注意：不是每个类都可序列化，有些类是不能序列化的，例如涉及线程的类与特定JVM有非常复杂的关系。

序列化机制：
序列化分为两大部分：序列化和反序列化。序列化是这个过程的第一部分，将数据分解成字节流，以便存储在文件中或在网络上传输。反序列化就是打开字节流并重构对象。对象序列化不仅要将基本数据类型转换成字节表示，有时还要恢复数据。恢复数据要求有恢复数据的对象实例。ObjectOutputStream中的序列化过程与字节流连接，包括对象类型和版本信息。反序列化时，JVM用头信息生成对象实例，然后将对象字节流中的数据复制到对象数据成员中。下面我们分两大部分来阐述：
处理对象流：
（序列化过程和反序列化过程）
Java.io包有两个序列化对象的类。ObjectOutputStream负责将对象写入字节流，ObjectInputStream从字节流重构对象。
我们先了解ObjectOutputStream类吧。ObjectOutputStream类扩展DataOutput接口。
writeObject() 方法是最重要的方法，用于对象序列化。如果对象包含其他对象的引用，则writeObject()方法递归序列化这些对象。每个 ObjectOutputStream维护序列化的对象引用表，防止发送同一对象的多个拷贝。（这点很重要）由于writeObject()可以序列化整组交叉引用的对象，因此同一ObjectOutputStream实例可能不小心被请求序列化同一对象。这时，进行反引用序列化，而不是再次写入对象字节流。
下面，让我们从例子中来了解ObjectOutputStream这个类吧。
// 序列化 today's date 到一个文件中.
FileOutputStream  f = new  FileOutputStream ("tmp" );
ObjectOutputStream  s = new  ObjectOutputStream (f);
s.writeObject("Today" );
s.writeObject(new  Date ());
s.flush();
现在，让我们来了解ObjectInputStream这个类。它与ObjectOutputStream相似。它扩展DataInput接口。 ObjectInputStream中的方法镜像DataInputStream中读取Java基本数据类型的公开方法。readObject()方法从字节流中反序列化对象。每次调用readObject()方法都返回流中下一个Object。对象字节流并不传输类的字节码，而是包括类名及其签名。 readObject()收到对象时，JVM装入头中指定的类。如果找不到这个类，则readObject()抛出 ClassNotFoundException,如果需要传输对象数据和字节码，则可以用RMI框架。ObjectInputStream的其余方法用于定制反序列化过程。
例子如下：
//从文件中反序列化 string 对象和 date 对象
FileInputStream  in = new  FileInputStream ("tmp" );
ObjectInputStream  s = new  ObjectInputStream (in);
String  today = (String )s.readObject();
Date  date = (Date )s.readObject();
定制序列化过程:
序列化通常可以自动完成，但有时可能要对这个过程进行控制。java可以将类声明为serializable，但仍可手工控制声明为static或transient的数据成员。
例子：一个非常简单的序列化类。
public  class  simpleSerializableClass implements  Serializable {

String  sToday="Today:" ;
transient  Date  dtToday=new  Date ();
}
序列化时，类的所有数据成员应可序列化除了声明为transient 或static的成员。将变量声明为transient告诉JVM我们会负责将变元序列化。将数据成员声明为transient后，序列化过程就无法将其加进对象字节流中，没有从transient数据成员发送的数据。后面数据反序列化时，要重建数据成员（因为它是类定义的一部分），但不包含任何数据，因为这个数据成员不向流中写入任何数据。记住，对象流不序列化static或transient。我们的类要用writeObject()与 readObject()方法以处理这些数据成员。使用writeObject()与readObject()方法时，还要注意按写入的顺序读取这些数据成员。
关于如何使用定制序列化的部分代码如下
//重写writeObject()方法以便处理transient的成员。
public  void  writeObject(ObjectOutputStream  outputStream) throws  IOException {
outputStream.defaultWriteObject();//使定制的writeObject()方法可以
利用自动序列化中内置的逻辑。
outputStream.writeObject(oSocket.getInetAddress());
outputStream.writeInt(oSocket.getPort());
}
//重写readObject()方法以便接收transient的成员。
private  void  readObject(ObjectInputStream  inputStream) throws IOException ,
ClassNotFoundException {
inputStream.defaultReadObject();//defaultReadObject()补充自动序列化
InetAddress  oAddress=(InetAddress )inputStream.readObject();
int  iPort =inputStream.readInt();
oSocket = new  Socket (oAddress,iPort);
iID=getID();
dtToday =new  Date ();
}
完全定制序列化过程:
如果一个类要完全负责自己的序列化，则实现Externalizable接口而不是Serializable接口。Externalizable接口定义包括两个方法writeExternal()与readExternal()。利用这些方法可以控制对象数据成员如何写入字节流.类实现 Externalizable时，头写入对象流中，然后类完全负责序列化和恢复数据成员，除了头以外，根本没有自动序列化。这里要注意了。声明类实现 Externalizable接口会有重大的安全风险。writeExternal()与readExternal()方法声明为public，恶意类可以用这些方法读取和写入对象数据。如果对象包含敏感信息，则要格外小心。这包括使用安全套接或加密整个字节流。到此为至，我们学习了序列化的基础部分知识。

作者: 信息发布软件 时间: 2016-10-20 15:30

在这篇文章里，我们关注对象序列化。

　　首先，我们来讨论一下什么是序列化以及序列化的原理；然后给出一个简单的示例来演示序列化和反序列化；有时有些信息是不应该被序列化的，我们应该如何控制；我们如何去自定义序列化内容；最后我们讨论一下在继承结构的场景中，序列化需要注意哪些内容。

　　序列化概述

　　序列化，简单来讲，就是以“流”的方式来保存对象，至于保存的目标地址，可以是文件，可以是数据库，也可以是网络，即通过网络将对象从一个节点传递到另一个节点。

　　我们知道在Java的I/O结构中，有ObjectOutputStream和ObjectInputStream，它们可以实现将对象输出为二进制流，并从二进制流中获取对象，那为什么还需要序列化呢？这需要从Java变量的存储结构谈起，我们知道对Java来说，基础类型存储在栈上，复杂类型（引用类型）存储在堆中，对于基础类型来说，上述的操作时可行的，但对复杂类型来说，上述操作过程中，可能会产生重复的对象，造成错误。

　　而序列化的工作流程如下：

　　1）通过输出流保存的对象都有一个唯一的序列号。

　　2）当一个对象需要保存时，先对其序列号进行检查。

　　3）当保存的对象中已包含该序列号时，不需要再次保存，否则，进入正常保存的流程。

　　正是通过序列号的机制，序列化才可以完整准确的保存对象的各个状态。

　　序列化保存的是对象中的各个属性的值，而不是方法或者方法签名之类的信息。对于方法或者方法签名，只要JVM能够找到正确的ClassLoader，那么就可以invoke方法。

　　序列化不会保存类的静态变量，因为静态变量是作用于类型，而序列化作用于对象。

　　简单的序列化示例

　　序列化的完整过程包括两部分：

　　1）使用ObjectOutputStream将对象保存为二进制流，这一步叫做“序列化”。

　　2）使用ObjectInputStream将二进制流转换成对象，这一步叫做“反序列化”。

　　下面我们来演示一个简单的示例，首先定义一个Person对象，它包含name和age两个信息。

定义Person对象

　　然后是两个公共方法，用来完成读、写对象的操作：

1 private static void writeObject(Object obj, String filePath) 2 { 3 try 4 { 5 FileOutputStream fos = new FileOutputStream(filePath); 6 ObjectOutputStream os = new ObjectOutputStream(fos); 7 os.writeObject(obj); 8 os.flush(); 9 fos.flush();10 os.close();11 fos.close();12 System.out.println("序列化成功。");13 }14 catch(Exception ex)15 {16 ex.printStackTrace();17 }18 }19 20 private static Object readObject(String filePath)21 {22 try23 {24 FileInputStream fis = new FileInputStream(filePath);25 ObjectInputStream is = new ObjectInputStream(fis);26 27 Object temp = is.readObject();28 29 fis.close();30 is.close();31 32 if (temp != null)33 {34 System.out.println("反序列化成功。");35 return temp;36 }37 }38 catch(Exception ex)39 {40 ex.printStackTrace();41 }42 43 return null;44 } Java对象序列化使用基础和实例教程 b2b软件

　　这里，我们将对象保存的二进制流输出到磁盘文件中。

　　接下来，我们首先来看“序列化”的方法：

1 private static void serializeTest1()2 {3 Person person = new Person();4 person.setName("Zhang San");5 person.setAge(30);6 System.out.println(person);7 writeObject(person, "d:\\temp\\test\\person.obj");8 } Java对象序列化使用基础和实例教程 b2b软件

　　我们定义了一个Person实例，然后将其保存到d:\temp\test\person.obj中。

　　最后，是“反序列化”的方法：

1 private static void deserializeTest1()2 { 3 Person temp = (Person)readObject("d:\\temp\\test\\person.obj");4 5 if (temp != null)6 {7 System.out.println(temp);8 }9 } Java对象序列化使用基础和实例教程 b2b软件

　　它从d:\temp\test\person.obj中读取对象，然后进行输出。

　　上述两个方法的执行结果如下：

Name:Zhang San; Age:30序列化成功。反序列化成功。Name:Zhang San; Age:30

　　可以看出，读取的对象和保存的对象是完全一致的。

　　隐藏非序列化信息

　　有时，我们的业务对象中会包含很多属性，而有些属性是比较隐私的，例如年龄、银行卡号等，这些信息是不太适合进行序列化的，特别是在需要通过网络来传输对象信息时，这些敏感信息很容易被窃取。

　　Java使用transient关键字来处理这种情况，针对那些敏感的属性，我们只需使用该关键字进行修饰，那么在序列化时，对应的属性值就不会被保存。

　　我们还是看一个实例，这次我们定义一个新的Person2，其中age信息是我们不希望序列化的：

定义Person2对象

　　注意age的声明语句：

1 private transient int age;

　　下面是“序列化”和“反序列化”的方法：

1 private static void serializeTest2() 2 { 3 Person2 person = new Person2(); 4 person.setName("Zhang San"); 5 person.setAge(30); 6 System.out.println(person); 7 writeObject(person, "d:\\temp\\test\\person2.obj"); 8 } 9 10 private static void deserializeTest2()11 { 12 Person2 temp = (Person2)readObject("d:\\temp\\test\\person2.obj");13 14 if (temp != null)15 {16 System.out.println(temp);17 }18 } Java对象序列化使用基础和实例教程 b2b软件

　　它的输出结果如下：

Name:Zhang San; Age:30序列化成功。反序列化成功。Name:Zhang San; Age:0

　　可以看到经过反序列化的对象，age的信息变成了Integer的默认值0。

　　自定义序列化过程

　　我们可以对序列化的过程进行定制，进行更细粒度的控制。

　　思路是在业务模型中添加readObject和writeObject方法。下面看一个实例，我们新建一个类型，叫Person3：

1 class Person3 implements Serializable 2 { 3 private String name; 4 private transient int age; 5 public void setName(String name) { 6 this.name = name; 7 } 8 public String getName() { 9 return name;10 }11 public void setAge(int age) {12 this.age = age;13 }14 public int getAge() {15 return age;16 }17 18 public String toString()19 {20 return "Name:" + name + "; Age:" + age;21 }22 23 private void writeObject(ObjectOutputStream os)24 {25 try26 {27 os.defaultWriteObject();28 os.writeObject(this.age);29 System.out.println(this);30 System.out.println("序列化成功。");31 }32 catch(Exception ex)33 {34 ex.printStackTrace();35 }36 }37 38 private void readObject(ObjectInputStream is)39 {40 try41 {42 is.defaultReadObject();43 this.setAge(((Integer)is.readObject()).intValue() - 1);44 System.out.println("反序列化成功。");45 System.out.println(this);46 }47 catch(Exception ex)48 {49 ex.printStackTrace();50 }51 }52 } Java对象序列化使用基础和实例教程 b2b软件

　　请注意观察readObject和writeObject方法，它们都是private的，接受的参数是ObjectStream，然后在方法体内调用了defaultReadObject或者defaultWriteObject方法。

　　这里age同样是transient的，但是在保存对象的过程中，我们单独对其进行了保存，在读取时，我们将age信息读取出来，并进行了减1处理。

　　下面是测试方法：

1 private static void serializeTest3() 2 { 3 Person3 person = new Person3(); 4 person.setName("Zhang San"); 5 person.setAge(30); 6 System.out.println(person); 7 try 8 { 9 FileOutputStream fos = new FileOutputStream("d:\\temp\\test\\person3.obj");10 ObjectOutputStream os = new ObjectOutputStream(fos);11 os.writeObject(person);12 fos.close();13 os.close();14 }15 catch(Exception ex)16 {17 ex.printStackTrace();18 }19 }20 21 private static void deserializeTest3()22 { 23 try24 {25 FileInputStream fis = new FileInputStream("d:\\temp\\test\\person3.obj");26 ObjectInputStream is = new ObjectInputStream(fis);27 is.readObject();28 fis.close();29 is.close();30 }31 catch(Exception ex)32 {33 ex.printStackTrace();34 }35 } Java对象序列化使用基础和实例教程 b2b软件

　　输出结果如下：

Name:Zhang San; Age:30序列化成功。反序列化成功。Name:Zhang San; Age:29

　　可以看到，经过反序列化得到的对象，其age属性已经减1。

　　探讨serialVersionUID

　　在上文中，我们描述序列化原理时，曾经提及每个对象都会有一个唯一的序列号，这个序列号，就是serialVersionUID。

　　当我们的对象实现Serializable接口时，该接口可以为我们生成serialVersionUID。

　　有两种方式来生成serialVersionUID，一种是固定值：1L，一种是经过JVM计算，不同的JVM采取的计算算法可能不同。

　　下面就是两个serialVersionUID的示例：

1 private static final long serialVersionUID = 1L;2 private static final long serialVersionUID = -2380764581294638541L;

　　第一行是采用固定值生成的；第二行是JVM经过计算得出的。

　　那么serialVersionUID还有其他用途吗？

　　我们可以使用它来控制版本兼容。如果采用JVM生成的方式，我们可以看到，当我们业务对象的代码保持不变时，多次生成的serialVersionUID也是不变的，当我们对属性进行修改时，重新生成的serialVersionUID会发生变化，当我们对方法进行修改时，serialVersionUID不变。这也从另一个侧面说明，序列化是作用于对象属性上的。

　　当我们先定义了业务对象，然后对其示例进行了“序列化”，这时根据业务需求，我们修改了业务对象，那么之前“序列化”后的内容还能经过“反序列化”返回到系统中吗？这取决于业务对象是否定义了serialVersionUID，如果定义了，那么是可以返回的，如果没有定义，会抛出异常。

　　来看下面的示例，定义新的类型Person4：

1 class Person4 implements Serializable 2 { 3 private String name; 4 private int age; 5 public void setName(String name) { 6 this.name = name; 7 } 8 public String getName() { 9 return name;10 }11 public void setAge(int age) {12 this.age = age;13 }14 public int getAge() {15 return age;16 }17 private void xxx(){}18 19 public String toString()20 {21 return "Name:" + name + "; Age:" + age;22 }23 } Java对象序列化使用基础和实例教程 b2b软件

　　然后运行下面的方法：

1 private static void serializeTest4()2 {3 Person4 person = new Person4();4 person.setName("Zhang San");5 person.setAge(30);6 7 writeObject(person, "d:\\temp\\test\\person4.obj");8 } Java对象序列化使用基础和实例教程 b2b软件

　　接下来修改Person4，追加address属性：

1 class Person4 implements Serializable 2 { 3 private String name; 4 private int age; 5 private String address; 6 public void setName(String name) { 7 this.name = name; 8 } 9 public String getName() {10 return name;11 }12 public void setAge(int age) {13 this.age = age;14 }15 public int getAge() {16 return age;17 }18 private void xxx(){}19 20 public String toString()21 {22 return "Name:" + name + "; Age:" + age;23 }24 public void setAddress(String address) {25 this.address = address;26 }27 public String getAddress() {28 return address;29 }30 } Java对象序列化使用基础和实例教程 b2b软件

　　然后运行“反序列化”方法：

1 private static void deserializeTest4()2 { 3 Person4 temp = (Person4)readObject("d:\\temp\\test\\person4.obj");4 5 if (temp != null)6 {7 System.out.println(temp);8 }9 } Java对象序列化使用基础和实例教程 b2b软件

　　可以看到，运行结果如下：

java.io.InvalidClassException: sample.serialization.Person4; local class incompatible: stream classdesc serialVersionUID = -2380764581294638541, local class serialVersionUID = -473458100724786987 at java.io.ObjectStreamClass.initNonProxy(Unknown Source) at java.io.ObjectInputStream.readNonProxyDesc(Unknown Source) at java.io.ObjectInputStream.readClassDesc(Unknown Source) at java.io.ObjectInputStream.readOrdinaryObject(Unknown Source) at java.io.ObjectInputStream.readObject0(Unknown Source) at java.io.ObjectInputStream.readObject(Unknown Source) at sample.serialization.Sample.readObject(Sample.java:158) at sample.serialization.Sample.deserializeTest4(Sample.java:105) at sample.serialization.Sample.main(Sample.java:16) Java对象序列化使用基础和实例教程 b2b软件

　　但是当我们在Person4中添加serialVersionUID后，再次执行上述各步骤，得出的运行结果如下：

反序列化成功。Name:Zhang San; Age:30
　　有继承结构的序列化

　　业务对象会产生继承，这在管理系统中是经常看到的，如果我们有下面的业务对象：

1 class Person5 2 { 3 private String name; 4 private int age; 5 public void setName(String name) { 6 this.name = name; 7 } 8 public String getName() { 9 return name;10 }11 public void setAge(int age) {12 this.age = age;13 }14 public int getAge() {15 return age;16 }17 18 public String toString()19 {20 return "Name:" + name + "; Age:" + age;21 }22 23 public Person5(String name, int age)24 {25 this.name = name;26 this.age = age;27 }28 }29 30 class Employee extends Person5 implements Serializable31 {32 public Employee(String name, int age) {33 super(name, age);34 }35 36 private String companyName;37 38 public void setCompanyName(String companyName) {39 this.companyName = companyName;40 }41 42 public String getCompanyName() {43 return companyName;44 }45 46 public String toString()47 {48 return "Name:" + super.getName() + "; Age:" + super.getAge() + "; Company:" + this.companyName;49 }50 } Java对象序列化使用基础和实例教程 b2b软件

　　Employee继承在Person5，Employee实现了Serializable接口，Person5没有实现，那么运行下面的方法：

1 private static void serializeTest5() 2 { 3 Employee emp = new Employee("Zhang San", 30); 4 emp.setCompanyName("XXX"); 5 6 writeObject(emp, "d:\\temp\\test\\employee.obj"); 7 } 8 9 private static void deserializeTest5()10 { 11 Employee temp = (Employee)readObject("d:\\temp\\test\\employee.obj");12 13 if (temp != null)14 {15 System.out.println(temp);16 }17 } Java对象序列化使用基础和实例教程 b2b软件

　　会正常运行吗？事实上不会，它会抛出如下异常：

java.io.InvalidClassException: sample.serialization.Employee; no valid constructor at java.io.ObjectStreamClass$ExceptionInfo.newInvalidClassException(Unknown Source) at java.io.ObjectStreamClass.checkDeserialize(Unknown Source) at java.io.ObjectInputStream.readOrdinaryObject(Unknown Source) at java.io.ObjectInputStream.readObject0(Unknown Source) at java.io.ObjectInputStream.readObject(Unknown Source) at sample.serialization.Sample.readObject(Sample.java:158) at sample.serialization.Sample.deserializeTest5(Sample.java:123) at sample.serialization.Sample.main(Sample.java:18)

　　原因：在有继承层次的业务对象，进行序列化时，如果父类没有实现Serializable接口，那么父类必须提供默认构造函数。

　　我们为Person5添加如下默认构造函数：

1 public Person5()2 {3 this.name = "Test";4 this.age = 1;5 }

　　再次运行上述代码，结果如下：

Name:Zhang San; Age:30; Company:XXX序列化成功。反序列化成功。Name:Test; Age:1; Company:XXX

　　可以看到，反序列化后的结果，父类中的属性，已经被父类构造函数中的赋值代替了！

　　因此，我们推荐在有继承层次的业务对象进行序列化时，父类也应该实现Serializable接口。我们对Person5进行修改，使其实现Serializable接口，执行结果如下：

Name:Zhang San; Age:30; Company:XXX序列化成功。反序列化成功。Name:Zhang San; Age:30; Company:XXX

　　这正是我们期望的结果。

作者: 信息发布软件 时间: 2016-10-20 15:40

Java中的对象的内部状态只保存在内存中，其生命周期最长与JVM的生命周期一样，即JVM停止之后，所有对象都会被销毁。但有时候，Java对象是需要持久化的，因此Java提供了一种对象持久化方式——对象序列化机制(Object serialization)，可以很容易的在JVM中的活动对象和字节数组（流）之间进行转换。

对象序列化保存的是对象的”状态”，即它的成员变量。由此可知，对象序列化不会关注类中的静态变量。

除了在持久化对象时会用到对象序列化之外，当使用RMI(远程方法调用)，或在网络中传递对象时，都会用到对象序列化。

注意：序列化的是对象（对象的状态，成员变量等），而不是类

简单示例?

100

101

[size=1em]<code [size=1em]class[size=1em]=[size=1em]"hljs java"[size=1em]>[size=1em]package [size=1em]java_interview;
[size=1em]import [size=1em]java.io.File;
[size=1em]import [size=1em]java.io.FileInputStream;
[size=1em]import [size=1em]java.io.FileOutputStream;
[size=1em]import [size=1em]java.io.ObjectInputStream;
[size=1em]import [size=1em]java.io.ObjectOutputStream;
[size=1em]import [size=1em]java.io.Serializable;
[size=1em]import [size=1em]java.lang.reflect.Field;
[size=1em]import [size=1em]java.util.ArrayList;
[size=1em]import [size=1em]java.util.Arrays;
[size=1em]import [size=1em]java.util.Collections;
[size=1em]import [size=1em]java.util.Comparator;
[size=1em]import [size=1em]java.util.HashMap;
[size=1em]import [size=1em]java.util.HashSet;
[size=1em]import [size=1em]java.util.Iterator;
[size=1em]import [size=1em]java.util.List;
[size=1em]import [size=1em]java.util.Map;
[size=1em]import [size=1em]java.util.NavigableMap;
[size=1em]import [size=1em]java.util.Random;
[size=1em]import [size=1em]java.util.Scanner;
[size=1em]import [size=1em]java.util.TreeMap;
[size=1em]import [size=1em]java.util.TreeSet;
[size=1em]public [size=1em]class [size=1em]Test {

[size=1em] [size=1em]public [size=1em]static [size=1em]void [size=1em]main(String[] args) [size=1em]throws [size=1em]Exception {

[size=1em] [size=1em]}
[size=1em]}
[size=1em] [size=1em]enum [size=1em]Gender {
[size=1em] [size=1em]MALE, FEMALE
[size=1em]}
[size=1em]class [size=1em]Person [size=1em]implements [size=1em]Serializable {

[size=1em] [size=1em]private [size=1em]String name = [size=1em]null[size=1em];

[size=1em] [size=1em]private [size=1em]Integer age = [size=1em]null[size=1em];

[size=1em] [size=1em]private [size=1em]Gender gender = [size=1em]null[size=1em];

[size=1em] [size=1em]public [size=1em]Person() {
[size=1em]       [size=1em]System.out.println([size=1em]"none-arg constructor"[size=1em]);
[size=1em] [size=1em]}

[size=1em] [size=1em]public [size=1em]Person(String name, Integer age, Gender gender) {
[size=1em]       [size=1em]System.out.println([size=1em]"arg constructor"[size=1em]);
[size=1em]       [size=1em]this[size=1em].name = name;
[size=1em]       [size=1em]this[size=1em].age = age;
[size=1em]       [size=1em]this[size=1em].gender = gender;
[size=1em] [size=1em]}

[size=1em] [size=1em]public [size=1em]String getName() {
[size=1em]       [size=1em]return [size=1em]name;
[size=1em] [size=1em]}

[size=1em] [size=1em]public [size=1em]void [size=1em]setName(String name) {
[size=1em]       [size=1em]this[size=1em].name = name;
[size=1em] [size=1em]}

[size=1em] [size=1em]public [size=1em]Integer getAge() {
[size=1em]       [size=1em]return [size=1em]age;
[size=1em] [size=1em]}

[size=1em] [size=1em]public [size=1em]void [size=1em]setAge(Integer age) {
[size=1em]       [size=1em]this[size=1em].age = age;
[size=1em] [size=1em]}

[size=1em] [size=1em]public [size=1em]Gender getGender() {
[size=1em]       [size=1em]return [size=1em]gender;
[size=1em] [size=1em]}

[size=1em] [size=1em]public [size=1em]void [size=1em]setGender(Gender gender) {
[size=1em]       [size=1em]this[size=1em].gender = gender;
[size=1em] [size=1em]}

[size=1em] [size=1em]@Override
[size=1em] [size=1em]public [size=1em]String toString() {
[size=1em]       [size=1em]return [size=1em]"[" [size=1em]+ name + [size=1em]", " [size=1em]+ age + [size=1em]", " [size=1em]+ gender + [size=1em]"]"[size=1em];
[size=1em] [size=1em]}
[size=1em]}
[size=1em]public [size=1em]class [size=1em]SimpleSerial {

[size=1em] [size=1em]public [size=1em]static [size=1em]void [size=1em]main(String[] args) [size=1em]throws [size=1em]Exception {
[size=1em]       [size=1em]File file = [size=1em]new [size=1em]File([size=1em]"person.out"[size=1em]);

[size=1em]       [size=1em]ObjectOutputStream oout = [size=1em]new [size=1em]ObjectOutputStream([size=1em]new [size=1em]FileOutputStream(file));
[size=1em]       [size=1em]Person person = [size=1em]new [size=1em]Person([size=1em]"John"[size=1em], [size=1em]101[size=1em], Gender.MALE);
[size=1em]       [size=1em]oout.writeObject(person);
[size=1em]       [size=1em]oout.close();

[size=1em]       [size=1em]ObjectInputStream oin = [size=1em]new [size=1em]ObjectInputStream([size=1em]new [size=1em]FileInputStream(file));
[size=1em]       [size=1em]Object newPerson = oin.readObject(); [size=1em]// 没有强制转换到Person类型
[size=1em]       [size=1em]oin.close();
[size=1em]       [size=1em]System.out.println(newPerson);
[size=1em] [size=1em]}
[size=1em]}
[size=1em]/*输出：
[size=1em]arg constructor
[size=1em][John, 101, MALE]

[size=1em]*/
[size=1em]</code>

此时必须注意的是，当重新读取被保存的Person对象时，并没有调用Person的任何构造器，看起来就像是直接使用字节将Person对象还原出来的。

当Person对象被保存到person.out文件中之后，我们可以在其它地方去读取该文件以还原对象，但必须确保该读取程序的CLASSPATH中包含有Person.class(哪怕在读取Person对象时并没有显示地使用Person类，如上例所示)，否则会抛出ClassNotFoundException。

Serializable的作用

什么一个类实现了Serializable接口，它就可以被序列化呢？在上节的示例中，使用ObjectOutputStream来持久化对象，在该类中有如下代码：

[size=1em]<code [size=1em]class[size=1em]=[size=1em]"hljs java"[size=1em]>[size=1em]private [size=1em]void [size=1em]writeObject0(Object obj, [size=1em]boolean [size=1em]unshared) [size=1em]throws [size=1em]IOException {

[size=1em] [size=1em]if [size=1em](obj [size=1em]instanceof [size=1em]String) {
[size=1em]       [size=1em]writeString((String) obj, unshared);
[size=1em] [size=1em]} [size=1em]else [size=1em]if [size=1em](cl.isArray()) {
[size=1em]       [size=1em]writeArray(obj, desc, unshared);
[size=1em] [size=1em]} [size=1em]else [size=1em]if [size=1em](obj [size=1em]instanceof [size=1em]Enum) {
[size=1em]       [size=1em]writeEnum((Enum) obj, desc, unshared);
[size=1em] [size=1em]} [size=1em]else [size=1em]if [size=1em](obj [size=1em]instanceof [size=1em]Serializable) {
[size=1em]       [size=1em]writeOrdinaryObject(obj, desc, unshared);
[size=1em] [size=1em]} [size=1em]else [size=1em]{
[size=1em]       [size=1em]if [size=1em](extendedDebugInfo) {
[size=1em]          [size=1em]throw [size=1em]new [size=1em]NotSerializableException(cl.getName() + [size=1em]"\n"
[size=1em]                   [size=1em]+ debugInfoStack.toString());
[size=1em]       [size=1em]} [size=1em]else [size=1em]{
[size=1em]          [size=1em]throw [size=1em]new [size=1em]NotSerializableException(cl.getName());
[size=1em]       [size=1em]}
[size=1em] [size=1em]}

[size=1em]}</code>

从上述代码可知，如果被写对象的类型是String，或数组，或Enum，或Serializable，那么就可以对该对象进行序列化，否则将抛出NotSerializableException。

默认序列化机制

如果仅仅只是让某个类实现Serializable接口，而没有其它任何处理的话，则就是使用默认序列化机制。

默认的序列化机制，是对对象的所有成员变量(静态变量不会被序列化，因为它不属于某个对象，是所有对象共享的)进行序列化

使用默认机制，在序列化对象时，不仅会序列化当前对象本身，还会对该对象引用的其它对象也进行序列化，同样地，这些其它对象引用的另外对象也将被序列化，以此类推。所以，如果一个对象包含的成员变量是容器类对象，而这些容器所含有的元素也是容器类对象，那么这个序列化的过程就会较复杂，开销也较大。

影响序列化

在现实应用中，有些时候不能使用默认序列化机制。比如，希望在序列化过程中忽略掉敏感数据，或者简化序列化过程。下面将介绍若干影响序列化的方法。

transient关键字

有些情况下，是不希望对象的所有成员变量都进行序列化，比如User中的passwd字段，这个是敏感数据，不希望它被序列化，那么就可以使用transient关键字。
transient，顾名思义，非持久化的。使用transient关键字修饰成员变量，能够使它在序列化的过程中被忽略。

此处将Person类中的age字段声明为transient，如下所示，

再执行SimpleSerial应用程序，会有如下输出：

1 2	[size=1em]<code [size=1em]class[size=1em]=[size=1em]"hljs delphi"[size=1em]>arg constructor [size=1em][John, [size=1em]null[size=1em], MALE]</code>

* writeObject()方法与readObject()方法*

对于上述已被声明为transitive的字段age，除了将transitive关键字去掉之外，是否还有其它方法能使它再次可被序列化？方法之一就是在Person类中添加两个方法：writeObject()与readObject()，如下所示：

在writeObject()方法中会先调用ObjectOutputStream中的defaultWriteObject()方法，该方法会执行默认的序列化机制，如5.1节所述，此时会忽略掉age字段。然后再调用writeInt()方法显示地将age字段写入到ObjectOutputStream中。readObject()的作用则是针对对象的读取，其原理与writeObject()方法相同。

再次执行SimpleSerial应用程序，则又会有如下输出：

1 2	[size=1em]<code [size=1em]class[size=1em]=[size=1em]"hljs delphi"[size=1em]>arg constructor [size=1em][John, [size=1em]31[size=1em], MALE]</code>

必须注意地是，writeObject()与readObject()都是private方法，那么它们是如何被调用的呢？毫无疑问，是使用反射。详情可见ObjectOutputStream中的writeSerialData方法，以及ObjectInputStream中的readSerialData方法。

通过这两个方法，可以对特殊要求的字段，增加额外的加密，解密的代码

Externalizable接口

以上例子都是基于实现Serializable接口来实现序列化的，Externalizable接口继承于Serializable，通过实现Externalizable接口也能实现序列化，不同的是，序列化操作的细节需要自己实现，而且，必须提供public的无参构造函数，否则会出现以下错误：

Java对象序列化使用基础和实例教程 b2b软件

无论是使用transient关键字，还是使用writeObject()和readObject()方法，其实都是基于Serializable接口的序列化。JDK中提供了另一个序列化接口–Externalizable，使用该接口之后，之前基于Serializable接口的序列化机制就将失效。此时将Person类修改成如下，

[size=1em]<code [size=1em]class[size=1em]=[size=1em]"hljs java"[size=1em]>[size=1em]public [size=1em]class [size=1em]Person [size=1em]implements [size=1em]Externalizable {

[size=1em] [size=1em]private [size=1em]String name = [size=1em]null[size=1em];

[size=1em] [size=1em]transient [size=1em]private [size=1em]Integer age = [size=1em]null[size=1em];

[size=1em] [size=1em]private [size=1em]Gender gender = [size=1em]null[size=1em];

[size=1em] [size=1em]public [size=1em]Person() {
[size=1em]       [size=1em]System.out.println([size=1em]"none-arg constructor"[size=1em]);
[size=1em] [size=1em]}

[size=1em] [size=1em]public [size=1em]Person(String name, Integer age, Gender gender) {
[size=1em]       [size=1em]System.out.println([size=1em]"arg constructor"[size=1em]);
[size=1em]       [size=1em]this[size=1em].name = name;
[size=1em]       [size=1em]this[size=1em].age = age;
[size=1em]       [size=1em]this[size=1em].gender = gender;
[size=1em] [size=1em]}

[size=1em] [size=1em]private [size=1em]void [size=1em]writeObject(ObjectOutputStream out) [size=1em]throws [size=1em]IOException {
[size=1em]       [size=1em]out.defaultWriteObject();
[size=1em]       [size=1em]out.writeInt(age);
[size=1em] [size=1em]}

[size=1em] [size=1em]private [size=1em]void [size=1em]readObject(ObjectInputStream in) [size=1em]throws [size=1em]IOException, ClassNotFoundException {
[size=1em]       [size=1em]in.defaultReadObject();
[size=1em]       [size=1em]age = in.readInt();
[size=1em] [size=1em]}

[size=1em] [size=1em]@Override
[size=1em] [size=1em]public [size=1em]void [size=1em]writeExternal(ObjectOutput out) [size=1em]throws [size=1em]IOException {

[size=1em] [size=1em]}

[size=1em] [size=1em]@Override
[size=1em] [size=1em]public [size=1em]void [size=1em]readExternal(ObjectInput in) [size=1em]throws [size=1em]IOException, ClassNotFoundException {

[size=1em] [size=1em]}

[size=1em]}</code>

此时再执行SimpleSerial程序之后会得到如下结果：

[size=1em]<code [size=1em]class[size=1em]=[size=1em]"hljs delphi"[size=1em]>arg constructor
[size=1em]none-arg constructor
[size=1em][[size=1em]null[size=1em], [size=1em]null[size=1em], [size=1em]null[size=1em]]</code>

从该结果，一方面可以看出Person对象中任何一个字段都没有被序列化。另一方面，如果细心的话，还可以发现这此次序列化过程调用了Person类的无参构造器。

另外，若使用Externalizable进行序列化，当读取对象时，会调用被序列化类的无参构造器去创建一个新的对象，然后再将被保存对象的字段的值分别填充到新对象中。这就是为什么在此次序列化过程中Person类的无参构造器会被调用。由于这个原因，实现Externalizable接口的类必须要提供一个无参的构造器，且它的访问权限为public。

对上述Person类作进一步的修改，使其能够对name与age字段进行序列化，但要忽略掉gender字段，如下代码所示：

[size=1em]<code [size=1em]class[size=1em]=[size=1em]"hljs java"[size=1em]>[size=1em]public [size=1em]class [size=1em]Person [size=1em]implements [size=1em]Externalizable {

[size=1em] [size=1em]private [size=1em]String name = [size=1em]null[size=1em];

[size=1em] [size=1em]transient [size=1em]private [size=1em]Integer age = [size=1em]null[size=1em];

[size=1em] [size=1em]private [size=1em]Gender gender = [size=1em]null[size=1em];

[size=1em] [size=1em]public [size=1em]Person() {
[size=1em]       [size=1em]System.out.println([size=1em]"none-arg constructor"[size=1em]);
[size=1em] [size=1em]}

[size=1em] [size=1em]public [size=1em]Person(String name, Integer age, Gender gender) {
[size=1em]       [size=1em]System.out.println([size=1em]"arg constructor"[size=1em]);
[size=1em]       [size=1em]this[size=1em].name = name;
[size=1em]       [size=1em]this[size=1em].age = age;
[size=1em]       [size=1em]this[size=1em].gender = gender;
[size=1em] [size=1em]}

[size=1em] [size=1em]private [size=1em]void [size=1em]writeObject(ObjectOutputStream out) [size=1em]throws [size=1em]IOException {
[size=1em]       [size=1em]out.defaultWriteObject();
[size=1em]       [size=1em]out.writeInt(age);
[size=1em] [size=1em]}

[size=1em] [size=1em]private [size=1em]void [size=1em]readObject(ObjectInputStream in) [size=1em]throws [size=1em]IOException, ClassNotFoundException {
[size=1em]       [size=1em]in.defaultReadObject();
[size=1em]       [size=1em]age = in.readInt();
[size=1em] [size=1em]}

[size=1em] [size=1em]@Override
[size=1em] [size=1em]public [size=1em]void [size=1em]writeExternal(ObjectOutput out) [size=1em]throws [size=1em]IOException {
[size=1em]       [size=1em]out.writeObject(name);
[size=1em]       [size=1em]out.writeInt(age);
[size=1em] [size=1em]}

[size=1em] [size=1em]@Override
[size=1em] [size=1em]public [size=1em]void [size=1em]readExternal(ObjectInput in) [size=1em]throws [size=1em]IOException, ClassNotFoundException {
[size=1em]       [size=1em]name = (String) in.readObject();
[size=1em]       [size=1em]age = in.readInt();
[size=1em] [size=1em]}

[size=1em]}</code>

执行SimpleSerial之后会有如下结果：

[size=1em]<code [size=1em]class[size=1em]=[size=1em]"hljs delphi"[size=1em]>arg constructor
[size=1em]none-arg constructor
[size=1em][John, [size=1em]31[size=1em], [size=1em]null[size=1em]]</code>

可知：采用这种方法实现序列化，transient是不起作用的，如果你不想序列化某个成员变量，只要在readExternal和writeExternal中不对该变量进行相应操作就可以了。

readResolve()方法

当我们使用Singleton模式时，应该是期望某个类的实例应该是唯一的，但如果该类是可序列化的，那么情况可能会略有不同。此时对第2节使用的Person类进行修改，使其实现Singleton模式，如下所示：

同时要修改SimpleSerial应用，使得能够保存/获取上述单例对象，并进行对象相等性比较，如下代码所示：

[size=1em]<code [size=1em]class[size=1em]=[size=1em]"hljs cs"[size=1em]>[size=1em]public [size=1em]class [size=1em]SimpleSerial {

[size=1em] [size=1em]public [size=1em]static [size=1em]void [size=1em]main(String[] args) [size=1em]throws [size=1em]Exception {
[size=1em]       [size=1em]File file = [size=1em]new [size=1em]File([size=1em]"person.out"[size=1em]);
[size=1em]       [size=1em]ObjectOutputStream oout = [size=1em]new [size=1em]ObjectOutputStream([size=1em]new [size=1em]FileOutputStream(file));
[size=1em]       [size=1em]oout.writeObject(Person.getInstance()); [size=1em]// 保存单例对象
[size=1em]       [size=1em]oout.close();

[size=1em]       [size=1em]ObjectInputStream oin = [size=1em]new [size=1em]ObjectInputStream([size=1em]new [size=1em]FileInputStream(file));
[size=1em]       [size=1em]Object newPerson = oin.readObject();
[size=1em]       [size=1em]oin.close();
[size=1em]       [size=1em]System.out.println(newPerson);

[size=1em]       [size=1em]System.out.println(Person.getInstance() == newPerson); [size=1em]// 将获取的对象与Person类中的单例对象进行相等性比较
[size=1em] [size=1em]}
[size=1em]}</code>

执行上述应用程序后会得到如下结果：

[size=1em]<code [size=1em]class[size=1em]=[size=1em]"hljs delphi"[size=1em]>arg constructor
[size=1em][John, [size=1em]31[size=1em], MALE]
[size=1em]false[size=1em]</code>

值得注意的是，从文件person.out中获取的Person对象与Person类中的单例对象并不相等。为了能在序列化过程仍能保持单例的特性，可以在Person类中添加一个readResolve()方法，在该方法中直接返回Person的单例对象，如下所示：

[size=1em]<code [size=1em]class[size=1em]=[size=1em]"hljs java"[size=1em]>[size=1em]public [size=1em]class [size=1em]Person [size=1em]implements [size=1em]Serializable {

[size=1em] [size=1em]private [size=1em]static [size=1em]class [size=1em]InstanceHolder {
[size=1em]       [size=1em]private [size=1em]static [size=1em]final [size=1em]Person instatnce = [size=1em]new [size=1em]Person([size=1em]"John"[size=1em], [size=1em]31[size=1em], Gender.MALE);
[size=1em] [size=1em]}

[size=1em] [size=1em]public [size=1em]static [size=1em]Person getInstance() {
[size=1em]       [size=1em]return [size=1em]InstanceHolder.instatnce;
[size=1em] [size=1em]}

[size=1em] [size=1em]private [size=1em]String name = [size=1em]null[size=1em];

[size=1em] [size=1em]private [size=1em]Integer age = [size=1em]null[size=1em];

[size=1em] [size=1em]private [size=1em]Gender gender = [size=1em]null[size=1em];

[size=1em] [size=1em]private [size=1em]Person() {
[size=1em]       [size=1em]System.out.println([size=1em]"none-arg constructor"[size=1em]);
[size=1em] [size=1em]}

[size=1em] [size=1em]private [size=1em]Person(String name, Integer age, Gender gender) {
[size=1em]       [size=1em]System.out.println([size=1em]"arg constructor"[size=1em]);
[size=1em]       [size=1em]this[size=1em].name = name;
[size=1em]       [size=1em]this[size=1em].age = age;
[size=1em]       [size=1em]this[size=1em].gender = gender;
[size=1em] [size=1em]}

[size=1em] [size=1em]private [size=1em]Object readResolve() [size=1em]throws [size=1em]ObjectStreamException {
[size=1em]       [size=1em]return [size=1em]InstanceHolder.instatnce;
[size=1em] [size=1em]}

[size=1em]}</code>

再次执行本节的SimpleSerial应用后将有如下输出：

[size=1em]<code [size=1em]class[size=1em]=[size=1em]"hljs delphi"[size=1em]>arg constructor
[size=1em][John, [size=1em]31[size=1em], MALE]
[size=1em]true[size=1em]</code>

无论是实现Serializable接口，或是Externalizable接口，当从I/O流中读取对象时，readResolve()方法都会被调用到。实际上就是用readResolve()中返回的对象直接替换在反序列化过程中创建的对象，而被创建的对象则会被垃圾回收掉。

总结实现Serializable与Externalizable接口都可以实现序列化前者实现方式如果不想序列化某个成员变量，使用transient关键字修饰该成员变量即可；如果想在此基础上添加一些自定义操作，在该类中实现writeObject与readObject方法(注意是private方法)，在这两个方法里就可以做一些自定义操作，如改变某个成员变量的值。后者实现方式，需要自己实现序列的细节(writeExternal与readExternal方法)，并且必须提供一个public的无参构造函数。这种方式为自定义序列化提供了更多的灵活性。高级认识序列化 ID 问题

情境：

两个客户端 A 和 B 试图通过网络传递对象数据，A 端将对象 C 序列化为二进制数据再传给 B，B 反序列化得到 C。

问题：

C 对象的全类路径假设为 com.inout.Test，在 A 和 B 端都有这么一个类文件，功能代码完全一致。也都实现了 Serializable 接口，但是反序列化时总是提示不成功。

解决：

虚拟机是否允许反序列化，不仅取决于类路径和功能代码是否一致，一个非常重要的一点是两个类的序列化 ID 是否一致（就是 private static final long serialVersionUID = 1L）。清单 1 中，虽然两个类的功能代码完全一致，但是序列化 ID 不同，他们无法相互序列化和反序列化。

清单 1. 相同功能代码不同序列化 ID 的类对比

[size=1em]<code [size=1em]class[size=1em]=[size=1em]"hljs java"[size=1em]> [size=1em]package [size=1em]com.inout;

[size=1em] [size=1em]import [size=1em]java.io.Serializable;

[size=1em] [size=1em]public [size=1em]class [size=1em]A [size=1em]implements [size=1em]Serializable {

[size=1em]    [size=1em]private [size=1em]static [size=1em]final [size=1em]long [size=1em]serialVersionUID = 1L;

[size=1em]    [size=1em]private [size=1em]String name;

[size=1em]    [size=1em]public [size=1em]String getName()
[size=1em]    [size=1em]{
[size=1em]       [size=1em]return [size=1em]name;
[size=1em]    [size=1em]}

[size=1em]    [size=1em]public [size=1em]void [size=1em]setName(String name)
[size=1em]    [size=1em]{
[size=1em]       [size=1em]this[size=1em].name = name;
[size=1em]    [size=1em]}
[size=1em] [size=1em]}

[size=1em] [size=1em]package [size=1em]com.inout;

[size=1em] [size=1em]import [size=1em]java.io.Serializable;

[size=1em] [size=1em]public [size=1em]class [size=1em]A [size=1em]implements [size=1em]Serializable {

[size=1em]    [size=1em]private [size=1em]static [size=1em]final [size=1em]long [size=1em]serialVersionUID = 2L;

[size=1em]    [size=1em]private [size=1em]String name;

[size=1em]    [size=1em]public [size=1em]String getName()
[size=1em]    [size=1em]{
[size=1em]       [size=1em]return [size=1em]name;
[size=1em]    [size=1em]}

[size=1em]    [size=1em]public [size=1em]void [size=1em]setName(String name)
[size=1em]    [size=1em]{
[size=1em]       [size=1em]this[size=1em].name = name;
[size=1em]</code>

如此问题中情景，客户端A将对象C序列化后，传给客户端B；客户端B对C进行反序列化时，B中必须有C对象对应的类，而且A、B客户端中对于对象C对应的类的序列化 ID 必须一致。

序列化 ID 在 Eclipse 下提供了两种生成策略，一个是固定的 1L，一个是随机生成一个不重复的 long 类型数据（实际上是使用 JDK 工具生成），在这里有一个建议，如果没有特殊需求，就是用默认的 1L 就可以，这样可以确保代码一致时反序列化成功。那么随机生成的序列化 ID 有什么作用呢，有些时候，通过改变序列化 ID 可以用来限制某些用户的使用。

序列化存储规则?

[size=1em]<code [size=1em]class[size=1em]=[size=1em]"hljs avrasm"[size=1em]>ObjectOutputStream out = [size=1em]new [size=1em]ObjectOutputStream(
[size=1em] [size=1em]new [size=1em]FileOutputStream([size=1em]"result.obj"[size=1em]));
[size=1em] [size=1em]Test test = [size=1em]new [size=1em]Test();
[size=1em] [size=1em]//试图将对象两次写入文件
[size=1em] [size=1em]out.writeObject(test);
[size=1em] [size=1em]out.flush();
[size=1em] [size=1em]System.out.println([size=1em]new [size=1em]File([size=1em]"result.obj"[size=1em]).length());
[size=1em] [size=1em]out.writeObject(test);
[size=1em] [size=1em]out.close();
[size=1em] [size=1em]System.out.println([size=1em]new [size=1em]File([size=1em]"result.obj"[size=1em]).length());

[size=1em] [size=1em]ObjectInputStream oin = [size=1em]new [size=1em]ObjectInputStream([size=1em]new [size=1em]FileInputStream(
[size=1em] [size=1em]"result.obj"[size=1em]));
[size=1em] [size=1em]//从文件依次读出两个文件
[size=1em] [size=1em]Test t1 = (Test) oin.readObject();
[size=1em] [size=1em]Test t2 = (Test) oin.readObject();
[size=1em] [size=1em]oin.close();

[size=1em] [size=1em]//判断两个引用是否指向同一个对象
[size=1em] [size=1em]System.out.println(t1 == t2);
[size=1em]/*
[size=1em]31
[size=1em]36
[size=1em]true
[size=1em]*/

[size=1em]</code>

解答：Java 序列化机制为了节省磁盘空间，具有特定的存储规则，当写入文件的为同一对象时，并不会再将对象的内容进行存储，而只是再次存储一份引用，上面增加的 5 字节的存储空间就是新增引用和一些控制信息的空间。反序列化时，恢复引用关系，使得清单 3 中的 t1 和 t2 指向唯一的对象，二者相等，输出 true。该存储规则极大的节省了存储空间。

作者: 信息发布软件 时间: 2016-10-20 15:40

对象序列化保存的是对象的”状态”，即它的成员变量。由此可知，对象序列化不会关注类中的静态变量。

除了在持久化对象时会用到对象序列化之外，当使用RMI(远程方法调用)，或在网络中传递对象时，都会用到对象序列化。

注意：序列化的是对象（对象的状态，成员变量等），而不是类

简单示例?

100

101

此时必须注意的是，当重新读取被保存的Person对象时，并没有调用Person的任何构造器，看起来就像是直接使用字节将Person对象还原出来的。

Serializable的作用

什么一个类实现了Serializable接口，它就可以被序列化呢？在上节的示例中，使用ObjectOutputStream来持久化对象，在该类中有如下代码：

从上述代码可知，如果被写对象的类型是String，或数组，或Enum，或Serializable，那么就可以对该对象进行序列化，否则将抛出NotSerializableException。

默认序列化机制

如果仅仅只是让某个类实现Serializable接口，而没有其它任何处理的话，则就是使用默认序列化机制。

默认的序列化机制，是对对象的所有成员变量(静态变量不会被序列化，因为它不属于某个对象，是所有对象共享的)进行序列化

影响序列化

transient关键字

此处将Person类中的age字段声明为transient，如下所示，

再执行SimpleSerial应用程序，会有如下输出：

1 2	[size=1em]<code [size=1em]class[size=1em]=[size=1em]"hljs delphi"[size=1em]>arg constructor [size=1em][John, [size=1em]null[size=1em], MALE]</code>

* writeObject()方法与readObject()方法*

再次执行SimpleSerial应用程序，则又会有如下输出：

1 2	[size=1em]<code [size=1em]class[size=1em]=[size=1em]"hljs delphi"[size=1em]>arg constructor [size=1em][John, [size=1em]31[size=1em], MALE]</code>

通过这两个方法，可以对特殊要求的字段，增加额外的加密，解密的代码

Externalizable接口

Java对象序列化使用基础和实例教程 b2b软件

此时再执行SimpleSerial程序之后会得到如下结果：

对上述Person类作进一步的修改，使其能够对name与age字段进行序列化，但要忽略掉gender字段，如下代码所示：

[size=1em]<code [size=1em]class[size=1em]=[size=1em]"hljs java"[size=1em]>[size=1em]public [size=1em]class [size=1em]Person [size=1em]implements [size=1em]Externalizable {

[size=1em] [size=1em]private [size=1em]String name = [size=1em]null[size=1em];

[size=1em] [size=1em]transient [size=1em]private [size=1em]Integer age = [size=1em]null[size=1em];

[size=1em] [size=1em]private [size=1em]Gender gender = [size=1em]null[size=1em];

[size=1em] [size=1em]public [size=1em]Person() {
[size=1em]       [size=1em]System.out.println([size=1em]"none-arg constructor"[size=1em]);
[size=1em] [size=1em]}

[size=1em] [size=1em]public [size=1em]Person(String name, Integer age, Gender gender) {
[size=1em]       [size=1em]System.out.println([size=1em]"arg constructor"[size=1em]);
[size=1em]       [size=1em]this[size=1em].name = name;
[size=1em]       [size=1em]this[size=1em].age = age;
[size=1em]       [size=1em]this[size=1em].gender = gender;
[size=1em] [size=1em]}

[size=1em] [size=1em]private [size=1em]void [size=1em]writeObject(ObjectOutputStream out) [size=1em]throws [size=1em]IOException {
[size=1em]       [size=1em]out.defaultWriteObject();
[size=1em]       [size=1em]out.writeInt(age);
[size=1em] [size=1em]}

[size=1em] [size=1em]private [size=1em]void [size=1em]readObject(ObjectInputStream in) [size=1em]throws [size=1em]IOException, ClassNotFoundException {
[size=1em]       [size=1em]in.defaultReadObject();
[size=1em]       [size=1em]age = in.readInt();
[size=1em] [size=1em]}

[size=1em] [size=1em]@Override
[size=1em] [size=1em]public [size=1em]void [size=1em]writeExternal(ObjectOutput out) [size=1em]throws [size=1em]IOException {
[size=1em]       [size=1em]out.writeObject(name);
[size=1em]       [size=1em]out.writeInt(age);
[size=1em] [size=1em]}

[size=1em] [size=1em]@Override
[size=1em] [size=1em]public [size=1em]void [size=1em]readExternal(ObjectInput in) [size=1em]throws [size=1em]IOException, ClassNotFoundException {
[size=1em]       [size=1em]name = (String) in.readObject();
[size=1em]       [size=1em]age = in.readInt();
[size=1em] [size=1em]}

[size=1em]}</code>

执行SimpleSerial之后会有如下结果：

readResolve()方法

同时要修改SimpleSerial应用，使得能够保存/获取上述单例对象，并进行对象相等性比较，如下代码所示：

执行上述应用程序后会得到如下结果：

[size=1em]<code [size=1em]class[size=1em]=[size=1em]"hljs delphi"[size=1em]>arg constructor
[size=1em][John, [size=1em]31[size=1em], MALE]
[size=1em]false[size=1em]</code>

[size=1em]<code [size=1em]class[size=1em]=[size=1em]"hljs java"[size=1em]>[size=1em]public [size=1em]class [size=1em]Person [size=1em]implements [size=1em]Serializable {

[size=1em] [size=1em]private [size=1em]static [size=1em]class [size=1em]InstanceHolder {
[size=1em]       [size=1em]private [size=1em]static [size=1em]final [size=1em]Person instatnce = [size=1em]new [size=1em]Person([size=1em]"John"[size=1em], [size=1em]31[size=1em], Gender.MALE);
[size=1em] [size=1em]}

[size=1em] [size=1em]public [size=1em]static [size=1em]Person getInstance() {
[size=1em]       [size=1em]return [size=1em]InstanceHolder.instatnce;
[size=1em] [size=1em]}

[size=1em] [size=1em]private [size=1em]String name = [size=1em]null[size=1em];

[size=1em] [size=1em]private [size=1em]Integer age = [size=1em]null[size=1em];

[size=1em] [size=1em]private [size=1em]Gender gender = [size=1em]null[size=1em];

[size=1em] [size=1em]private [size=1em]Person() {
[size=1em]       [size=1em]System.out.println([size=1em]"none-arg constructor"[size=1em]);
[size=1em] [size=1em]}

[size=1em] [size=1em]private [size=1em]Person(String name, Integer age, Gender gender) {
[size=1em]       [size=1em]System.out.println([size=1em]"arg constructor"[size=1em]);
[size=1em]       [size=1em]this[size=1em].name = name;
[size=1em]       [size=1em]this[size=1em].age = age;
[size=1em]       [size=1em]this[size=1em].gender = gender;
[size=1em] [size=1em]}

[size=1em] [size=1em]private [size=1em]Object readResolve() [size=1em]throws [size=1em]ObjectStreamException {
[size=1em]       [size=1em]return [size=1em]InstanceHolder.instatnce;
[size=1em] [size=1em]}

[size=1em]}</code>

再次执行本节的SimpleSerial应用后将有如下输出：

[size=1em]<code [size=1em]class[size=1em]=[size=1em]"hljs delphi"[size=1em]>arg constructor
[size=1em][John, [size=1em]31[size=1em], MALE]
[size=1em]true[size=1em]</code>

情境：

两个客户端 A 和 B 试图通过网络传递对象数据，A 端将对象 C 序列化为二进制数据再传给 B，B 反序列化得到 C。

问题：

解决：

清单 1. 相同功能代码不同序列化 ID 的类对比

序列化存储规则?

欢迎光临信息发布软件,b2b软件,广告发布软件 (http://www.postbbs.com/)