JavaIO<4>--Serializable和Externalizable序列化总结
JavaIO<4>--Serializable和Externalizable序列化总结
Zhao-Qian 发表于3年前
JavaIO<4>--Serializable和Externalizable序列化总结
  • 发表于 3年前
  • 阅读 26
  • 收藏 0
  • 点赞 0
  • 评论 0

腾讯云 新注册用户 域名抢购1元起>>>   

摘要: 我们对序列化进行深入的学习和探讨。学习内容,包括序列化的作用、用途、用法,以及对实现序列化的2种方式Serializable和Externalizable的深入研究。

1. 序列化是的作用和用途

序列化,就是为了保存对象的状态;而与之对应的反序列化,则可以把保存的对象状态再读出来
简言之:序列化/反序列化,是Java提供一种专门用于的保存/恢复对象状态的机制。

一般在以下几种情况下,我们可能会用到序列化:
a)当你想把的内存中的对象状态保存到一个文件中或者数据库中时候; 
b)当你想用套接字在网络上传送对象的时候; 
c)当你想通过RMI传输对象的时候。

2.类序列化演示程序

package org.credo.jdk.io.serial;

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

public class SerialTest1
{

	public static void main(String[] args)
	{
		testWrite();
		testRead();
	}
	
	private static final String TMP_FILE = "serialtest1.txt"; 
	
	public static void testWrite() {
		try
		{
			ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream(TMP_FILE));
			Box box=new Box("AAA", 180, 180);
			oos.writeObject(box);
			System.out.println("testWrite box: " + box); 
			oos.close();
		} catch (FileNotFoundException e)
		{
			e.printStackTrace();
		} catch (IOException e)
		{
			e.printStackTrace();
		}
	}
	
	public static void testRead() {
		try
		{
			ObjectInputStream ois=new ObjectInputStream(new FileInputStream(TMP_FILE));
			Box box=(Box) ois.readObject();
			System.out.println("read box:"+box);
			ois.close();
		} catch (IOException e)
		{
			e.printStackTrace();
		} catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}
	}

}
/**  
 * Box类“支持序列化”。因为Box实现了Serializable接口。  
 *  
 * 实际上,一个类只需要实现Serializable即可实现序列化,而不需要实现任何函数。  
 */ 
class Box implements Serializable {  
	
	private static final long serialVersionUID = -6722457644709778968L;
	
	private int width;     
    private int height;   
    private String name;     
 
    public Box(String name, int width, int height) {  
        this.name = name;  
        this.width = width;  
        this.height = height;  
    }  
 
    @Override 
    public String toString() {  
        return "["+name+": ("+width+", "+height+") ]";  
    }  
}

运行结果

testWrite box: [desk: (80, 48) ]
testRead box: [desk: (80, 48) ]

去掉Box内部类的implements Serializable.则报错:

java.io.NotSerializableException: org.credo.jdk.io.serial.Box
	at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1180)
	at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:346)
	at org.credo.jdk.io.serial.SerialTest1.testWrite(SerialTest1.java:27)
	at org.credo.jdk.io.serial.SerialTest1.main(SerialTest1.java:16)
java.io.WriteAbortedException: writing aborted; java.io.NotSerializableException: org.credo.jdk.io.serial.Box
	at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1352)
	at java.io.ObjectInputStream.readObject(ObjectInputStream.java:370)
	at org.credo.jdk.io.serial.SerialTest1.testRead(SerialTest1.java:43)
	at org.credo.jdk.io.serial.SerialTest1.main(SerialTest1.java:17)
Caused by: java.io.NotSerializableException: org.credo.jdk.io.serial.Box
	at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1180)
	at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:346)
	at org.credo.jdk.io.serial.SerialTest1.testWrite(SerialTest1.java:27)
	at org.credo.jdk.io.serial.SerialTest1.main(SerialTest1.java:16)

源码说明

(01) 程序的作用很简单,就是演示:先将Box对象,通过对象输出流保存到文件中;之后,再通过对象输入流,将文件中保存的Box对象读取出来。

