我爱学Java之对象序列化

Java平台允许我们在内存中创建可复用的Java对象，但一般情况下，只有当JVM处于运行时，这些对象才可能存在，当JVM停止运行时，这些对象就不复存在，但在实际应用中，我们需要持久化的保存指定的对象，并在特定的时间重新读取被保存的对象，Java对象序列化就能够帮助我们实现该功能。

在进行Java对象序列化的时候，会把其状态保存为一组字节，在对这些对象反序列化的时候再将这些字节组装成对象。但值得注意的事，对象序列化保存的是对象的”状态“，即它的成员变量，因此类中的静态变量不会被序列化。

除了在持久化对象时会用到对象序列化之外，当使用RMI(远程方法调用)，或在网络中传递对象时，都会用到对象序列化，下面我们分别通过文件和MySQL理解Java对象的序列化。

首先定义需要被序列化的类，通过实现Serializable接口：

class Student implements Serializable{

private static final long serialVersionUID = 1L;

//多种类型测试
private int id;
private String name;
private Address address;
private ArrayList<String> course;

public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Address getAddress() {
return address;
}
public void setAddress(Address address) {
this.address = address;
}
public ArrayList<String> getCourse() {
return course;
}
public void setCourse(ArrayList<String> course) {
this.course = course;
}
}
//被引用的类也需要实现Serializable接口，否则会报错
class Address implements Serializable{
private static final long serialVersionUID = 1L;

private String street;
private String road;
public String getStreet() {
return street;
}
public void setStreet(String street) {
this.street = street;
}
public String getRoad() {
return road;
}
public void setRoad(String road) {
this.road = road;
}
}

接下来，先测试针对MySQL的对象序列化的测试：

先建立数据库表，字段对应为“blog”：

mysql> create table student(
-> id int auto_increment primary key,
-> stu blob
-> );

接下来，写测试用例：

public static void main(String[] args) throws IOException{

String url = "jdbc:mysql://localhost:3306/test";
String user = "root";
String pass = "root";

Student student = new Student();
student.setId(2);
student.setName("gaoya");

Address address = new Address();
address.setStreet("aa");
address.setRoad("bb");
student.setAddress(address);

ArrayList<String> course = new ArrayList<String>();
course.add("math");
course.add("english");
student.setCourse(course);

try {
Class.forName("com.mysql.jdbc.Driver");
Connection conn = DriverManager.getConnection(url, user, pass);
String sql = "insert into student(stu) values(?)";
PreparedStatement pre = conn.prepareStatement(sql);
pre.setObject(1, student);
pre.executeUpdate();

sql = "select stu from student";
pre = conn.prepareStatement(sql);
ResultSet rs = pre.executeQuery();
while(rs.next()){
Blob blob = rs.getBlob(1);
InputStream is = blob.getBinaryStream();
BufferedInputStream buff = new BufferedInputStream(is);

byte[] b = new byte[(int)blob.length()];
while(buff.read(b) != -1);

ObjectInputStream obj = new ObjectInputStream(new ByteArrayInputStream(b));
Student stu = (Student)obj.readObject();

System.out.println(stu.getName());
System.out.println(stu.getId());
System.out.println(stu.getAddress().getRoad() + " " + stu.getAddress().getStreet());
System.out.println(stu.getCourse());
;
}
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}

输出结果：



再来针对文件的对象序列化

public static void main(String[] args){

Student student = new Student();
student.setId(2);
student.setName("gaoya");

Address address = new Address();
address.setStreet("aa");
address.setRoad("bb");
student.setAddress(address);

ArrayList<String> course = new ArrayList<String>();
course.add("math");
course.add("english");
student.setCourse(course);

try {

//将对象序列化到文件
File file = new File("d:\\out.txt");//输出目录
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(file));
out.writeObject(student);
out.close();

ObjectInputStream in = new ObjectInputStream(new FileInputStream(file));
Student stu = (Student)in.readObject();

System.out.println(stu.getId());
System.out.println(stu.getName());
System.out.println(stu.getAddress().getRoad() + " " + stu.getAddress().getStreet());
System.out.println(stu.getCourse());
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}

输出结果:



再提一下transient关键字，当某个字段被声明为transient后，默认序列化机制就会忽略该字段。此处将Student类中的id字段声明为transient：

private transient String name;

再运行得到的结果如下：



可见name字段未被序列化；如想再恢复该字段的序列化能力，除了删除transient关键字以外，还有另外一种方式：即在Student类中加两个方法，如下所示：

//需将这两个方法定义为private，序列化的时候会自动被调用
private void writeObject(ObjectOutputStream out) throws IOException{
out.defaultWriteObject();//执行默认化序列化机制
out.writeUTF(name);//将name字段写入ObjectOutputStream中
}

private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException{
in.defaultReadObject();//执行默认反序列化机制
name = in.readUTF();//将name字段读入ObjectInputStream中
}

直接在此运行得到结果如图：



还有另一种序列化接口-Externalizable

将之前两个类修改如下：

class Student implements Externalizable{

private static final long serialVersionUID = 1L;
//多种类型测试
private int id;
private transient String name;
private Address address;
private ArrayList<String> course;

public Student(){
System.out.println("student");
}

public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Address getAddress() {
return address;
}
public void setAddress(Address address) {
this.address = address;
}
public ArrayList<String> getCourse() {
return course;
}
public void setCourse(ArrayList<String> course) {
this.course = course;
}

private void writeObject(ObjectOutputStream out) throws IOException{
out.defaultWriteObject();//执行默认化序列化机制
out.writeUTF(name);//将name字段写入ObjectOutputStream中
}

private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException{
in.defaultReadObject();
name = in.readUTF();
}
@Override
public void writeExternal(ObjectOutput out) throws IOException {
// TODO Auto-generated method stub

}
@Override
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
// TODO Auto-generated method stub

}
}

