对象的序列化和反序列化浅析

对象的序列化和反序列化浅析

• 什么是序列化和反序列化？

　　对象序列化，就是将Object转换成byte序列，反之叫对象的反序列化
　　序列化流(ObjectOutputStream),是过滤流----writeObject
　　反序列化流(ObjectInputStream)---readObject

• 序列化接口(Serializable)介绍

　　这是一个位于java.io包下的空接口，没有任何方法，只是一个标准，这不更是接口的精髓所在嘛，哈哈，对于接口的概念还比较模糊的朋友可参考我的这一篇博文：Java基础之抽象类与接口
　　此外，对象必须实现此序列化接口 ，才能进行序列化，否则将抛出异常

• transient关键字

　　在实际开发过程中，我们常常会遇到这样的问题，这个类的有些属性需要序列化，而其他属性不需要被序列化，打个比方，如果一个用户有一些敏感信息（如密码，银行卡号等），为了安全起见，不希望在网络操作（主要涉及到序列化操作，本地序列化缓存也适用）中被传输，这些信息对应的变量就可以加上transient关键字。换句话说，这个字段的生命周期仅存于调用者的内存中而不会写到磁盘里持久化。

　　总之，java 的transient关键字为我们提供了便利，你只需要实现Serilizable接口，将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中。

　　对于加了transient关键字的属性但自己需要自己进行序列化时，我们可以定义这两个方法（参考ArrayList源码）

　　private void writeObject(java.io.ObjectOutputStream s)
                throws java.io.IOException

　　private void readObject(java.io.ObjectInputStream s)
                throws java.io.IOException, ClassNotFoundException

• 代码分析：

　　定义一个学生类

package me.io.seri;

import java.io.Serializable;

/**
 * 学生类
 * 
 * @author Administrator
 *
 */
public class Student implements Serializable {

    private static final long serialVersionUID = 1L;
    private String stuNum;
    private String stuName;
    // 该元素不会被jvm进行默认的序列化，也可以自己进行序列化
    private transient int stuAge;

    public Student() {
    }

    public Student(String stuNum, String stuName, int stuAge) {
    super();
    this.stuNum = stuNum;
    this.stuName = stuName;
    this.stuAge = stuAge;
    }

    public String getStuName() {
    return stuName;
    }

    public void setStuName(String stuName) {
    this.stuName = stuName;
    }

    public int getStuAge() {
    return stuAge;
    }

    public void setStuAge(int stuAge) {
    this.stuAge = stuAge;
    }

    public String getStuNum() {
    return stuNum;
    }

    public void setStuNum(String stuNum) {
    this.stuNum = stuNum;
    }

    @Override
    public String toString() {
    return "Student [stuNum=" + stuNum + ", stuName=" + stuName + ", stuAge=" + stuAge + "]";
    }

    private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {

    s.defaultWriteObject();// 把JVM能默认序列化的元素进行序列化操作
    s.writeInt(stuAge);// 自己完成stuAge的序列化操作
    }

    private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException {
    s.defaultReadObject();// 把JVM默认反序列化的元素进行反序列化操作
    this.stuAge = s.readInt();// 自己完成stuAge的反序列化操作
    }
}

　　对象序列化和反序列化示例：

package me.io.seri;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/**
 * 对象序列化和反序列化示例
 * 
 * @author Administrator
 *
 */
public class ObjectSeriaUtil {

    public static ObjectOutputStream oos = null;
    public static ObjectInputStream ois = null;
    public static String file = null;

    public static void setFile(String file) {
    ObjectSeriaUtil.file = file;
    }

    /**
     * 对象的序列化
     * 
     * @param obj
     * @throws IOException
     */
    public static void ObjectSerialize(Object obj) throws IOException {
    oos = new ObjectOutputStream(new FileOutputStream(file));
    oos.writeObject(obj);
    oos.flush();
    oos.close();
    }

    /**
     * 对象反序列化
     * @throws IOException
     * @throws ClassNotFoundException
     */
    public static void ObjectDeserialize() throws IOException, ClassNotFoundException {
    ois = new ObjectInputStream(new FileInputStream(file));
    System.out.println(ois.readObject());
    ois.close();
    }

}

　　main方法进行测试：

package me.io.seri;

import java.io.IOException;

public class SeriaMain {