(02) Box类说明。Box是我们自定义的演示类,它被用于序列化的读写。Box实现了Serialable接口,因此它支持序列化操作;即,Box支持通过ObjectOutputStream去写入到输出流中,并且支持通过ObjectInputStream从输入流中读取出来。

(03) testWrite()函数说明。testWrite()的作用就是,新建一个Box对象,然后将该Box对象写入到文件中。
       首先,新建文件TMP_FILE的文件输出流对象(即FileOutputStream对象),再创建该文件输出流的对象输出流(即ObjectOutputStream对象)。
       a) 关于FileInputStream和FileOutputStream的内容,可以参考后面的相关文章。
       b) 关于ObjectInputStream和ObjectOutputStream的的更多知识,可参考上一章.

       然后,新建Box对象。
       最后,通过out.writeObject(box) 将box写入到对象输出流中。实际上,相当于将box写入到文件TMP_FILE中。

(04) testRead()函数说明。testRead()的作用就是,从文件中读出Box对象。
       首先,新建文件TMP_FILE的文件输入流对象(即FileInputStream对象),再创建该文件输入流的对象输入流(即ObjectInputStream对象)。
       然后,通过in.readObject() 从对象输入流中读取出Box对象。实际上,相当于从文件TMP_FILE中读取Box对象。

通过上面的示例,我们知道:我们可以自定义类,让它支持序列化(即实现Serializable接口),从而能支持对象的保存/恢复。
若要支持序列化,除了“自定义实现Serializable接口的类”之外;java的“基本类型”和“java自带的实现了Serializable接口的类”,都支持序列化。我们通过下面的示例去查看一下。

3. 基本类型演示程序

package org.credo.jdk.io.serial;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class SerialTest2
{

	private static final String TMP_FILE = ".serialabletest2.txt";

	public static void main(String[] args)
	{
		testWrite();
		testRead();
	}

	/**
	 * ObjectOutputStream 测试函数
	 */
	@SuppressWarnings({ "rawtypes", "unchecked" })
	private static void testWrite()
	{
		try
		{
			ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(TMP_FILE));
			out.writeBoolean(true); // 写入Boolean值
			out.writeByte((byte) 65);// 写入Byte值
			out.writeChar('a'); // 写入Char值
			out.writeInt(20131015); // 写入Int值
			out.writeFloat(3.14F); // 写入Float值
			out.writeDouble(1.414D);// 写入Double值
			// 写入HashMap对象
			HashMap map = new HashMap();
			map.put("one", "red");
			map.put("two", "green");
			map.put("three", "blue");
			out.writeObject(map);

			out.close();
		} catch (Exception ex)
		{
			ex.printStackTrace();
		}
	}

	/**
	 * ObjectInputStream 测试函数
	 */
	@SuppressWarnings("rawtypes")
	private static void testRead()
	{
		try
		{
			ObjectInputStream in = new ObjectInputStream(new FileInputStream(TMP_FILE));
			System.out.printf("boolean:%b\n", in.readBoolean());
			System.out.printf("byte:%d\n", (in.readByte() & 0xff));
			System.out.printf("char:%c\n", in.readChar());
			System.out.printf("int:%d\n", in.readInt());
			System.out.printf("float:%f\n", in.readFloat());
			System.out.printf("double:%f\n", in.readDouble());
			// 读取HashMap对象
			HashMap map = (HashMap) in.readObject();
			Iterator iter = map.entrySet().iterator();
			while (iter.hasNext())
			{
				Map.Entry entry = (Map.Entry) iter.next();
				System.out.printf("%-6s -- %s\n", entry.getKey(), entry.getValue());
			}

			in.close();
		} catch (Exception e)
		{
			e.printStackTrace();
		}
	}
}
输入:
boolean:true
byte:65
char:a
int:20131015
float:3.140000
double:1.414000
three  -- blue
two    -- green
one    -- red

源码说明

(01) 程序的作用很简单,就是演示:先将“基本类型数据”和“HashMap对象”,通过对象输出流保存到文件中;之后,再通过对象输入流,将这些保存的数据读取出来。

