Serializable的序列化与反序列化

使用Serializable序列化，只要实现Serializable接口即可。一般情况下都会显示设置静态成员变量serialVersionUID为固定值。序列化时使用ObjectOutputStream写入，反序列化时使用ObjectInputStream读出。

如此简单，谁都会。但这是我碰到复杂点的情况，特作以下总结：

1、Serializable可继承：父类实现了序列化，子类也会自动实现序列化

PersonBean.java:

public class PersonBean implements Serializable{
    private static final long serialVersionUID = 1L;

    private String name;
    private int age;

    public PersonBean(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }

    @Override
    public String toString() {
        return name + "$$$" + age;
    }
}

ProgrammerBean.java:

public class ProgrammerBean extends PersonBean {
    private String language;

    public ProgrammerBean(String name, int age, String language) {
        super(name, age);
        this.language = language;
    }


    public String getLanguage() {
        return language;
    }

    public void setLanguage(String language) {
        this.language = language;
    }

    @Override
    public String toString() {
        return getName() + "@@@" + getAge() + "@@@" + language;
    }
}

SerialTest.java:

package com.example;

import com.example.serialBean.PersonBean;
import com.example.serialBean.ProgrammerBean;

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

/**
 * Created by Ralap on 2016/7/11.
 */
public class SerialTest {

    private static final String filePath = System.getProperty("user.dir");
    private static final String fileName = "serialTest.st";


    public static void test() {
        // 1、Serializable可继承
        testExtends();

        // 2、transient和static修饰变量，使其不参加序列化

        // 3、含有不可序列化的对象，自定义writeObject()和readObject()

        // 4、集合序列化

    }

    private static void testExtends() {
        PersonBean personBean = new PersonBean("Boss", 38);
        ProgrammerBean programmerBean = new ProgrammerBean("hacker", 29, "Java");

        printfn("==========Before Serialize :==========");
        printfn(personBean.toString());
        printfn(programmerBean.toString());

        File file = createFile();
        if (file == null) {
            printfn("create file fail");
            return;
        }

        // 序列化
        serialize(file, personBean, programmerBean);

        // 反序列化
        Object[] objs = new Object[2];
        unserialize(file, objs);
        PersonBean perBean = (PersonBean) objs[0];
        ProgrammerBean proBean = (ProgrammerBean) objs[1];

        // 打印
        printfn("==========After Unserialize:==========");
        printfn(perBean.toString());
        printfn(proBean.toString());
    }

