Java基础-IO流对象之序列化（ObjectOutputStream）与反序列化（ObjectInputStream）

　　　　　　　Java基础-IO流对象之序列化（ObjectOutputStream）与反序列化（ObjectInputStream）

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰

版权声明：原创作品，谢绝转载！否则将追究法律责任。

 

 

 

 

一.对象的序列化与反序列化

 　　ObjectOutputStream流用于将对象保存在磁盘中，或者通过网络传输到另一台主机上。保存在文件中的对象的二进制流可以用ObjectInputStream流在以后被还原成原来的对象。

　　对象输出流的对象可以永久的保存在磁盘上，使对象可以脱离程序而存在，此过程也称为“序列化”过程，反之，将磁盘的数据加载到内存中的就称为“反序列化”过程。换句话说，对象中的数据以流的形式写入到文件中保存的过程称为写出对象，也叫对象的序列化，在文件中以流的形式将对象读取出来，读取对象的过程也叫反序列化。

　 

　　注意：反序列化是不走构造方法的哟！

 

 

二.ObjectOutputStream流写对象

　　类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。序列化接口没有方法或字段，仅用于标识可序列化的语义。

　　接下来我们定义一个实现Serializable类接口如下：

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/

package cn.org.yinzhengjie.note6;

import java.io.Serializable;

public class Person implements Serializable{
    private String Name;
    private int Age;
    public Person(String name, int age) {
        super();
        Name = name;
        Age = age;
    }
    
    public String getName() {
        return Name;
    }
    
    public void setName(String name) {
        Name = name;
    }
    
    public int getAge() {
        return Age;
    }
    
    public void setAge(int age) {
        Age = age;
    }
    
    @Override
    public String toString() {
        return "Person [姓名=" + Name + ",年龄=" + Age+ "]";
    }
}

　　定义好需要序列化的对象之后，我们需要就来搞事情吧，看看ObjectOutputStream 到底是如何使用的，案例如下：

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/

package cn.org.yinzhengjie.note6;

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

public class ObjectOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        //创建字节输出流，封装文件
        File file = new File("yinzhengjie.txt");
        if(!file.exists()) {
            file.createNewFile();
        }
        FileOutputStream fos = new FileOutputStream(file);
        
        //创建写出对象的序列化流的对象，构造方法传递字节输出流
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        Person p = new Person("yinzhengjie", 18);
        //调用序列化流的方法writeObject,写出对象。需要实例对象p具有序列化接口，否则会抛出异常对象：java.io.NotSerializableException
        oos.writeObject(p);
        //别忘了释放资源哟！
        oos.close();
    }
}

 

三.ObjectInputStream流读取对象

 　　在反序列一个文件内容的时候可能会存在java.lang.ClassNotFoundException类异常，原因是缺少反序列的字节码（*.class）文件。因此，序列化的前提是：必须有反序列化相关的字节码文件。现在我们把之前序列化的文件进行反序列操作，如下：

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/

package cn.org.yinzhengjie.note6;

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

public class ObjectInputSteamDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //创建字节输入流，封装文件
        File file = new File("yinzhengjie.txt");
        FileInputStream fis = new FileInputStream(file);
        //创建反序列化流，构造方法中，传递字节输入流
        ObjectInputStream ois = new ObjectInputStream(fis);
        //调用反序列化流的方法"readObject()"读取对象，要注意的是反序列话的对象需要存在相应的字节码文件。否则会抛异常
        Object obj = ois.readObject();
        //记得释放资源
        ois.close();
        //查看我们的想要看的内容。
        System.out.println(obj);
    }
}


/*
以上代码执行结果如下：
Person [姓名=yinzhengjie,年龄=18]
*/

　　注意，在序列化和反序列化过程中，序列化用的什么方法写入，我们读取的时候也应该用对应的方法去读取，打个比方，我们上面序列化一个自定义类时，用的是wirteObject()方法，读取的时候应该用对应方法读取，我们上面的案例就是用readObject方法进行读取，如果你序列化使用的wirteInt()方法，那么反序列话的时候就应该用readInt()方法哟！谨记这一点，会让你少踩很多坑的，别问我为什么这么说，因为这个坑我已经踩了你就别去踩了哈！

 

四.关于序列化的面试题

1>.静态成员变量为什么不能被序列化？

　　答：序列化其实是将对象进行序列化操作，而static修饰的成员变量是属于类的，并非对象所有！因此静态修饰的成员变量无法被序列化。

2>.瞬态关键字transient的用法？

　　答：当一个类的对象需要被序列化时，某些属性不需要被反序列化，这时不需要序列化的属性可以使用关键字transient修饰，只要被transient修饰了，序列化时这个属性就不会被序列化啦！它的用法比较单一，只能用于修饰成员变量不被序列化！这样做的目的是可以节省空间，将不需要的数据不进行序列化操作。

3>.Serializable接口有上面含义？

　　答：Serializable并没有任何功能，只是一个标记性接口，就好像去菜市场买猪肉，安检人员会在猪肉上印上一个标记表示该猪肉检验合格可以食用！而在Java中用该接口只是标识该类是可以被序列化！

4>.分析序列化中的为什么会存在序列化冲突问题？