(02) testWrite()函数说明。testWrite()的作用就是,先将“基本类型数据”和“HashMap对象”,通过对象输出流保存到文件中。
       首先,新建文件TMP_FILE的文件输出流对象(即FileOutputStream对象),再创建该文件输出流的对象输出流(即ObjectOutputStream对象)。
       然后,通过 writeBoolean(), writeByte(), ... , writeDouble() 等一系列函数将“Boolean, byte, char, ... , double等基本数据类型”写入到对象输出流中。实际上,相当于将这些内容写入到文件TMP_FILE中。
      最后,新建HashMap对象map,并通过out.writeObject(map) 将map写入到对象输出流中。实际上,相当于map写入到文件TMP_FILE中。

(03) testRead()函数说明。testRead()的作用就是,从文件中读出testWrite()写入的对象。
       首先,新建文件TMP_FILE的文件输入流对象(即FileInputStream对象),再创建该文件输入流的对象输入流(即ObjectInputStream对象)。
       然后,通过in.readObject() 从对象输入流中读取出testWrite()对象。实际上,相当于从文件TMP_FILE中读取出这些对象。

在前面,我们提到过:若要支持序列化,除了“自定义实现Serializable接口的类”之外;java的“基本类型”和“java自带的实现了Serializable接口的类”,都支持序列化。为了验证这句话,我们看看HashMap是否实现了Serializable接口。
HashMap是java.util包中定义的类,它的接口声明如下:

public class HashMap<K,V> extends AbstractMap<K,V>  
    implements Map<K,V>, Cloneable, Serializable {}

至此,我们对序列化的认识已经比较深入了:即知道了“序列化的作用和用法”,也知道了“基本类型”、“java自带的支持Serializable接口的类”和“自定义实现Serializable接口的类”都能支持序列化。

应付序列化的简单使用应该足够了。但是,我们的目的是对序列化有更深层次的了解!更何况,写此文的作者(也就是区区在下),应该比各位看官要累(既要写代码,又要总结,还得注意排版和用词,讲的通俗易懂,让各位看得轻松自在);我这个菜鸟都能做到这些,何况对知识极其渴望的您呢?所以,请深吸一口气,然后继续……

我们在介绍序列化定义时,说过“序列化/反序列化,是专门用于的保存/恢复对象状态的机制”。
从中,我们知道:序列化/反序列化,只支持保存/恢复对象状态,即仅支持保存/恢复类的成员变量,但不支持保存类的成员方法!
但是,序列化是不是对类的所有的成员变量的状态都能保存呢?
答案当然是否定的
(01) 序列化对static和transient变量,是不会自动进行状态保存的。
        transient的作用就是,用transient声明的变量,不会被自动序列化。
(02) 对于Socket, Thread类,不支持序列化。若实现序列化的接口中,有Thread成员;在对该类进行序列化操作时,编译会出错!
        这主要是基于资源分配方面的原因。如果Socket,Thread类可以被序列化,但是被反序列化之后也无法对他们进行重新的资源分配;再者,也是没有必要这样实现。

下面,我们还是通过示例来查看“序列化对static和transient的处理”。

4. static和transient演示程序

package org.credo.jdk.io.serial;

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

import org.apache.commons.lang.builder.ToStringBuilder;

public class SerialTest3
{
	private static final String TMP_FILE = ".serialtest3.txt";

	public static void main(String[] args)
	{
		testWrite();
		testRead();
	}

	/**
	 * 将Box对象通过序列化,保存到文件中
	 */
	private static void testWrite()
	{
		try
		{
			// 获取文件TMP_FILE对应的对象输出流。
			// ObjectOutputStream中,只能写入“基本数据”或“支持序列化的对象”
			ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(TMP_FILE));
			// 创建Box对象,Box实现了Serializable序列化接口
			Box2 box = new Box2("desk", 80, 48);
			// 将box对象写入到对象输出流out中,即相当于将对象保存到文件TMP_FILE中
			out.writeObject(box);
			// 打印“Box对象”
			System.out.println("testWrite box: " + box);

			out.close();
		} catch (Exception ex)
		{
			ex.printStackTrace();
		}
	}

	/**
	 * 从文件中读取出“序列化的Box对象”
	 */
	private static void testRead()
	{
		try
		{
			// 获取文件TMP_FILE对应的对象输入流。
			ObjectInputStream in = new ObjectInputStream(new FileInputStream(TMP_FILE));
			// 从对象输入流中,读取先前保存的box对象。
			Box2 box = (Box2) in.readObject();
			// 打印“Box对象”
			System.out.println("testRead  box2: " + box);
			in.close();
		} catch (Exception e)
		{
			e.printStackTrace();
		}
	}
}

