对象的串行化Serializable 接口

最新推荐文章于 2021-02-12 17:19:50 发布

远有青山

最新推荐文章于 2021-02-12 17:19:50 发布

阅读量1.6k

点赞数 1

分类专栏： Java

Java 专栏收录该内容

69 篇文章 5 订阅

订阅专栏

Serializable 接口–java.io.serializable

作用：类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。序列化接口没有方法或字段，仅用于标识可序列化的语义。
实现了此接口的类有：String, Integer, Boolean, Long, ArrayList, List, File 等等。
当java内存有一个对象的时候，我们想把它持久化保存起来，以后又可以从保存的数据中恢复成对象，这种情况经常在java中出现；sun公司为了方便实现这种功能，为用户提供了java.io.Serializable这个接口，这个接口中没有方法(又称为mini接口)；
在java编译器编译的时候对这种mini接口的对象进行特殊的编译，如果你的对象实现了serializable接口，那么就可以通过另一个工具ObjectOutputStream的方法writeObject(obj)来存储对象，而不需要具体知道存储该对象的具体细节；
当恢复对象的时候，便可以通过ObjectInputStream.readObject(obj)来恢复对象；
由于对于文件的存储目标是未知的，可以是硬盘也可以是网络上的某个主机，故ObjectInputStream和ObjectOutputStream并不是直接操作硬盘，也不是直接操作网络，而是操作可以直接访问物理设备的流的对象，如FileInputStream和FileOutputStream，即ObjectInputStream和ObjectOutputStream可以将直接进行底层操作的流FileInputStream和FileOutputStream包装起来，形成包装类，或者叫包装流；
在形成包装类之后，对于需要保存的对象，先由包装类的外层将该对象转换为二进制字节，再将这些字节传递给内层可以直接进行物理设备操作的流如FileOutputStream，通过底层流保存到物理设备；
包装的思想：首先，有个物理设备，如硬盘或网络，在内存中会有个流，如FileOutputStream，这个流只能有个write(byte[])方法，该方法写的是字节。而现在要将一个对象写入物理设备，故需要一个类来进行对象到字节的转换，这个转换类就是ObjectInputStream和ObjectOutputStream，通过这两个类转换，将转换后的字节数据交给FileOutputStream来进行物理设备操作。简单地说，就是一个分层的思想，也是“各尽其责”的思想。对象保存到物理设备，这个过程由两层完成，上层只负责将对象转换成字节数据，下层只负责将接收到的字节写入物理设备。
所以包装流(如ObjectOutputStream)并不真正连接到底层物理设备，它起到一个中转的作用，因此它的构造方法一定要传递给它一个与底层设备相关的流，前者是把数据转换完了交给后者去读写物理设备；对于物理设备是什么设备，包装流并不知道，只有传递给它的底层设备相关的流(如FileOutputStream)知道。

Serializable接口初探

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

　　Java的"对象序列化"能让你将一个实现了Serializable接口的对象转换成一组byte，这样日后要用这个对象时候，你就能把这些byte数据恢复出来，并据此重新构建那个对象了。

　　要想序列化对象，你必须先创建一个OutputStream，然后把它嵌进ObjectOutputStream。这时，你就能用writeObject( )方法把对象写入OutputStream了。

　　writeObject 方法负责写入特定类的对象的状态，以便相应的 readObject 方法可以还原它。通过调用 out.defaultWriteObject 可以调用保存 Object 的字段的默认机制。该方法本身不需要涉及属于其超类或子类的状态。状态是通过使用 writeObject 方法或使用 DataOutput 支持的用于基本数据类型的方法将各个字段写入 ObjectOutputStream 来保存的。

　　读的时候，你得把InputStream嵌到ObjectInputStream里面，然后再调用readObject( )方法。不过这样读出来的，只是一个Object的reference，因此在用之前，还得先下传。readObject 方法负责从流中读取并还原类字段。它可以调用 in.defaultReadObject 来调用默认机制，以还原对象的非静态和非瞬态字段。

　　最后结果如下：
node 0
node 1
node 2
node 3
node 4
node5
node 6

import java.io.*;

class tree implements java.io.Serializable

