Java 序列化之Serializable完全解读
Serializable 概念
Serializable是一个对象序列化接口，一个类实现了Serializable接口，表示它可以通过JDK本身进行序列化和反序列化操作。
Serializable工具类
Serializable依赖的是ObjectInputStream和ObjectOutputStream，使用ObjectOutputStream的writeObject方法将JavaBean的序列化内容写入输出流，使用ObjectInputStream的readObject将反序列化内容读入JavaBean。
package com.securitit.serialize.serializable.utils;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/**
* @author Securitit.
* @note Serializable工具类.
*/
public class SerializableUtils {
/**
* JavaBean序列化.
*
* @param javaBean Java对象.
* @throws Exception 异常信息.
*/
public static <T> byte[] serialize(T javaBean) throws Exception {
ObjectOutputStream oos = null;
ByteArrayOutputStream baos = null;
try {
baos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(baos);
// 写入对象.
oos.writeObject(javaBean);
oos.flush();
return baos.toByteArray();
} catch (Exception ex) {
// 模拟日志记录，可以自己改为项目日志框架.
System.out.println("[模拟日志记录]SerializableUtils.serialize.异常." + ex.getMessage());
throw new Exception("SerializableUtils.serialize.异常.", ex);
} finally {
if (null != oos) {
oos.close();
}
}
}
/**
* JavaBean反序列化.
*
* @param serializeData 序列化数据.
* @throws Exception 异常信息.
*/
public static <T> T deserialize(byte[] serializeData) throws Exception {
T javaBean = null;
ObjectInputStream ois = null;
ByteArrayInputStream bais = null;
try {
bais = new ByteArrayInputStream(serializeData);
ois = new ObjectInputStream(bais);
// 读取对象.
javaBean = (T) ois.readObject();
return javaBean;
} catch (Exception ex) {
// 模拟日志记录，可以自己改为项目日志框架.
System.out.println("[模拟日志记录]SerializableUtils.deserialize.异常." + ex.getMessage());
throw new Exception("SerializableUtils.deserialize.异常.", ex);
} finally {
if (null != ois) {
ois.close();
}
}
}
}
该工具提供serialize和deserialize两个方法，serialize是序列化方法，将JavaBean转换为byte[]（至于byte[]的处理，可以选择存储为本地文件、数据库Blob或网络传输），deserialize是反序列化方法，将byte[]（byte[]来自于本地文件、数据库Blob或网络传输）。该工具类可以适用任何场景，与具体JavaBean无关，日志记录可以根据个人的选择重写。
Serializable JavaBean
基于上面工具类，示例相对就比较简单了，首先定义个JavaBean，命名为Car，详细如下：
package com.securitit.serialize.serializable.bean;
import java.io.Serializable;
/**
* @author Securitit.
* @note Car Pojo.
*/
public class Car implements Serializable {
/**
* serialVersionUID.
*/
private static final long serialVersionUID = 3943382426658456693L;
/**
* 名称.
*/
private String name;
/**
* 价格.
*/
private Integer price;
/**
* 颜色.
*/
private String color;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getPrice() {
return price;
}
public void setPrice(Integer price) {
this.price = price;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
@Override
public String toString() {
return "{name: \"" + name + "\", price: \"" + price + "\", color: \"" + color + "\"}";
}
}
Serializable 示例
package com.securitit.serialize.serializable;
import com.securitit.serialize.serializable.bean.Car;
import com.securitit.serialize.serializable.utils.SerializableUtils;
/**
* @author Securitit.
* @note Serializable测试类.
*/
public class SerializableTester {
public static void main(String[] args) throws Exception {
byte[] serializeData = null;
Car deserializeCar = null;
// 定义JavaBean.
Car car = new Car();
car.setName("布加迪");
car.setPrice(12000000);
car.setColor("红色");
// 序列化JavaBean.
serializeData = SerializableUtils.serialize(car);
System.out.println(serializeData);
// 反序列化JavaBean.
deserializeCar = SerializableUtils.deserialize(serializeData);
System.out.println(deserializeCar);
}
}
运行测试类，得到如下结果：
[B@14ae5a5
{name: "布加迪", price: "12000000", color: "红色"}
Serializable 关键点
serialVersionUID
· serialVersionUID生成
首先要说的是serialVersionUID，serialVersionUID是JavaBean的版本号，在IDE中，若没有定义这个属性，IDE会给出提示，同时IDE会给出两种生成方式：
· 默认1L。
· 根据包名、类名、继承关系、非私有方法和属性、以及参数、返回值等等诸多计算因子计算出一个64位散列值。
至于IDE对于serialVersionUID的检查，可以通过Window->Preferences->Java->Compiler->Errors/Warnings->Serializable class without serialVersionUID，选择Ignore，即可跳过此校验，如下图： 
当实现java.io.Serializable接口的类中没有显示定义serialVersionUID时，在编译时，Java编译器会根据Class自动生产一个serialVersionUID，此时，若类结构没有发生变化，serialVersionUID多次生成仍会保持不变。若类结构发生改变，serialVersionUID会随之改变。
· serialVersionUID作用
简单来说，Java的序列化机制通过serialVersionUID来判断JavaBean的版本一致性。在进行反序列化时，JVM会把需要反序列化的字节流中的serialVersionUID与本地JavaBean中的serialVersionUID比较，若一致，则进行反序列化。若不一致，则禁止反序列化，抛出InvalidClassException异常。
还有一种情况是serialVersionUID保持不变，JavaBean发生改变，此时不影响反序列化，但是要注意对JavaBean所做的更改是否会影响反序列化数据的正确性。
静态变量
序列化只保存对象的非静态成员变量，不能保存成员方法和静态变量，且序列化只能保存成员变量的值，对于变量的任何修饰符都不能保存。
在原Car中新增private static String region;属性，这里有一点需要注意的是，对于static序列化和反序列化的测试不可以在一个JVM中，由于static是类的信息，类加载后会一直伴随整个生命周期。
· 错误示例
package com.securitit.serialize.serializable;
import com.securitit.serialize.serializable.bean.Car;
import com.securitit.serialize.serializable.utils.SerializableUtils;
/**
* @author Securitit.
* @note Serializable测试类.
*/
public class SerializableTester {
public static void main(String[] args) throws Exception {
byte[] serializeData = null;
Car deserializeCar = null;
Car car = new Car();
car.setName("布加迪");
car.setPrice(12000000);
car.setColor("红色");
car.setRegion("大连");
System.out.println(car.hashCode());
serializeData = SerializableUtils.serialize(car);
System.out.println(serializeData);
deserializeCar = SerializableUtils.deserialize(serializeData);
System.out.println(deserializeCar);
System.out.println(deserializeCar.hashCode());
}
}
输出结果
[B@14ae5a5
{name: "布加迪", price: "12000000", color: "红色", region: "大连"}
· 正确示例
序列化测试类
package com.securitit.serialize.serializable;
import java.io.File;
import org.apache.commons.io.FileUtils;
import com.securitit.serialize.serializable.bean.Car;
import com.securitit.serialize.serializable.utils.SerializableUtils;
/**
* @author Securitit.
* @note Serializable测试类.
*/
public class SerializableStaticTester {
public static void main(String[] args) throws Exception {
byte[] serializeData = null;
Car car = new Car();
car.setName("布加迪");
car.setPrice(12000000);
car.setColor("红色");
car.setRegion("北京");
serializeData = SerializableUtils.serialize(car);
// commons-io提供.
FileUtils.writeByteArrayToFile(new File("C:/Users/Administrator/Downloads/个人文件/Car"), serializeData);
}
}
反序列化测试类
package com.securitit.serialize.serializable;
import java.io.File;
import org.apache.commons.io.FileUtils;
import com.securitit.serialize.serializable.bean.Car;
import com.securitit.serialize.serializable.utils.SerializableUtils;
/**
* @author Securitit.
* @note Serializable测试类.
*/
public class DeserializableStaticTester {
public static void main(String[] args) throws Exception {
byte[] serializeData = null;
Car deserializeCar = null;
// commons-io提供.
serializeData = FileUtils.readFileToByteArray(new File("C:/Users/Administrator/Downloads/个人文件/Car"));
deserializeCar = SerializableUtils.deserialize(serializeData);
System.out.println(deserializeCar);
}
}
输出结果
{name: "布加迪", price: "12000000", color: "红色", region: "null"}
transient变量
transient关键的字作用是：阻止实例中那些用此关键字生命的变量持久化。当对象被反序列化时，这样的实例变量值不会被持久化和恢复。
transient总结：
· 被transient关键字修饰后，变量将不会被序列化。
· transient关键字只能修饰成员变量，不能修饰方法和类。
· 被transient修饰的成员变量不能给序列化，static变量不管是否被transient修饰，都不能被序列化。
· transient的缺点是，若某个成员变量被transient修饰，反序列化时，对应变量是类型的默认值，可能存在意想不到的问题。
· transient实例
在原Car中新增private transient int length;属性，然后进行序列化和反序列化，如下：
package com.securitit.serialize.serializable;
import com.securitit.serialize.serializable.bean.Car;
import com.securitit.serialize.serializable.utils.SerializableUtils;
/**
* @author Securitit.
* @note Serializable测试类.
*/
public class SerializableTester {
public static void main(String[] args) throws Exception {
byte[] serializeData = null;
Car deserializeCar = null;
Car car = new Car();
car.setName("布加迪");
car.setPrice(12000000);
car.setColor("红色");
car.setLength(2980);
serializeData = SerializableUtils.serialize(car);
System.out.println(serializeData);
deserializeCar = SerializableUtils.deserialize(serializeData);
System.out.println(deserializeCar);
}
}
输出结果
[B@14ae5a5
{name: "布加迪", price: "12000000", color: "红色", length: "0"}
readObjectNoData 方法
Serializable反序列化时，可能存在序列化类与反序列化类版本不一致、序列化类的父类与反序列化类的父类不一致、或序列化流损坏等问题，此时，成员变量都会初始化为对应类型的默认值。
建议序列化类都定义自己的readObjectNoData方法，如果发生以上问题时，可以防止成员变量初始化为对应类型的默认值，从而导致后续处理出现问题。
private void readObjectNoData() {
this.name = "法拉利";
this.price = 1000000;
this.color = "白色";
this.length = 5000;
}
writeReplace 方法
序列化类重写writeReplace()方法，可以在序列化过程中，使用writeReplace()返回对象作为实际序列化类，此时调用的writeObject()方法亦是替换后的序列化类，以此来完成对原序列化类的替换。
private Object writeReplace() {
Car newCar = new Car();
newCar.setName("兰博基尼");
newCar.setPrice(12000000);
newCar.setColor("蓝色");
newCar.setLength(6000);
return newCar;
}
readResolve 方法
反序列化类重写readResolve()方法，可以在反序列化过程中，使用readResolve()返回对象作为实际反序列化类，以此来完成对原反序列化类的替换。
private Object readResolve() {
Car newCar = new Car();
newCar.setName("兰博基尼");
newCar.setPrice(12000000);
newCar.setColor("蓝色");
newCar.setLength(6000);
return newCar;
}
总结
· 使用Java自动序列化机制时，只需让序列化类实现Serializable接口即可。
· 序列化应定义serialVersionUID，使得JavaBean在离线或远程通信时可以尊徐版本号机制。
· static修饰的成员变量，不会参与序列化的过程。
· transient修改的成员变量，不会参与序列化的过程。
· 在保证serialVersionUID不变的情况下，序列化类成员变量的增减对反序列化过程不会产生影响。
· 序列化类存在继承关系时，若父类没有实现Serializable接口，则序列化类从父类继承的属性将不参与序列化过程。
· 反序列化过程不会执行序列化类的构造方法。若父类没有实现Serializable接口，在反序列化过程中，序列化类的构造方法不会执行，但由于没有父类的信息，父类会执行构造方法。