class Box2 implements Serializable
{
	private static final long serialVersionUID = 1L;
	private static int width;
	private transient int height;
	private String name;

	public Box2(String name, int width, int height)
	{
		this.name = name;
		this.width = width;
		this.height = height;
	}

	@Override
	public String toString()
	{
		 return "["+name+": ("+width+", "+height+") ]";
	}
}
输出:
testWrite box: [desk: (80, 48) ]
testRead  box2: [desk: (80, 0) ]

SerialTest3.java 相比于 SerialTest1.java。仅仅对Box类中的 width 和 height 变量的定义进行了修改。
SerialTest1.java 中width和height定义
private int width;     
private int height;  
SerialTest3.java 中width和height定义
private static int width;   
private transient int height;  

transient(短暂的):java语言的关键字,变量修饰符,如果用transient声明一个实例变量,当对象存储时,它的值不需要维持。Java的serialization提供了一种持久化对象实例的机制。当持久化对象时,可能有一个特殊的对象数据成员,我们不想用serialization机制来保存它。为了在一个特定对象的一个域上关闭serialization,可以在这个域前加上关键字transient。当一个对象被序列化的时候,transient型变量的值不包括在序列化的表示中.

结果分析

我们前面说过,“序列化不对static和transient变量进行状态保存”。因此,testWrite()中保存Box对象时,不会保存width和height的值。这点是毋庸置疑的!但是,为什么testRead()中读取出来的Box对象的width=80,而height=0呢?
先说,为什么height=0。因为Box对象中height是int类型,而int类型的默认值是0。
再说,为什么width=80。这是因为height是static类型,而static类型就意味着所有的Box对象都共用一个height值;而在testWrite()中,我们已经将height初始化为80了。因此,我们通过序列化读取出来的Box对象的height值,也被就是80。

5. static和transient演示程序2

public class SerialTest4 {   
    private static final String TMP_FILE = ".serialtest4.txt";  
    
    public static void main(String[] args) {     
        // 将“对象”通过序列化保存  
        testWrite();  
        // 将序列化的“对象”读出来  
        testRead();  
    }  
    
 
    /**  
     * 将Box对象通过序列化,保存到文件中  
     */ 
    private static void testWrite() {     
        try {  
            // 获取文件TMP_FILE对应的对象输出流。  
            // ObjectOutputStream中,只能写入“基本数据”或“支持序列化的对象”  
            ObjectOutputStream out = new ObjectOutputStream(  
                    new FileOutputStream(TMP_FILE));  
            // 创建Box对象,Box实现了Serializable序列化接口  
            Box box = new Box("desk", 80, 48);  
            // 将box对象写入到对象输出流out中,即相当于将对象保存到文件TMP_FILE中  
            out.writeObject(box);  
            // 打印“Box对象”  
            System.out.println("testWrite box: " + box);  
            // 修改box的值  
            box = new Box("room", 100, 50);  
 
            out.close();  
        } catch (Exception ex) {  
            ex.printStackTrace();  
        }  
    }  
   
