【Java基础第二弹】Java序列化进阶篇

1.transient

类一旦实现了Serializable 接口即被声明为可序列化，然而某些情况下并不是所有的属性都需要序列化，想要人为的去阻止这些属性被序列化，就需要用到transient 关键字。

transient 关键字用于声明属性，被声明的属性在序列化时其状态不被序列化执行：

public class Cat implements Serializable {

public static final long serialVersionUID = 1L;
private String name;
private int age;
//color将不被序列化
private transient String color;

...

}

name :喵星人
age  :3
color:null

说明虽然我们设置了color 属性值，但是由于transient 关键字的作用，序列化过程跳过了该属性，从而在反序列化时得到的值为null。

2.静态变量序列化

如果属性被声明成static或final时，序列化时实例值是否会被序列化？

1）当属性声明为static时：

private static String color;

反序列化后打印结果：

白色

说明static 修饰的属性也会被序列化存储或传递。

2）当属性声明为final时：

private final String color="白色";

反序列化后打印结果：

白色

说明final 修饰的属性同样会被序列化存储或传递。

但是！如果在反序列化前修改color 属性值会出现什么结果？打印结果为：

黑色

这就说明以上两种结论是错误的，static、final声明的属性是不会被序列化的，他只与类有关。其实也很好理解，静态变量其 实是存于这个类的静态变量表中的，无论你在序列化时如何折腾，最终改变的都是静态表中的值，而不是序列化存储文件或传输流的值。

总结：

序列化并不保存静态变量。

3.子类序列化

前文已经了解到，继承自可序列化类的子类默认也是可序列化的，然而还有一种情况就是子类是可序列化类，而父类不是，这两种情况下相关属性能否序列化保存成功？

1）父类可序列化，子类与父类各属性序列化情况。

父类Cat：