{

public tree left;

public tree right;

public int id;

public int level;

private static int count = 0;

public tree(int depth)

{

id = count++;

level = depth;

if (depth > 0)

{

left = new tree(depth - 1);

right = new tree(depth - 1);

}

public void print(int levels)

{

for (int i = 0; i < level; i++)

System.out.print(" ");

System.out.println(" node " + id);

if (level <= levels && left != null)

left.print(levels);

if (level <= levels && right != null)

right.print(levels);

}

public static void main(String argv[])

{

try

{

/** *//**//* 创建一个文件写入序列化树。 */

FileOutputStream ostream = new FileOutputStream(" tree.tmp ");

/** *//**//* 创建输出流 */

ObjectOutputStream p = new ObjectOutputStream(ostream);

/** *//**//* 创建一个二层的树。 */

tree base = new tree(2);

p.writeObject(base); // 将树写入流中。

p.writeObject(" LiLy is 惠止南国 ");

p.flush();

ostream.close(); // 关闭文件。

/** *//**//* 打开文件并设置成从中读取对象。 */

FileInputStream istream = new FileInputStream(" tree.tmp ");

ObjectInputStream q = new ObjectInputStream(istream);

/** *//**//* 读取树对象，以及所有子树 */

tree new_tree = (tree) q.readObject();

new_tree.print(2); // 打印出树形结构的最上面２级

String name = (String) q.readObject();

System.out.println(" " + name);

} catch (Exception ex)

{

ex.printStackTrace();

}

可以看到，在序列化的时候，writeObject与readObject之间的先后顺序。readObject将最先write的object read出来。用数据结构的术语来讲就姑且称之为先进先出吧！

　　在序列化时，有几点要注意的：
　　１：当一个对象被序列化时，只保存对象的非静态成员变量，不能保存任何的成员方法和静态的成员变量。
２：如果一个对象的成员变量是一个对象，那么这个对象的数据成员也会被保存。
　　３：如果一个可序列化的对象包含对某个不可序列化的对象的引用，那么整个序列化操作将会失败，并且会抛出一个NotSerializableException。我们可以将这个引用标记为transient，那么对象仍然可以序列化

　　还有我们对某个对象进行序列化时候，往往对整个对象全部序列化了，比如说类里有些数据比较敏感，不希望序列化，一个方法可以用transient来标识，另一个方法我们可以在类里重写

private void readObject(java.io.ObjectInputStream stream)

throws IOException, ClassNotFoundException;

private void writeObject(java.io.ObjectOutputStream stream)

throws IOException

这二个方法！
　　示例：

import java.io.*;

class ObjectSerialTest

{

public static void main(String[] args) throws Exception

{

Employee e1 = new Employee(" zhangsan ", 25, 3000.50);

Employee e2 = new Employee(" lisi ", 24, 3200.40);

Employee e3 = new Employee(" wangwu ", 27, 3800.55);

FileOutputStream fos = new FileOutputStream(" employee.txt ");

ObjectOutputStream oos = new ObjectOutputStream(fos);

oos.writeObject(e1);

oos.writeObject(e2);

oos.writeObject(e3);

oos.close();

FileInputStream fis = new FileInputStream(" employee.txt ");

ObjectInputStream ois = new ObjectInputStream(fis);

Employee e;

for (int i = 0; i < 3; i++)

{

e = (Employee) ois.readObject();

System.out.println(e.name + " : " + e.age + " : " + e.salary);

}

class Employee implements Serializable

{

String name;

int age;

double salary;

transient Thread t = new Thread();

public Employee(String name, int age, double salary)

{

this.name = name;

this.age = age;

this.salary = salary;

}

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

{

oos.writeInt(age);

oos.writeUTF(name);

System.out.println(" Write Object ");

}

private void readObject(java.io.ObjectInputStream ois) throws IOException

{

age = ois.readInt();

name = ois.readUTF();

System.out.println(" Read Object ");

}

对象的串行化（Serialization）

一、串行化的概念和目的

1.什么是串行化

            对象的寿命通常随着生成该对象的程序的终止而终止。有时候，可能需要将对象的状态保存下来，在需要时再将对象恢复。我们把对象的这种能记录自己的状态以便将来再生的能力。叫作对象的持续性(persistence)。对象通过写出描述自己状态的数值来记录自己，这个过程叫对象的串行化(Serialization) 。串行化的主要任务是写出对象实例变量的数值。如果交量是另一对象的引用，则引用的对象也要串行化。这个过程是递归的，串行化可能要涉及一个复杂树结构的单行化，包括原有对象、对象的对象、对象的对象的对象等等。对象所有权的层次结构称为图表(graph)。

2.串行化的目的

            Java对象的单行化的目标是为Java的运行环境提供一组特性，如下所示：

1)       尽量保持对象串行化的简单扼要，但要提供一种途径使其可根据开发者的要求进行扩展或定制。

2)       串行化机制应严格遵守Java的对象模型。对象的串行化状态中应该存有所有的关于种类的安全特性的信息。

3)       对象的串行化机制应支持Java的对象持续性。

4)       对象的串行化机制应有足够的可扩展能力以支持对象的远程方法调用(RMI)。

5)       对象串行化应允许对象定义自身的格式即其自身的数据流表示形式，可外部化接口来完成这项功能。

二、串行化方法
            从JDK1.1开始，Java语言提供了对象串行化机制，在java.io包中，接口Serialization用来作为实现对象串行化的工具，只有实现了Serialization的类的对象才可以被串行化。

            Serializable接口中没有任何的方法。当一个类声明要实现Serializable接口时，只是表明该类参加串行化协议，而不需要实现任何特殊的方法。下面我们通过实例介绍如何对对象进行串行化。

1.定义一个可串行化对象