    /**  
     * 从文件中读取出“序列化的Box对象”  
     */ 
    private static void testRead() {  
        try {  
            // 获取文件TMP_FILE对应的对象输入流。  
            ObjectInputStream in = new ObjectInputStream(  
                    new FileInputStream(TMP_FILE));  
            // 从对象输入流中,读取先前保存的box对象。  
            Box box = (Box) in.readObject();  
            // 打印“Box对象”  
            System.out.println("testRead  box: " + box);  
            in.close();  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
}  
 
 
/**  
 * Box类“支持序列化”。因为Box实现了Serializable接口。  
 *  
 * 实际上,一个类只需要实现Serializable即可实现序列化,而不需要实现任何函数。  
 */ 
class Box implements Serializable {  
    private static int width;     
    private transient int height;   
    private String name;     
 
    public Box(String name, int width, int height) {  
        this.name = name;  
        this.width = width;  
        this.height = height;  
    }  
 
    @Override 
    public String toString() {  
        return "["+name+": ("+width+", "+height+") ]";  
    }  
}
SerialTest4.java 相比于 SerialTest3.java,在testWrite()中添加了一行代码 box = new Box("room", 100, 50);
运行结果:
testWrite box: [desk: (80, 48) ]  
testRead  box: [desk: (100, 0) ]
现在,我们更加确认“序列化不对static和transient变量进行状态保存”。但是,若我们想要保存static或transient变量,能不能办到呢?
当然可以!我们在类中重写两个方法writeObject()和readObject()即可。

6. 保存static和transient演示程序

我们对前面的SerialTest4.java进行简单修改,以达到:序列化存储static和transient变量的目的。
package org.credo.jdk.io.serial;

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

public class SerialTest5
{
	private static final String TMP_FILE = ".serialtest5.txt";

	public static void main(String[] args)
	{
		testWrite();
		testRead();
	}

	/**
	 * 将Box对象通过序列化,保存到文件中
	 */
	private static void testWrite()
	{
		try
		{
			// 获取文件TMP_FILE对应的对象输出流。
			// ObjectOutputStream中,只能写入“基本数据”或“支持序列化的对象”
			ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(TMP_FILE));
			// 创建Box对象,Box实现了Serializable序列化接口
			Box5 box = new Box5("desk", 80, 48);
			// 将box对象写入到对象输出流out中,即相当于将对象保存到文件TMP_FILE中
			out.writeObject(box);
			// 打印“Box对象”
			System.out.println("testWrite box: " + box);
			// 修改box的值
			box = new Box5("room", 100, 50);

			out.close();
		} catch (Exception ex)
		{
			ex.printStackTrace();
		}
	}

	/**
	 * 从文件中读取出“序列化的Box对象”
	 */
	private static void testRead()
	{
		try
		{
			// 获取文件TMP_FILE对应的对象输入流。
			ObjectInputStream in = new ObjectInputStream(new FileInputStream(TMP_FILE));
			// 从对象输入流中,读取先前保存的box对象。
			Box5 box = (Box5) in.readObject();
			// 打印“Box对象”
			System.out.println("testRead  box5: " + box);
			in.close();
		} catch (Exception e)
		{
			e.printStackTrace();
		}
	}
}

/**
 * Box类“支持序列化”。因为Box实现了Serializable接口。
 * 实际上,一个类只需要实现Serializable即可实现序列化,而不需要实现任何函数。
 */
class Box5 implements Serializable
{
	private static final long serialVersionUID = 1L;
	private static int width;
	private transient int height;
	private String name;

	public Box5(String name, int width, int height)
	{
		this.name = name;
		this.width = width;
		this.height = height;
	}

	private void writeObject(ObjectOutputStream oos) throws IOException
	{
		// 使定制的writeObject()方法可以利用自动序列化中内置的逻辑。
		oos.defaultWriteObject();
		oos.writeInt(width);
		oos.writeInt(height);
	}

	private void readObject(ObjectInputStream ois) throws ClassNotFoundException, IOException
	{
		// defaultReadObject()补充自动序列化
		ois.defaultReadObject();
		width = ois.readInt();
		height = ois.readInt();
	}