    public static void main(String[] args) throws IOException, ClassNotFoundException {
    ObjectSeriaUtil.setFile("demo/obj.dat");
    ObjectSeriaUtil.ObjectSerialize(new Student("10003", "Rose", 18));
    ObjectSeriaUtil.ObjectDeserialize();
    }
}

       

• 分析ArrayList源码中序列化和反序列化的问题

　　我们都知道ArrayList是基于动态数组实现的一个操作集合的工具类，它实现了Serializable接口，意味着ArrayList可以进行序列化，关于ArrayList我在前面的博文中也有详细的介绍，不太清楚的朋友们可以看看我的这篇博文：

　　Java集合框架之ArrayList浅析

　　先来看看ArrayList中这个动态数组的定义：
　　　　transient Object[] elementData;

　　就这么简短的一句，主要是前面的transient关键字，这意味着elementData不会被JVM默认的进行序列化，ArrayList会对它进行序列化

　　我们来看看ArrayList的两个方法：

　　这个方法中ArrayList使用for循环对elementData进行了序列化

private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        elementData = EMPTY_ELEMENTDATA;

        // Read in size, and any hidden stuff
        s.defaultReadObject();

        // Read in capacity
        s.readInt(); // ignored

        if (size > 0) {
            // be like clone(), allocate array based upon size not capacity
            ensureCapacityInternal(size);

            Object[] a = elementData;
            // Read in all elements in the proper order.
            for (int i=0; i<size; i++) {
                a[i] = s.readObject();
            }
        }
}

　　同样，这个方法中ArrayList使用for循环对elementData进行了反序列化操作

private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
        // Write out element count, and any hidden stuff
        int expectedModCount = modCount;
        s.defaultWriteObject();

        // Write out size as capacity for behavioural compatibility with clone()
        s.writeInt(size);

        // Write out all elements in the proper order.
        for (int i=0; i<size; i++) {
            s.writeObject(elementData[i]);
        }

        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
}

　　为什么要这么做呢？

　　来看看ArrayList中成员变量size的定义：

/**
 * The size of the ArrayList (the number of elements it contains).
 *
 * @serial
 */
private int size;

　　可见，size表示ArrayList中当前包含的元素的个数

　　再回头看看readObject和writeObject这两个方法中的for循环，相信大家应该已经理解了吧

　　Java类库的设计者是为了提高ArrayList的性能才这样去做的，显然由于ArrayList的动态扩容机制，ArrayList中包含的元素的个数总是小于ArrayList的容量，因此对ArrayList做序列化操作时，对于动态数组根据其元素的个数做序列化显然比直接对整个数组序列化性能会高一些。

• 序列化中 子类和父类构造函数的调用问题

　　代码分析：

package me.io.seri;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class SerializableDemo {
    public static void main(String[] args) throws Exception {
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("demo/obj1.dat"));
    Foo2 foo2 = new Foo2();
    oos.writeObject(foo2);
    oos.flush();
    oos.close();

    // 反序列化是否递归调用父类的构造函数
    ObjectInputStream ois = new ObjectInputStream(new FileInputStream("demo/obj1.dat"));
    Foo2 foo21 = (Foo2) ois.readObject();
    System.out.println(foo21);
    ois.close();

    ObjectOutputStream oos1 = new ObjectOutputStream(new FileOutputStream("demo/obj1.dat"));
    Bar2 bar2 = new Bar2();
    oos1.writeObject(bar2);
    oos1.flush();
    oos1.close();

    ObjectInputStream ois1 = new ObjectInputStream(new FileInputStream("demo/obj1.dat"));
    Bar2 bar21 = (Bar2) ois1.readObject();
    System.out.println(bar21);
    ois1.close();

    /*
     * 对子类对象进行反序列化操作时， 如果其父类没有实现序列化接口 那么其父类的构造函数会被调用
     */
    }
}

/*
 * 一个类实现了序列化接口，那么其子类都可以进行序列化
 */
class Foo implements Serializable {
    public Foo() {
    System.out.println("foo...");
    }
}

class Foo1 extends Foo {
    public Foo1() {
    System.out.println("foo1...");
    }
}

class Foo2 extends Foo1 {
    public Foo2() {
    System.out.println("foo2...");
    }
}

class Bar {
    public Bar() {
    System.out.println("bar");
    }
}

class Bar1 extends Bar {
    public Bar1() {
    System.out.println("bar1..");
    }
}

class Bar2 extends Bar1 implements Serializable {
    public Bar2() {
    System.out.println("bar2...");
    }
}

 　　博主原创，转载请注明出处，谢谢!