package com.animals;
import java.io.Serializable;
/**
* 喵星人
* @author 286
*
*/
public class Cat implements Serializable {

public static final long serialVersionUID = 1L;
private String name;
private int age;
//color将不被序列化
private transient String color;

public void setColor(String color) {
this.color = color;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getColor() {
return color;
}
public static long getSerialversionuid() {
return serialVersionUID;
}

}

子类Garfield：

package com.animals;

/**
* 加菲猫
* @author 286
*
*/
public class Garfield extends Cat {
private static final long serialVersionUID = 2L;
private Double price;

public double getPrice() {
return price;
}

public void setPrice(double price) {
this.price = price;
}

}

序列化与反序列化过程：

public static void main(String[] args) throws IOException,ClassNotFoundException {
write();
read();
}

public static void read() throws IOException, ClassNotFoundException{
InputStream is = new FileInputStream("E:\\g.txt");
ObjectInputStream ois = new ObjectInputStream(is);
Garfield g = (Garfield) ois.readObject();
System.out.println(g.getName());
System.out.println(g.getAge());
System.out.println(g.getColor());
System.out.println(g.getPrice());

ois.close();
is.close();
}

public static void write() throws IOException{
Garfield g=new Garfield();
g.setName("喵星人");
g.setAge(3);
g.setColor("花猫");
g.setPrice(4000);
//定义文件输出流，准备将数据写入文件中
OutputStream os=new FileOutputStream("E:\\g.txt");
ObjectOutputStream oos=new ObjectOutputStream(os);
//写入实例数据
oos.writeObject(g);
oos.close();
os.close();
}

打印结果：
喵星人
3
null
4000.0

结论：

子类继承自可序列化的父类后拥有一切序列化相关的特性，可以像操作可序列化类一样操作。

2）子类可序列化，父类未声明。

代码与上面基本相同，只是Garfield 实现Serializable 接口，Cat 则不实现，打印结果：

null
0
null
4000.0

结果表示Cat 中的属性均没有被序列化保存，从而反序列化未读取出值。

结论：

子类可序列化，父类默认是不可序列化的，要想将父类对象也序列化，就需要让父类也实现Serializable 接口。这种方式可以将不需要被序列化的字段抽取出来放在父类中，子类实现 Serializable 接口，父类不实现，根据父类序列化规则，父类的字段数据将不被序列化，从而达到部分序列化的功能，代码维护也比较方便。

3）但是此时我们对父类Cat 进行改造，增加一个无参数的构造函数：

public Cat(){
this.name="喵星人";
this.age=3;
this.color="花猫";
}

再执行以上操作，结果又会如何？

喵星人
3
花猫
4000.0

结论：

在父类没有实现 Serializable 接口时，虚拟机不会序列化父对象的。而一个Java 对象的构造必须先有父对象，才有子对象，反序列化也不例外。所以反序列化时，为了构造父对象，只能调用父类的无参构造函数作为默认的父对象。因此当我们取 父对象的变量值时，它的值是调用父类无参构造函数后的值。如果你考虑到这种序列化的情况，在父类无参构造函数中对变量进行初始化，否则的话，父类变量值都 是默认声明的值，如 int 型的默认是 0，String 型的默认是 null。

4.自定义序列化

默认的序列化和反序列化方式并不能满足我们全部的需求，某些情况下需要一种更加灵活的方式处理相关序列化数据信息，如对序列化信息进行添加、封装、加密等操作。

实现自定义序列化很简单，只需要重写以下两个方法即可：

private void writeObject(java.io.ObjectOutputStream out)
throws IOException
private void readObject(java.io.ObjectInputStream in)
throws IOException, ClassNotFoundException;

writeObject 方法负责写入特定类的对象的状态，以便相应的 readObject 方法可以恢复它。通过调用 out.defaultWriteObject 可以调用保存 Object 的字段的默认机制。该方法本身不需要涉及属于其超类或子类的状态。通过使用 writeObject 方法或使用 DataOutput 支持的用于基本数据类型的方法将各个字段写入 ObjectOutputStream，状态可以被保存。

readObject 方法负责从流中读取并恢复类字段。它可以调用 in.defaultReadObject 来调用默认机制，以恢复对象的非静态和非瞬态字段。defaultReadObject 方法使用流中的信息来分配流中通过当前对象中相应指定字段保存的对象的字段。这用于处理类演化后需要添加新字段的情形。该方法本身不需要涉及属于其超类或 子类的状态。通过使用 writeObject 方法或使用 DataOutput 支持的用于基本数据类型的方法将各个字段写入 ObjectOutputStream，状态可以被保存。

此时我们先不必知道序列化和反序列化其内部的处理流程和相关实现，只需要了解自定义序列化的方式即可，下一篇高级篇会更深入探究其内部机理。

重写了writeObject 与readObject 两个方法后的Cat 类代码为：

package com.animals;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
* 喵星人
*
* @author 286
*
*/
public class Cat implements Serializable {

private static final long serialVersionUID = 1L;
private String name;
private int age;
private String color;

private void writeObject(ObjectOutputStream os) throws IOException {
os.defaultWriteObject();// java对象序列化默认操作
}

private void readObject(ObjectInputStream is) throws IOException,
ClassNotFoundException {
is.defaultReadObject();// java对象反序列化默认操作
}
...
}

defaultWriteObject() 和defaultReadObject() 方法是调用默认的序列化和反序列化方法。当然我们也可以添加更多操作，例如：

1）在序列化时我们人为的将数据内容进行修改：

private void writeObject(ObjectOutputStream os) throws IOException {
PutField putFields = os.putFields();
putFields.put("name", "汪星人");
putFields.put("age", 4);
putFields.put("color", "绿毛汪");
os.writeFields();
}

其中put方法用于缓冲写入流中的持久存储字段的对象。调用 writeFields 方法时，字段被写入流中。

2）在反序列化时也是人为的对已序列化内容进行获取并处理：

private void readObject(ObjectInputStream is) throws IOException,
ClassNotFoundException {
GetField readFields = is.readFields();
String nameTemp = (String) readFields.get("name", "喵星人2");
int ageTemp = readFields.get("age", 10);
String colorTemp = (String) readFields.get("color", "蓝色");
// 这样就可以对几个属性进行各种处理了,或者直接赋给当前对象
this.name = nameTemp;
this.age = ageTemp;
this.color = colorTemp;
}

其中get方法含有两个参数分别为name和val，name代表字段的名称，val代表name 没有值的情况下所使用的默认值。因为之前设置过值所以打印出来的结果为：

汪星人
4
绿毛汪
4000.0

总结：

自定义序列化可以更加灵活的实现特殊的业务场景，如添加特殊字段，对某些敏感内容进行加密等。缺点在于每一个需要序列化的类都需要重写相关的方法，且传输过程中没有加密处理。

5.其他类型序列化

某些情况下序列化实例类型不仅仅局限于单JavaBean个对象，还有很多其他如Map、list、int、boolean等类型。

public void read() throws IOException, ClassNotFoundException {
InputStream is = new FileInputStream("E:\\g.txt");
ObjectInputStream ois = new ObjectInputStream(is);
Garfield g = (Garfield) ois.readObject();
System.out.println(g.getName());
System.out.println(g.getAge());
System.out.println(g.getColor());
System.out.println(g.getPrice());
List list=(List) ois.readObject();
int i=ois.readInt();
System.out.println(i);
Map map=(Map) ois.readObject();
ois.close();
is.close();
}

public void write() throws IOException, ClassNotFoundException {
Garfield g = new Garfield();
g.setName("喵星人");
g.setAge(3);
g.setColor("花猫");
g.setPrice(4000);
// 定义文件输出流，准备将数据写入文件中
OutputStream os = new FileOutputStream("E:\\g.txt");
ObjectOutputStream oos = new ObjectOutputStream(os);
// 写入实例数据
oos.writeObject(g);
oos.writeObject(new ArrayList());
oos.writeInt(99);
oos.writeObject(new HashMap());
oos.close();
os.close();
}

//打印结果：
喵星人
3
花猫
4000.0
99

在序列化过程中我们可以将多个实例写入序列化队列，反序列化时只需按顺序取出即可使用。