	@Override
	public String toString()
	{
		return "[" + name + ": (" + width + ", " + height + ") ]";
	}
}
输出

testWrite box: [desk: (80, 48) ]
testRead  box5: [desk: (80, 48) ]

程序说明:
“序列化不会自动保存static和transient变量”,因此我们若要保存它们,则需要通过writeObject()和readObject()去手动读写。
(01) 通过writeObject()方法,写入要保存的变量。writeObject的原始定义是在ObjectOutputStream.java中,我们按照如下示例覆盖即可:
private void writeObject(ObjectOutputStream out) throws IOException{   
    out.defaultWriteObject();// 使定制的writeObject()方法可以利用自动序列化中内置的逻辑。   
    out.writeInt(ival);      // 若要保存“int类型的值”,则使用writeInt()  
    out.writeObject(obj);    // 若要保存“Object对象”,则使用writeObject()  
}  
(02) 通过readObject()方法,读取之前保存的变量。readObject的原始定义是在ObjectInputStream.java中,我们按照如下示例覆盖即可:
private void readObject(ObjectInputStream in) throws IOException,ClassNotFoundException{   
    in.defaultReadObject();       // 使定制的readObject()方法可以利用自动序列化中内置的逻辑。   
    int ival = in.readInt();      // 若要读取“int类型的值”,则使用readInt()  
    Object obj = in.readObject(); // 若要读取“Object对象”,则使用readObject()  
}  
至此,我们就介绍完了“序列化对static和transient变量的处理”。
接下来,我们来研究“对于Socket, Thread类,不支持序列化”。还是通过示例来查看。

7. 对于Socket, Thread类,不支持序列化

我们修改SerialTest5.java的源码,在Box类中添加一个Thread成员。
package org.credo.jdk.io.serial;

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

public class SerialTest5
{
	private static final String TMP_FILE = ".serialtest5.txt";

	public static void main(String[] args)
	{
		testWrite();
		testRead();
	}

	/**
	 * 将Box对象通过序列化,保存到文件中
	 */
	private static void testWrite()
	{
		try
		{
			// 获取文件TMP_FILE对应的对象输出流。
			// ObjectOutputStream中,只能写入“基本数据”或“支持序列化的对象”
			ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(TMP_FILE));
			// 创建Box对象,Box实现了Serializable序列化接口
			Box5 box = new Box5("desk", 80, 48);
			// 将box对象写入到对象输出流out中,即相当于将对象保存到文件TMP_FILE中
			out.writeObject(box);
			// 打印“Box对象”
			System.out.println("testWrite box: " + box);
			// 修改box的值
			box = new Box5("room", 100, 50);

			out.close();
		} catch (Exception ex)
		{
			ex.printStackTrace();
		}
	}

	/**
	 * 从文件中读取出“序列化的Box对象”
	 */
	private static void testRead()
	{
		try
		{
			// 获取文件TMP_FILE对应的对象输入流。
			ObjectInputStream in = new ObjectInputStream(new FileInputStream(TMP_FILE));
			// 从对象输入流中,读取先前保存的box对象。
			Box5 box = (Box5) in.readObject();
			// 打印“Box对象”
			System.out.println("testRead  box5: " + box);
			in.close();
		} catch (Exception e)
		{
			e.printStackTrace();
		}
	}
}

/**
 * Box类“支持序列化”。因为Box实现了Serializable接口。
 * 实际上,一个类只需要实现Serializable即可实现序列化,而不需要实现任何函数。
 */
class Box5 implements Serializable
{
	private static final long serialVersionUID = 1L;
	private static int width;
	private transient int height;
	private String name;
	
	private Thread thread = new Thread() {  
        @Override 
        public void run() {  
            System.out.println("Serializable thread");  
        }  
    }; 

	public Box5(String name, int width, int height)
	{
		this.name = name;
		this.width = width;
		this.height = height;
	}

	private void writeObject(ObjectOutputStream oos) throws IOException
	{
		// 使定制的writeObject()方法可以利用自动序列化中内置的逻辑。
		oos.defaultWriteObject();
		oos.writeInt(width);
		oos.writeInt(height);
	}

	private void readObject(ObjectInputStream ois) throws ClassNotFoundException, IOException
	{
		// defaultReadObject()补充自动序列化
		ois.defaultReadObject();
		width = ois.readInt();
		height = ois.readInt();
	}