　　答：Java代码在执行之前需要经过javac命令对源代码进行编译生成字节码文件“*.class”，与此同时会给该“*.class”计算出来一个序列号（serialVersionUID），在序列化时会将该属性一并序列化到文件中。当我们对源代码再次进行编辑时，依然是需要javac命令进行编译该文件才能运行修改后的代码，此时会生成一个新的序列号（serialVersionUID）出来。这个时候当我们将序列化的文件进行反序列化操作时，首先会对比字节码文件的序列号是否一致，如果不一致，则会抛出异常：“java.io.InvalidClassException”。

5>.为什么要自定义序列号？

　　答：原因很简单，就是为了解决序列化冲突问题。我们只需要要让源代码修改前和修改后的序列号（serialVersionUID）保持一致，这样就可以正常进行序列化操作啦！我们可以看一下案例如下：

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/

package cn.org.yinzhengjie.note6;

import java.io.Serializable;

public class Person implements Serializable{
    private String Name;
    public /*transient关键字在这里加，就可以阻止成员变量进行序列化啦！*/int Age;
    
    static final long serialVersionUid = 7758520L;        //类自定义序列号，编译器就不会计算序列号。
    
    public Person(String name, int age) {
        super();
        Name = name;
        Age = age;
    }
    
    public  String getName() {
        return Name;
    }
    
    public void setName(String name) {
        Name = name;
    }
    
    public int getAge() {
        return Age;
    }
    
    public void setAge(int age) {
        Age = age;
    }
    
    @Override
    public String toString() {
        return "Person [姓名=" + Name + ",年龄=" + Age+ "]";
    }
    

}

 

五.小试牛刀

 

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/
package cn.org.yinzhengjie.serializable;


import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

/**
 * 客户类
 */
public class Customer implements Serializable {
    private static final long serialVersionUID = 6327665722505706622L;
    private String name ;
    private int age ;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    //临时的,不参与串行化
    private transient List<Order> orders = new ArrayList<Order>() ;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public List<Order> getOrders() {
        return orders;
    }

    public void setOrders(List<Order> orders) {
        this.orders = orders;
    }
}

 

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/
package cn.org.yinzhengjie.serializable;


import java.io.Serializable;

/**
 * 客户类
 */
public class Item implements Serializable {
    private String itemname;

    public String getItemname() {
        return itemname;
    }

    public void setItemname(String itemname) {
        this.itemname = itemname;
    }
}

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/
package cn.org.yinzhengjie.serializable;


import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

/**
 * 客户类
 */
public class Order implements Serializable {
    private String orderno;

    private List<Item> items =new ArrayList<Item>() ;

    public List<Item> getItems() {
        return items;
    }

    public void setItems(List<Item> items) {
        this.items = items;
    }

    public String getOrderno() {
        return orderno;
    }

    public void setOrderno(String orderno) {
        this.orderno = orderno;
    }
}

 

1>.实现浅拷贝

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/
package cn.org.yinzhengjie.serializable;

import org.junit.Test;

public class ShallowReplicas {
    @Test
    public void testDeeplyCopy() throws Exception {
        Customer c = new Customer();
        c.setName("尹正杰");

        Order o1 = new Order();
        o1.setOrderno("0001");

        Order o2 = new Order();
        o2.setOrderno("0002");

        Item i1 = new Item();
        i1.setItemname("iphone 8 Plus");

        //建立关系
        c.getOrders().add(o1);
        c.getOrders().add(o2);

        o1.getItems().add(i1);

        //浅度复制
        Customer cc = new Customer();
        cc.setName(c.getName());
        cc.setOrders(c.getOrders());

        String name = cc.getName();
        System.out.println(name);
    }
}

2>.实现深度拷贝

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/

package cn.org.yinzhengjie.serializable;

import org.junit.Test;

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

public class DeepCopy {
   String filePath = "D:\\BigData\\JavaSE\\yinzhengjieData\\c.dat";

    /**
     * 深度拷贝，将对象序列化到文件
     */
    @Test
    public void testDeeplyCopy() throws Exception {
        Customer c = new Customer();
        c.setName("尹正杰");

        Order o1 = new Order();
        o1.setOrderno("0001");

        Order o2 = new Order();
        o2.setOrderno("0002");

        Item i1 = new Item();
        i1.setItemname("iphone 8 Plus");

        //建立关系
        c.getOrders().add(o1);
        c.getOrders().add(o2);

        o1.getItems().add(i1);

        //深度拷贝，将对象序列化到文件
        FileOutputStream fos = new FileOutputStream(filePath) ;
        ObjectOutputStream oos = new ObjectOutputStream(fos) ;
        oos.writeObject(c);
        oos.close();
        fos.close();
        System.out.println();
    }


    /**
     * 定义反序列化的代码
     */
    @Test
    public void testDeserialize() throws Exception {
        FileInputStream fis = new FileInputStream(filePath);
        ObjectInputStream ois = new ObjectInputStream(fis);
        Customer obj = (Customer)ois.readObject();
        ois.close();
        fis.close();
        System.out.println(obj.getName());
    }
}

/*
以上代码执行结果如下：
    尹正杰
 */