    /**
     * 序列化
     *
     * @param file 序列化目标文件
     * @param objs 序列化对象
     */
    private static void serialize(File file, Object... objs) {
        ObjectOutputStream objectOS = null;
        try {
            FileOutputStream fos = new FileOutputStream(file);
            objectOS = new ObjectOutputStream(fos);
            for (Object obj : objs) {
                objectOS.writeObject(obj);
            }
            objectOS.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (objectOS != null) {
                try {
                    objectOS.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 反序列化
     * @param file 反序列化文件
     * @return 反序列化出来的对象数组
     */
    private static void unserialize(File file, Object[] objs) {

        ObjectInputStream objectIS = null;
        try {
            FileInputStream fis = new FileInputStream(file);
            objectIS = new ObjectInputStream(fis);
            Object obj;
            int offset = 0;
            while ((obj = objectIS.readObject()) != null) {
                objs[offset++] = obj;
                if (offset >= objs.length) {
                    return;
                }
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (objectIS != null) {
                try {
                    objectIS.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private static void printf(String s) {
        System.out.printf("%s", s);
    }

    private static void printfn(String s) {
        System.out.printf("%s\n", s);
    }

    /**
     * 创建文件
     * 存在：删除后新建。不存在：新建
     */
    private static File createFile() {
        File file = new File(filePath, fileName);
        try {
            if (file.exists()) {
                if (!file.delete()) {
                    return null;
                }
            }
            if (!file.createNewFile()) {
                return null;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return file;
    }
}

结果：

2、static和transient修饰的变量，将不参加序列化

序列化只对类中的filed字段属性进行序列化，且序列化的只是类的实例对象的属性类型及值，所以method方法和static修饰的属性将不被序列化。如果要让非static属性也不序列化，使用transient。

扩展：另一个修饰变量符volatile，易变的意思。一般用于多线程中，因为每个线程都会有自己独立的内存空间，共享变量会从主内存拷贝一份到自己的内存中，操作的是自己内存中的数值，在进入线程或退出同步代码块时，才与共享中的成员变量进行比对、同步，这样可能导致其他线程获取到的不是最新值。所以，用volatile来修饰共享成员变量，在每次使用变量时都会强迫从共享内存中重新读取共享变量的值。

static：静态的，被所有对象共享，非某个对象私有，不会被持久化
transient：代表瞬间的意思，表示不会被持久化

把上面ProgrammerBean和SerialTest进行修改

ProgrammerBean.java

public class ProgrammerBean extends PersonBean {
    private String language;
    private static String belongIndustry = "Linux"; // static修饰
    transient private boolean hasGF; // transient修饰。boolean默认值是false，注意比较

    public ProgrammerBean(String name, int age, String language) {
        super(name, age);
        this.language = language;
    }


    public String getLanguage() {
        return language;
    }

    public void setLanguage(String language) {
        this.language = language;
    }

    public static String getBelongIndustry() {
        return belongIndustry;
    }

    public static void setBelongIndustry(String belongIndustry) {
        ProgrammerBean.belongIndustry = belongIndustry;
    }

    public boolean isHasGF() {
        return hasGF;
    }

    public void setHasGF(boolean hasGF) {
        this.hasGF = hasGF;
    }


    @Override
    public String toString() {
        return getName() + "^^^" + getAge() + "^^^" + language + "^^^" + belongIndustry + "^^^" + hasGF;
    }
}

SerialTest.java修改部分

    public static void test() {
        // 1、Serializable可继承
//        testExtends();

        // 2、transient和static修饰变量，使其不参加序列化
        testNotSerial();

        // 3、含有不可序列化的对象，自定义writeObject()和readObject()

        // 4、集合序列化

    }

    private static void testNotSerial() {
        PersonBean personBean = new PersonBean("Boss", 38);
        ProgrammerBean programmerBean = new ProgrammerBean("hacker", 29, "Java");
        programmerBean.setHasGF(true);

        printfn("==========Before Serialize :==========");
        printfn(personBean.toString());
        printfn(programmerBean.toString());

        File file = createFile();
        if (file == null) {
            printfn("create file fail");
            return;
        }

        // 序列化
        serialize(file, personBean, programmerBean);

        // 序列化后修改static属性值
        ProgrammerBean.setBelongIndustry("Android");

        // 反序列化
        Object[] objs = new Object[2];
        unserialize(file, objs);
        PersonBean perBean = (PersonBean) objs[0];
        ProgrammerBean proBean = (ProgrammerBean) objs[1];

        // 打印
        printfn("==========After Unserialize:==========");
        printfn(perBean.toString());
        printfn(proBean.toString());
    }

结果：

3、使用自定义序列化使不可序列化的类序列化

一些类没有实现Serializable，就不能序列化。如ProgrammerBean中包含了一个不可序列化的类InterestBean。

ProgrammerBean.java

public class ProgrammerBean extends PersonBean {
    private String languages;
    InterestBean interest;

    public ProgrammerBean(String name, int age, String languages) {
        super(name, age);
        this.languages = languages;
    }


    public String getLanguages() {
        return languages;
    }

    public void setLanguages(String languages) {
        this.languages = languages;
    }

    public InterestBean getInterest() {
        return interest;
    }

    public void setInterest(InterestBean interest) {
        this.interest = interest;
    }

    @Override
    public String toString() {
        return getName() + "^^^" + getAge() + "^^^" + languages + ":::" + interest.getType() + "^^^" + interest.getNames();
    }
}

InterestBean.java

public class InterestBean{
    private String type;
    private String names;

    public InterestBean(String type, String names) {
        this.type = type;
        this.names = names;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getNames() {
        return names;
    }

    public void setNames(String names) {
        this.names = names;
    }
}

SerialTest.java部分修改（从别人那学习到更漂亮的序列化代码，因此作了修改）

package com.example;

import com.example.serialBean.InterestBean;
import com.example.serialBean.ProgrammerBean;

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

/**
 * Created by Ralap on 2016/7/11.
 */
public class SerialTest {

    private static final String filePath = System.getProperty("user.dir");
    private static final String fileName = "serialTest.st";


    public static void test() {
        // 1、Serializable可继承
//        testExtends();

        // 2、transient和static修饰变量，使其不参加序列化
//        testNotSerial();

        // 3、含有不可序列化的对象，自定义writeObject()和readObject()
        testCustomSerial();

        // 4、集合序列化

    }

    private static void testCustomSerial() {
        ProgrammerBean programmerBean = new ProgrammerBean("hacker", 29, "Java");
        InterestBean interest = new InterestBean("gril", "Gril God");
        programmerBean.setInterest(interest);

        printfn("==========Before Serialize :==========");
        printfn(programmerBean.toString());

        File file = createFile();
        if (file == null) {
            printfn("create file fail");
            return;
        }

        // 序列化
        serialize(file, programmerBean);

        // 反序列化
        ProgrammerBean proBean = unserialize(file);

        // 打印
        printfn("==========After Unserialize:==========");
        printfn(proBean.toString());
    }

    /**
     * 序列化
     *
     * @param file 序列化目标文件
     * @param object 序列化对象
     */
    private static <T> void serialize(final File file, final T object) {
        ObjectOutputStream objectOS = null;
        try {
            FileOutputStream fos = new FileOutputStream(file);
            objectOS = new ObjectOutputStream(fos);
            objectOS.writeObject(object);
            objectOS.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (objectOS != null) {
                try {
                    objectOS.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 反序列化
     * @param file 反序列化文件
     * @return 反序列化出来的对象数组
     */
    private static <T> T unserialize(final File file) {
        ObjectInputStream objectIS = null;
        T retObj = null;
        try {
            FileInputStream fis = new FileInputStream(file);
            objectIS = new ObjectInputStream(fis);
            retObj =  (T)objectIS.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (objectIS != null) {
                try {
                    objectIS.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return retObj;
    }

}

上面在写入和读出的时候都会报不可序列化异常：NotSerializableException

如果这是自己的类，实现一下Serializable就OK了。但万一这是别人封装好的，不能修改，那怎么办？这时就可以使用自定义的序列化方法。在类中
【1】给该属性添加修饰符transient，为不可序列化。
【2】加上下面三个方法（一般前面两个就可以）并实现之：

// Serializable接口中没有抽象方法，这些方法不是重写接口的方法，且他们都是private，但序列化时会自动调用这里的方法。这就是机制
private void writeObject(ObjectOutputStream out) throws IOException {
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException{
}
private void readObjectNoData() throws ObjectStreamException
{
}

修改后的ProgrammerBean.java

public class ProgrammerBean extends PersonBean {
    private String languages;
    transient private InterestBean interest;

    public ProgrammerBean(String name, int age, String languages) {
        super(name, age);
        this.languages = languages;
    }


    public String getLanguages() {
        return languages;
    }

    public void setLanguages(String languages) {
        this.languages = languages;
    }

    public InterestBean getInterest() {
        return interest;
    }

    public void setInterest(InterestBean interest) {
        this.interest = interest;
    }

    @Override
    public String toString() {
        return getName() + "^^^" + getAge() + "^^^" + languages + ":::" + interest.getType() + "^^^" + interest.getNames();
    }

    private void writeObject(ObjectOutputStream out) throws IOException {
        // 先使用默认写入，会自动把可序列化的序列化
        out.defaultWriteObject();
        out.writeUTF(interest.getType());
        out.writeUTF(interest.getNames());
    }
    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException{
        // 先使用默认读出，会自动把可序列化的读出
        in.defaultReadObject();
        // interest默认是null，这里必须新建。且读出与写入顺序必须一致
        interest = new InterestBean(in.readUTF(), in.readUTF()); 
    }
    private void readObjectNoData() throws ObjectStreamException
    {
        throw new InvalidObjectException("No Stream Data");
    }
}

这样结果就出来：

4、集合的序列化

ArrayList实现了Serializable接口，完全可以序列化。这个完全当做是验证测试

SerialTest.java部分修改

public class SerialTest {

    private static final String filePath = System.getProperty("user.dir");
    private static final String fileName = "serialTest.st";


    public static void test() {
        // 1、Serializable可继承
//        testExtends();

        // 2、transient和static修饰变量，使其不参加序列化
//        testNotSerial();

        // 3、含有不可序列化的对象，自定义writeObject()和readObject()
//        testCustomSerial();

        // 4、集合序列化
        testListSerial();
    }

    private static void testListSerial() {
        List<ProgrammerBean> list = new ArrayList<>();
        for (int i = 0; i < 5000; i++) {
            ProgrammerBean programmerBean = new ProgrammerBean("hacker" + i, 29, "Java");
            programmerBean.setInterest(new InterestBean("gril", "Gril God" + i));
            list.add(programmerBean);
        }

//        printfn("==========Before Serialize :==========");
//        printfn(programmerBean.toString());

        File file = createFile();
        if (file == null) {
            printfn("create file fail");
            return;
        }

        // 序列化
        serialize(file, list);

        // 反序列化
        List<ProgrammerBean> programmerList = unserialize(file);

        // 打印
        printfn("==========After Unserialize:==========");
        for (ProgrammerBean pro : programmerList) {
            printfn(pro.toString());
        }
    }

结果：

……

serialTest.st文件的大小：247 KB (252,987 字节)

我们目前使用的是XML（json因故暂时不考虑），XML也可以实现序列化与反序列化，具体有什么区别，还没研究，但先来简单计算下文件大小：

①Serializable中，UTF-8编码格式，都是英文字母或数字，每个字母或数字占一个字节，一个bean中的有意义的数据（属性值）大概是33个字节，33*5000 = 165,000字节。其他的占空间的都是包名+类名，属性类型。

②XML中，有意义的数据不变，也是165,000字节，其他的主要是tag占空间。保守假设每个tag名称为5字节，格式是<tag01>value</tag01>，也就是说每个属性值还要是15字节，每个bean共有6个属性。这样一个bean就是7*15 = 105字节，tag总空间：105*5000 = 525,000字节。

So，从大小上来说，还是Serializable节省空间。代码还不用写xml这样复杂的序列化与反序列化，看到那么多Bean，简单重复的操作，真想写个框架（反射+注解）改掉它。老大说xml执行效率高，也许吧，下次验证下就知道了。

下篇进攻XML……

---

补充（2016/7/12 18:00）：
上面第一种情况是父类序列化，子类会自动实现序列化。如果父类不序列化，子类需要序列化。如上，PersonBean不实现Serializable，而ProgrammerBean实现Serializable，其他保持原样不变。这样，子类对象在序列化时正常，但反序列化时会报以下异常：

java.io.InvalidClassException: com.example.serialBean.ProgrammerBean; no valid constructor
    at java.io.ObjectStreamClass$ExceptionInfo.newInvalidClassException(ObjectStreamClass.java:150)
    at java.io.ObjectStreamClass.checkDeserialize(ObjectStreamClass.java:768)
    at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1772)
    at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1350)
    at java.io.ObjectInputStream.readObject(ObjectInputStream.java:370)

这表示，在反序列化时检测的时候抛的异常，提示该类没有有效的构造方法。
解决办法：在父类中添加无参构造方法。具体原因，不详，百度也没找到满意的答案（希望哪位大神帮忙解惑下）。这让我想起了以前一位老师说过，永远给出无参构造方法。