class Address implements Externalizable{
private static final long serialVersionUID = 1L;

private String street;
private String road;

public Address(){
System.out.println("address");
}

public String getStreet() {
return street;
}
public void setStreet(String street) {
this.street = street;
}
public String getRoad() {
return road;
}
public void setRoad(String road) {
this.road = road;
}

@Override
public void writeExternal(ObjectOutput out) throws IOException {
// TODO Auto-generated method stub

}
@Override
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
// TODO Auto-generated method stub

}
}

此时在此运行程序，得到结果如下：



从该结果可看出对象中任何一个字段都没有被序列化，但是可以看出调用了类的无参构造器。Externalizable继承于Serializable，当使用该接口时，序列化的细节需要由通过实现writeExternal()与readExternal()方法。另外，若使用Externalizable进行序列化，当读取对象时，会调用被序列化类的无参构造器去创建一个新的对象，然后再将被保存对象的字段的值分别填充到新对象中。这就是为什么在此次序列化过程中类的无参构造器会被调用。由于这个原因，实现Externalizable接口的类必须要提供一个无参的构造器，且它的访问权限为public。

对上述类作进一步的修改，使其能够对name与age字段进行序列化：

@Override
public void writeExternal(ObjectOutput out) throws IOException {
// TODO Auto-generated method stub
out.writeInt(id);
out.writeObject(name);
out.writeObject(address);
out.writeObject(course);

}
@Override
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
// TODO Auto-generated method stub
id = in.readInt();
name = (String)in.readObject();
address = (Address) in.readObject();
course = (ArrayList<String>) in.readObject();

}

@Override
public void writeExternal(ObjectOutput out) throws IOException {
// TODO Auto-generated method stub
out.writeObject(street);
out.writeObject(road);
}
@Override
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
// TODO Auto-generated method stub
street = (String) in.readObject();
road = (String) in.readObject();
}

在运行得到如下结果：



最后说一下serialVersionUID的作用：

Java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的，在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应类的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，如不同，就会出现序列化版本不一致的异常，如下图：



serialVersionUID有两种生成方式：一个是指定一个默认值，比如：private static final long serialVersionUID = 1L; 另一个是根据类名、接口名、成员方法及属性等来生成一个64位的哈希字段，比如：private static final long serialVersionUID = 8107332608515657739L。

在实现序列化的过程当中，如果我们没有显示的指定serialVersionUID，Java序列化机制会根据编译的class自动生成一个serialVersionUID(不同的编译器对于同一个类可能会产生不同的serialVersionUID)，如果我们在序列化期间没有对类进行修改，那么无论编译多少次serialVersionUID都不会变，也就是说反序列化的时候不会出现问题，但是我们一旦修改了类的某一部分，反序列化就会出现如上所说的版本不一致的异常。

所以需要序列化的时候，我们最好显示的指定serialVersionUID(但要注意的是，如果使用第一种方式即指定默认值，需要对不同的类指定程不同的值，否则可能会出现把不同项目的相同类名的类当作一样的类去处理)，这样当序列化一个类实例的时候，如添加修改删除一个字段，反序列化的时候对于添加和修改的字段会设定对于其类型的默认值，而删除的字段将不设置。