            一个类，如果要使其对象可以被串行化，必须实现Serializable接口。我们定义一个类Student如下：

 
  import java.io.Serializable;   
  
public class Student implements Serializable {   
  
    int id;// 学号   
  
    String name;// 姓名   
  
    int age;// 年龄   
  
    String department; // 系别   
  
    public Student(int id, String name, int age, String department) {   
  
        this.id = id;   
  
        this.name = name;   
  
        this.age = age;   
  
        this.department = department;   
  
    }   
  
}

2.构造对象的输入／输出流

要串行化一个对象，必须与一定的对象输出／输入流联系起来，通过对象输出流将对象状态保存下来，再通过对象输入流将对象状态恢复。

java.io包中，提供了ObjectInputStream和ObjectOutputStream将数据流功能扩展至可读写对象。在ObjectInputStream 中用readObject()方法可以直接读取一个对象，ObjectOutputStream中用writeObject()方法可以直接将对象保存到输出流中。

 
  import java.io.FileInputStream;   
import java.io.FileOutputStream;   
import java.io.IOException;   
import java.io.ObjectInputStream;   
import java.io.ObjectOutputStream;   
  
public class ObjectSer {   
  
    public static void main(String args[]) throws IOException,   
            ClassNotFoundException {   
  
        Student stu = new Student(981036, "LiuMing", 18, "CSD");   
  
        FileOutputStream fo = new FileOutputStream("data.ser");   
  
        ObjectOutputStream so = new ObjectOutputStream(fo);   
  
        try {   
  
            so.writeObject(stu);   
  
            so.close();   
  
        } catch (IOException e) {   
            System.out.println(e);   
        }   
  
        stu = null;   
  
        FileInputStream fi = new FileInputStream("data.ser");   
  
        ObjectInputStream si = new ObjectInputStream(fi);   
  
        try {   
  
            stu = (Student) si.readObject();   
  
            si.close();   
  
        } catch (IOException e)   
  
        {   
            System.out.println(e);   
        }   
  
        System.out.println("Student Info:");   
  
        System.out.println("ID:" + stu.id);   
  
        System.out.println("Name:" + stu.name);   
  
        System.out.println("Age:" + stu.age);   
  
        System.out.println("Dep:" + stu.department);   
  
    }   
  
}

运行结果如下：

Student Info:

　　ID:981036

　　Name:LiuMing

　　Age:18

　　Dep:CSD

            在这个例子中，我们首先定义了一个类Student，实现了Serializable接口，然后通过对象输出流的writeObject()方法将Student对象保存到文件 data.ser中。之后，通过对家输入流的readObjcet()方法从文件data.ser中读出保存下来的Student对象。从运行结果可以看到，通过串行化机制，可以正确地保存和恢复对象的状态。

三、串行化的注意事项
1.串行化能保存的元素

            串行化只能保存对象的非静态成员交量，不能保存任何的成员方法和静态的成员变量，而且串行化保存的只是变量的值，对于变量的任何修饰符都不能保存。

2.transient关键字

            对于某些类型的对象，其状态是瞬时的，这样的对象是无法保存其状态的。例如一个Thread对象或一个FileInputStream对象，对于这些字段，我们必须用transient关键字标明，否则编译器将报措。

            另外，串行化可能涉及将对象存放到磁盘上或在网络上发达数据，这时候就会产生安全问题。因为数据位于Java运行环境之外，不在Java安全机制的控制之中。对于这些需要保密的字段，不应保存在永久介质中，或者不应简单地不加处理地保存下来，为了保证安全性。应该在这些字段前加上transient关键字。

下面是java规范中对transient关键字的解释：
The transient marker is not fully specified by The Java Language Specification but is used in object serialization to mark member variables that should not be serialized.

以下是transient的一个应用举例:

//LoggingInfo.java
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Date;a
public class LoggingInfo implements java.io.Serializable {
private static final long serialVersionUID = 1L;
private Date loggingDate = new Date();
private String uid;
private transient String pwd;
LoggingInfo(String user, String password) {
uid = user;
pwd = password;
}
public String toString() {
String password = null;
if (pwd == null) {
password = "NOT SET";
} else {
password = pwd;
}
return "logon info: \n " + "user: " + uid + "\n logging date : "
+ loggingDate.toString() + "\n password: " + password;
}
public static void main(String[] args) {
LoggingInfo logInfo = new LoggingInfo("MIKE", "MECHANICS");
System.out.println(logInfo.toString());
try {
ObjectOutputStream o = new ObjectOutputStream(new FileOutputStream(
"logInfo.out"));
o.writeObject(logInfo);
o.close();
} catch (Exception e) {// deal with exception
}
// To read the object back, we can write
try {
ObjectInputStream in = new ObjectInputStream(new FileInputStream(
"logInfo.out"));
LoggingInfo logInfo1 = (LoggingInfo) in.readObject();
System.out.println(logInfo1.toString());
} catch (Exception e) {// deal with exception
}
}
}