⼀、序列化和反序列化的概念
把对象转换为字节序列的过程称为对象的序列化。 把字节序列恢复为对象的过程称为对象的反序列化。 对象的序列化主要有两种⽤途：
1） 把对象的字节序列永久地保存到硬盘上，通常存放在⼀个⽂件中； 2） 在⽹络上传送对象的字节序列。
在很多应⽤中，需要对某些对象进⾏序列化，让它们离开内存空间，⼊住物理硬盘，以便长期保存。⽐如最常见的是Web服务器中的Session对象，当有 10万⽤户并发访问，就有可能出现10万个Session对象，内存可能吃不消，于是Web容器就会把⼀些seesion先序列化到硬盘中，等要⽤了，再把保存在硬盘中的对象还原到内存中。
当两个进程在进⾏远程通信时，彼此可以发送各种类型的数据。⽆论是何种类型的数据，都会以⼆进制序列的形式在⽹络上传送。发送⽅需要把这个Java对象转换为字节序列，才能在⽹络上传送；接收⽅则需要把字节序列再恢复为Java对象。
⼆、JDK类库中的序列化API
java.io.ObjectOutputStream代表对象输出流，它的writeObject(Object obj)⽅法可对参数指定的obj对象进⾏序列化，把得到的字节序列写到⼀个⽬标输出流中。
java.io.ObjectInputStream代表对象输⼊流，它的readObject()⽅法从⼀个源输⼊流中读取字节序列，再把它们反序列化为⼀个对象，并将其返回。
只有实现了Serializable和Externalizable接⼝的类的对象才能被序列化。Externalizable接⼝继承⾃ Serializable接⼝，实现Externalizable接⼝的类完全由⾃⾝来控制序列化的⾏为，⽽仅实现Serializable接⼝的类可以 采⽤默认的序列化⽅式 。 对象序列化包括如下步骤：
1） 创建⼀个对象输出流，它可以包装⼀个其他类型的⽬标输出流，如⽂件输出流； 2） 通过对象输出流的writeObject()⽅法写对象。
对象反序列化的步骤如下：
1） 创建⼀个对象输⼊流，它可以包装⼀个其他类型的源输⼊流，如⽂件输⼊流； 2） 通过对象输⼊流的readObject()⽅法读取对象。对象序列化和反序列范例：
定义⼀个Person类，实现Serializable接⼝
1 import java.io.Serializable; 2 3 /**
4 *
ClassName: Person
5 *
Description:测试对象序列化和反序列化
6 * @author xudp 7 * @version 1.0 V
8 * @createTime 2014-6-9 下午02:33:25 9 */
10 public class Person implements Serializable {11
12 /**
13 * 序列化ID14 */
15 private static final long serialVersionUID = -5809782578272943999L;16 private int age;
17 private String name;18 private String sex;19
20 public int getAge() {21 return age;22 }23
24 public String getName() {25 return name;26 }27
28 public String getSex() {29 return sex;30 }31
32 public void setAge(int age) {33 this.age = age;34 }35
36 public void setName(String name) {37 this.name = name;
38 }39
40 public void setSex(String sex) {41 this.sex = sex;42 }43 }
序列化和反序列化Person类对象
1 import java.io.File;
2 import java.io.FileInputStream;
3 import java.io.FileNotFoundException; 4 import java.io.FileOutputStream; 5 import java.io.IOException;
6 import java.io.ObjectInputStream; 7 import java.io.ObjectOutputStream; 8 import java.text.MessageFormat; 9 10 /**
11 *
ClassName: TestObjSerializeAndDeserialize
12 *
Description: 测试对象的序列化和反序列
13 * @author xudp14 * @version 1.0 V
15 * @createTime 2014-6-9 下午03:17:2516 */
17 public class TestObjSerializeAndDeserialize {18
19 public static void main(String[] args) throws Exception {20 SerializePerson();//序列化Person对象
21 Person p = DeserializePerson();//反序列Perons对象
22 System.out.println(MessageFormat.format(\"name={0},age={1},sex={2}\23 p.getName(), p.getAge(), p.getSex()));24 }25 26 /**
27 * MethodName: SerializePerson 28 * Description: 序列化Person对象29 * @author xudp
30 * @throws FileNotFoundException31 * @throws IOException32 */
33 private static void SerializePerson() throws FileNotFoundException,34 IOException {
35 Person person = new Person();36 person.setName(\"gacl\");37 person.setAge(25);38 person.setSex(\"男\");
39 // ObjectOutputStream 对象输出流，将Person对象存储到E盘的Person.txt⽂件中，完成对Person对象的序列化操作40 ObjectOutputStream oo = new ObjectOutputStream(new FileOutputStream(41 new File(\"E:/Person.txt\")));42 oo.writeObject(person);
43 System.out.println(\"Person对象序列化成功！\");44 oo.close();45 }46
47 /**
48 * MethodName: DeserializePerson 49 * Description: 反序列Perons对象50 * @author xudp51 * @return
52 * @throws Exception53 * @throws IOException54 */
55 private static Person DeserializePerson() throws Exception, IOException {56 ObjectInputStream ois = new ObjectInputStream(new FileInputStream(57 new File(\"E:/Person.txt\")));
58 Person person = (Person) ois.readObject();
59 System.out.println(\"Person对象反序列化成功！\");60 return person;61 }62 63 }
代码运⾏结果如下：
序列化Person成功后在E盘⽣成了⼀个Person.txt⽂件，⽽反序列化Person是读取E盘的Person.txt后⽣成了⼀个Person对象
三、serialVersionUID的作⽤
serialVersionUID: 字⾯意思上是序列化的版本号，凡是实现Serializable接⼝的类都有⼀个表⽰序列化版本标识符的静态变量
1 private static final long serialVersionUID
实现Serializable接⼝的类如果类中没有添加serialVersionUID，那么就会出现如下的警告提⽰
⽤⿏标点击就会弹出⽣成serialVersionUID的对话框，如下图所⽰：
serialVersionUID有两种⽣成⽅式：
采⽤这种⽅式⽣成的serialVersionUID是1L，例如：
1 private static final long serialVersionUID = 1L;
采⽤这种⽅式⽣成的serialVersionUID是根据类名，接⼝名，⽅法和属性等来⽣成的，例如：
1 private static final long serialVersionUID = 4603642343377807741L;
添加了之后就不会出现那个警告提⽰了，如下所⽰：
扯了那么多，那么serialVersionUID(序列化版本号)到底有什么⽤呢，我们⽤如下的例⼦来说明⼀下serialVersionUID的作⽤，看下⾯的代码：
1 import java.io.File;
2 import java.io.FileInputStream;
3 import java.io.FileNotFoundException; 4 import java.io.FileOutputStream; 5 import java.io.IOException;
6 import java.io.ObjectInputStream; 7 import java.io.ObjectOutputStream; 8 import java.io.Serializable; 9
10 public class TestSerialversionUID {11
12 public static void main(String[] args) throws Exception {13 SerializeCustomer();// 序列化Customer对象
14 Customer customer = DeserializeCustomer();// 反序列Customer对象15 System.out.println(customer);16 }17
18 /**
19 * MethodName: SerializeCustomer 20 * Description: 序列化Customer对象21 * @author xudp
22 * @throws FileNotFoundException23 * @throws IOException24 */
25 private static void SerializeCustomer() throws FileNotFoundException,26 IOException {
27 Customer customer = new Customer(\"gacl\28 // ObjectOutputStream 对象输出流
29 ObjectOutputStream oo = new ObjectOutputStream(new FileOutputStream(30 new File(\"E:/Customer.txt\")));31 oo.writeObject(customer);
32 System.out.println(\"Customer对象序列化成功！\");33 oo.close();34 }35
36 /**
37 * MethodName: DeserializeCustomer 38 * Description: 反序列Customer对象39 * @author xudp40 * @return
41 * @throws Exception42 * @throws IOException43 */
44 private static Customer DeserializeCustomer() throws Exception, IOException {45 ObjectInputStream ois = new ObjectInputStream(new FileInputStream(46 new File(\"E:/Customer.txt\")));
47 Customer customer = (Customer) ois.readObject();48 System.out.println(\"Customer对象反序列化成功！\");49 return customer;50 }51 }52 53 /**
54 *
ClassName: Customer
55 *
Description: Customer实现了Serializable接⼝，可以被序列化
56 * @author xudp57 * @version 1.0 V
58 * @createTime 2014-6-9 下午04:20:1759 */
60 class Customer implements Serializable {61 //Customer类中没有定义serialVersionUID62 private String name;63 private int age;64
65 public Customer(String name, int age) {66 this.name = name;67 this.age = age;68 }69 70 /*
71 * @MethodName toString
72 * @Description 重写Object类的toString()⽅法73 * @author xudp74 * @return string
75 * @see java.lang.Object#toString()76 */
77 @Override
78 public String toString() {
79 return \"name=\" + name + \80 }81 }
运⾏结果：
序列化和反序列化都成功了。
下⾯我们修改⼀下Customer类，添加多⼀个sex属性，如下：
1 class Customer implements Serializable { 2 //Customer类中没有定义serialVersionUID 3 private String name; 4 private int age; 5
6 //新添加的sex属性
7 private String sex; 8
9 public Customer(String name, int age) {10 this.name = name;11 this.age = age;12 }13
14 public Customer(String name, int age,String sex) {15 this.name = name;16 this.age = age;17 this.sex = sex;18 }19 20 /*
21 * @MethodName toString
22 * @Description 重写Object类的toString()⽅法23 * @author xudp24 * @return string
25 * @see java.lang.Object#toString()26 */
27 @Override
28 public String toString() {
29 return \"name=\" + name + \30 }31 }
然后执⾏反序列操作，此时就会抛出如下的异常信息：
1 Exception in thread \"main\" java.io.InvalidClassException: Customer; 2 local class incompatible:
3 stream classdesc serialVersionUID = -88175599799432325, 4 local class serialVersionUID = -5182532647273106745
意思就是说，⽂件流中的class和classpath中的class，也就是修改过后的class，不兼容了，处于安全机制考虑，程序抛出了错误，并且拒绝载⼊。那么如果我们真的有需求要在序列化后添加⼀个字段或者⽅法呢？应该怎么办？那就是⾃⼰去指定serialVersionUID。在
TestSerialversionUID例⼦中，没有指定Customer类的serialVersionUID的，那么java编译器会⾃动给这个class进⾏⼀个摘要算法，类似于指纹算法，只要这个⽂件 多⼀个空格，得到的UID就会截然不同的，可以保证在这么多类中，这个编号是唯⼀的。所以，添加了⼀个字段后，由于没有显指定 serialVersionUID，编译器⼜为我们⽣成了⼀个UID，当然和前⾯保存在⽂件中的那个不会⼀样了，于是就出现了2个序列化版本号不⼀致的错误。因此，只要我们⾃⼰指定了serialVersionUID，就可以在序列化后，去添加⼀个字段，或者⽅法，⽽不会影响到后期的还原，还原后的对象照样可以使⽤，⽽且还多了⽅法或者属性可以⽤。
下⾯继续修改Customer类，给Customer指定⼀个serialVersionUID，修改后的代码如下：
1 class Customer implements Serializable {
2 /**
3 * Customer类中定义的serialVersionUID(序列化版本号) 4 */
5 private static final long serialVersionUID = -5182532647273106745L; 6 private String name; 7 private int age; 8
9 //新添加的sex属性10 //private String sex;11
12 public Customer(String name, int age) {13 this.name = name;14 this.age = age;15 }16
17 /*public Customer(String name, int age,String sex) {18 this.name = name;19 this.age = age;20 this.sex = sex;21 }*/22 23 /*
24 * @MethodName toString
25 * @Description 重写Object类的toString()⽅法26 * @author xudp27 * @return string
28 * @see java.lang.Object#toString()29 */
30 @Override
31 public String toString() {
32 return \"name=\" + name + \33 }34 }
重新执⾏序列化操作，将Customer对象序列化到本地硬盘的Customer.txt⽂件存储，然后修改Customer类，添加sex属性，修改后的Customer类代码如下：
1 class Customer implements Serializable { 2 /**
3 * Customer类中定义的serialVersionUID(序列化版本号) 4 */
5 private static final long serialVersionUID = -5182532647273106745L; 6 private String name; 7 private int age; 8
9 //新添加的sex属性
10 private String sex;11
12 public Customer(String name, int age) {13 this.name = name;14 this.age = age;15 }16
17 public Customer(String name, int age,String sex) {18 this.name = name;19 this.age = age;20 this.sex = sex;21 }22 23 /*
24 * @MethodName toString
25 * @Description 重写Object类的toString()⽅法26 * @author xudp27 * @return string
28 * @see java.lang.Object#toString()29 */
30 @Override
31 public String toString() {
32 return \"name=\" + name + \33 }34 }
执⾏反序列操作，这次就可以反序列成功了，如下所⽰：
四、serialVersionUID的取值
serialVersionUID的取值是Java运⾏时环境根据类的内部细节⾃动⽣成的。如果对类的源代码作了修改，再重新编译，新⽣成的类⽂件的serialVersionUID的取值有可能也会发⽣变化。
类的serialVersionUID的默认值完全依赖于Java编译器的实现，对于同⼀个类，⽤不同的Java编译器编译，有可能会导致不同的serialVersionUID，也有可能相同。为了提⾼serialVersionUID的独⽴性和确定性，强烈建议在⼀个可序列化类中显⽰的定义serialVersionUID，为它赋予明确的值。
显式地定义serialVersionUID有两种⽤途：
1、 在某些场合，希望类的不同版本对序列化兼容，因此需要确保类的不同版本具有相同的serialVersionUID； 2、 在某些场合，不希望类的不同版本对序列化兼容，因此需要确保类的不同版本具有不同的serialVersionUID。
因篇幅问题不能全部显示，请点此查看更多更全内容