	@Override
	public String toString()
	{
		return "[" + name + ": (" + width + ", " + height + ") ]";
	}
}
结果是,编译出错!
事实证明,不能对Thread进行序列化。若希望程序能编译通过,我们对Thread变量添加static或transient修饰即可!如下,是对Thread添加transient修饰的源码
private static final String TMP_FILE = ".serialtest7.txt";  
    
    public static void main(String[] args) {     
        // 将“对象”通过序列化保存  
        testWrite();  
        // 将序列化的“对象”读出来  
        testRead();  
    }  
    
 
    /**  
     * 将Box对象通过序列化,保存到文件中  
     */ 
    private static void testWrite() {     
        try {  
            // 获取文件TMP_FILE对应的对象输出流。  
            // ObjectOutputStream中,只能写入“基本数据”或“支持序列化的对象”  
            ObjectOutputStream out = new ObjectOutputStream(  
                    new FileOutputStream(TMP_FILE));  
            // 创建Box对象,Box实现了Serializable序列化接口  
            Box box = new Box("desk", 80, 48);  
            // 将box对象写入到对象输出流out中,即相当于将对象保存到文件TMP_FILE中  
            out.writeObject(box);  
            // 打印“Box对象”  
            System.out.println("testWrite box: " + box);  
            // 修改box的值  
            box = new Box("room", 100, 50);  
 
            out.close();  
        } catch (Exception ex) {  
            ex.printStackTrace();  
        }  
    }  
   
    /**  
     * 从文件中读取出“序列化的Box对象”  
     */ 
    private static void testRead() {  
        try {  
            // 获取文件TMP_FILE对应的对象输入流。  
            ObjectInputStream in = new ObjectInputStream(  
                    new FileInputStream(TMP_FILE));  
            // 从对象输入流中,读取先前保存的box对象。  
            Box box = (Box) in.readObject();  
            // 打印“Box对象”  
            System.out.println("testRead  box: " + box);  
            in.close();  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
}  
 
 
/**  
 * Box类“支持序列化”。因为Box实现了Serializable接口。  
 *  
 * 实际上,一个类只需要实现Serializable即可实现序列化,而不需要实现任何函数。  
 */ 
class Box implements Serializable {  
    private static int width;     
    private transient int height;   
    private String name;     
    private transient Thread thread = new Thread() {  
        @Override 
        public void run() {  
            System.out.println("Serializable thread");  
        }  
    };  
 
    public Box(String name, int width, int height) {  
        this.name = name;  
        this.width = width;  
        this.height = height;  
    }  
 
    private void writeObject(ObjectOutputStream out) throws IOException{   
        out.defaultWriteObject();//使定制的writeObject()方法可以利用自动序列化中内置的逻辑。   
        out.writeInt(height);   
        out.writeInt(width);   
        //System.out.println("Box--writeObject width="+width+", height="+height);  
    }  
 
    private void readObject(ObjectInputStream in) throws IOException,ClassNotFoundException{   
        in.defaultReadObject();//defaultReadObject()补充自动序列化   
        height = in.readInt();   
        width = in.readInt();   
        //System.out.println("Box---readObject width="+width+", height="+height);  
    }  
 
    @Override 
    public String toString() {  
        return "["+name+": ("+width+", "+height+") ]";  
    }  
}
至此,关于“Serializable接口”来实现序列化的内容,都说完了。为什么这么说?因为,实现序列化,除了Serializable之外,还有其它的方式,就是通过实现Externalizable来实现序列化。整理下心情,下面继续对Externalizable进行了解。

8. Externalizable和完全定制序列化过程

如果一个类要完全负责自己的序列化,则实现Externalizable接口,而不是Serializable接口。

Externalizable接口定义包括两个方法writeExternal()与readExternal()。需要注意的是:声明类实现Externalizable接口会有重大的安全风险。writeExternal()与readExternal()方法声明为public,恶意类可以用这些方法读取和写入对象数据。如果对象包含敏感信息,则要格外小心。


package org.credo.jdk.io.serial;

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;

public class ExternalizableTest1
{
	private static final String TMP_FILE = ".externalizabletest1.txt";

	public static void main(String[] args)
	{
		// 将“对象”通过序列化保存
		testWrite();
		// 将序列化的“对象”读出来
		testRead();
	}

	public static void testWrite()
	{
		//略
	}

	public static void testRead()
	{
		//略
	}
}

class Box implements Externalizable
{
	private int width;
	private int height;
	private String name;

	public Box()
	{
	}

	public Box(String name, int width, int height)
	{
		this.name = name;
		this.width = width;
		this.height = height;
	}

	@Override
	public void writeExternal(ObjectOutput out) throws IOException
	{
		
	}

	@Override
	public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
	{
		
	}
	
	 @Override 
	    public String toString() {  
	        return "["+name+": ("+width+", "+height+") ]";  
	    }  

}
运行结果:
testWrite box: [desk: (80, 48) ]  
testRead  box: [null: (0, 0) ] 
说明:
(01) 实现Externalizable接口的类,不会像实现Serializable接口那样,会自动将数据保存。
(02) 实现Externalizable接口的类,必须实现writeExternal()和readExternal()接口!
否则,程序无法正常编译!
(03) 实现Externalizable接口的类,必须定义不带参数的构造函数!
否则,程序无法正常编译!
(04) writeExternal() 和 readExternal() 的方法都是public的,不是非常安全!


接着,我们修改上面的ExternalizableTest1.java测试程序;实现Box类中的writeExternal()和readExternal()接口!
修改后的源码如下
package org.credo.jdk.io.serial;

import java.io.Externalizable;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;

public class ExternalizableTest1
{
	private static final String TMP_FILE = ".externalizabletest1.txt";

	public static void main(String[] args)
	{
		// 将“对象”通过序列化保存
		testWrite();
		// 将序列化的“对象”读出来
		testRead();
	}

	public static void testWrite()
	{
		try
		{
			// 获取文件TMP_FILE对应的对象输出流。
			// ObjectOutputStream中,只能写入“基本数据”或“支持序列化的对象”
			ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(TMP_FILE));
			// 创建Box对象
			BoxA box = new BoxA("desk", 80, 48);
			// 将box对象写入到对象输出流out中,即相当于将对象保存到文件TMP_FILE中
			out.writeObject(box);
			// 打印“Box对象”
			System.out.println("testWrite box: " + box);

			out.close();
		} catch (Exception ex)
		{
			ex.printStackTrace();
		}
	}

	public static void testRead()
	{
		try
		{
			// 获取文件TMP_FILE对应的对象输入流。
			ObjectInputStream in = new ObjectInputStream(new FileInputStream(TMP_FILE));
			// 从对象输入流中,读取先前保存的box对象。
			BoxA box = (BoxA) in.readObject();
			// 打印“Box对象”
			System.out.println("testRead  box: " + box);
			in.close();
		} catch (Exception e)
		{
			e.printStackTrace();
		}
	}
}

class BoxA implements Externalizable
{
	private int width;
	private int height;
	private String name;

	public BoxA()
	{
	}

	public BoxA(String name, int width, int height)
	{
		this.name = name;
		this.width = width;
		this.height = height;
	}

	@Override
	public void writeExternal(ObjectOutput out) throws IOException
	{
		out.writeObject(name);
		out.writeInt(width);
		out.writeInt(height);
	}

	@Override
	public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
	{
		name=(String) in.readObject();
		width=in.readInt();
		height=in.readInt();
	}

	@Override
	public String toString()
	{
		return "[" + name + ": (" + width + ", " + height + ") ]";
	}

}
运行结果:
testWrite box: [desk: (80, 48) ]  
testRead  box: [desk: (80, 48) ]




共有 人打赏支持
粉丝 308
博文 156
码字总数 238058
×
Zhao-Qian
如果觉得我的文章对您有用,请随意打赏。您的支持将鼓励我继续创作!
* 金额(元)
¥1 ¥5 ¥10 ¥20 其他金额
打赏人
留言
* 支付类型
微信扫码支付
打赏金额:
已支付成功
打赏金额: