Java对象序列化
所有分布式应用常常需要跨平台,跨网络,因此要求所有传的签署,返回值都必须实现序列化。
定义:对象的序列化是指将一个Java对象写入IO流中,反序列化是指从IO流中恢复改Java对象。
实现:
实现如下两个接口之一的类才能被序列化:
(1)Serializable
(2)Externalizable
—序列化:ObjectOutputStream代表对象输出流,它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化,把得到的字节序列写道一个目标输出流中。
—反序列化:ObjectInputStream代表对象输入流,它的readObject()方法从一个源输出流中读取字节序列,再把他们反序列化为一个对象,并将其返回。
使用writeObject()和readObject()方法的对象必须已经被序列化。
一般序列化
示例:
要被序列化的对象:
public class Person implements Serializable {
private String name = null;
private Integer age = null;
public Person(){
System.out.println("无参构造");
}
public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
//getter setter方法省略...
@Override
public String toString() {
return "[" + name + ", " + age+"]";
}
}
如果有另一个类持有一个Person类的引用,只有Person类是可序列化的,这个类才是可序列化的
MySerilizable 是一个简单的序列化程序,它先将一个Person对象保存到文件person.txt中,然后再从该文件中读出被存储的Person对象,并打印该对象。
ublic class MySerilizable {
public static void main(String[] args) throws Exception {
File file = new File("person.txt");
//序列化持久化对象
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(file));
Person person = new Person("Peter", 27);
out.writeObject(person);
out.close();
//反序列化,并得到对象
ObjectInputStream in = new ObjectInputStream(new FileInputStream(file));
Object newPerson = in.readObject(); // 没有强制转换到Person类型,也可以强制转换到Person,这里主要是因为Person类里改写了toString方法才没有强制转换类型
in.close();
System.out.println(newPerson);
}
}
选择序列化
transient
当某个对象进行序列化时,系统会自动把该对象的所有实例变量依次进行序列化,如果某个实例变量引用到另一个对象,则被引用的对象也会被序列化;如果被引用的对象的实例变量也引用了其他对象,则被引用的对象也会被序列化,这种情况被称为递归序列化。
为了避免这些情况,特别是某些实例变量是敏感信息时,例如银行账户信息等。这时不希望系统将该实例变量进行序列化,该怎么办呢?
通过在实例变量面前使用transient关键字修饰,就可以指定Java序列化时无需理会该实例变量。
public class Person
implements java.io.Serializable
{
private String name;
private transient int age;
// 注意此处没有提供无参数的构造器!
public Person(String name , int age)
{
System.out.println("有参数的构造器");
this.name = name;
this.age = age;
}
// 省略name与age的setter和getter方法
// name的setter和getter方法
public void setName(String name)
{
this.name = name;
}
public String getName()
{
return this.name;
}
// age的setter和getter方法
public void setAge(int age)
{
this.age = age;
}
public int getAge()
{
return this.age;
}
}
对Person的age变量加了transient修饰符,便不会被序列化,因此下面程序中输出值为0
public class TransientTest
{
public static void main(String[] args)
{
try(
// 创建一个ObjectOutputStream输出流
ObjectOutputStream oos = new ObjectOutputStream(
new FileOutputStream("transient.txt"));
// 创建一个ObjectInputStream输入流
ObjectInputStream ois = new ObjectInputStream(
new FileInputStream("transient.txt")))
{
Person per = new Person("孙悟空", 500);
// 系统会per对象转换字节序列并输出
oos.writeObject(per);
Person p = (Person)ois.readObject();
System.out.println(p.getAge());
}
catch (Exception ex)
{
ex.printStackTrace();
}
}
}
writeObject()与readObject()方法
使用transient组织序列化虽然简单,但被她修饰的属性被完全隔离在序列化机制之外,导致了在反序列化时无法获得该属性的值,而通过在需要的序列化对象的Java类加入writeObject()与readObject()的方法可以控制如何序列化各属性,甚至不完全序列化某些属性。
例如:如果我们想要上面的Person类里的name属性在序列化后存在文件里不让别人知道具体是什么(加密),我们就可在Person类里加如下代码:
public class Person
implements java.io.Serializable
{
private String name;
private int age;
// 注意此处没有提供无参数的构造器!
public Person(String name , int age)
{
System.out.println("有参数的构造器");
this.name = name;
this.age = age;
}
// 省略name与age的setter和getter方法
// name的setter和getter方法
public void setName(String name)
{
this.name = name;
}
public String getName()
{
return this.name;
}
// age的setter和getter方法
public void setAge(int age)
{
this.age = age;
}
public int getAge()
{
return this.age;
}
private void writeObject(java.io.ObjectOutputStream out)
throws IOException
{
// 将name实例变量的值反转后写入二进制流
out.writeObject(new StringBuffer(name).reverse());
out.writeInt(age);
}
private void readObject(java.io.ObjectInputStream in)
throws IOException, ClassNotFoundException
{
// 将读取的字符串反转后赋给name实例变量
this.name = ((StringBuffer)in.readObject()).reverse()
.toString();
this.age = in.readInt();
}
}
Externalizable接口
Java还提供了另一种序列化机制,这种序列化方式完全由程序员决定存储和恢复对象的数据。要实现改目标,Java类必须实现Externalizable接口,该接口里定义了如下两个方法。
void readExternal(ObjectInput in):需要序列化的类实现readExternal()方法来实现反序列化。
void writeExternal(ObjectOutput out):需要序列化的类实现writeExternal()方法来保存对象的状态值。
下面程序中的Person实现了java.io.Externalizable接口,该Person类还实现了readExternal(),writeExternal()两个方法,这两个方法除了方法签名和readObject(),writeObject()两个方法的方法签名有所不同之外,其方法体完全一样。
需要注意的是实现Externalizable接口的类必须实现无参构造方法,否则反序列化会失败。
public class Teacher implements Externalizable{
private String name;
private Integer age;
public Teacher(){
System.out.println("无参构造");
}
public Teacher(String name,Integer age){
System.out.println("有参构造");
this.name = name;
this.age = age;
}
//setter、getter方法省略
@Override
public void writeExternal(ObjectOutput out) throws IOException {
out.writeObject(new StringBuffer(name).reverse()); //将name简单加密
//out.writeInt(age); //注掉这句后,age属性将不能被序化
}
@Override
public void readExternal(ObjectInput in) throws IOException,
ClassNotFoundException {
name = ((StringBuffer) in.readObject()).reverse().toString();
//age = in.readInt();
}
@Override
public String toString() {
return "[" + name + ", " + age+ "]";
}
}
public class MySerilizable {
public static void main(String[] args) throws Exception {
File file = new File("person.txt");
//序列化持久化对象
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(file));
Teacher person = new Teacher("Peter", 27);
out.writeObject(person);
out.close();
//反序列化,并得到对象
ObjectInputStream in = new ObjectInputStream(new FileInputStream(file));
Object newPerson = in.readObject(); // 没有强制转换到Person类型
in.close();
System.out.println(newPerson);
}
}
Serializable和Externalizable 的比较
— 实现Serializable接口的需要序列化的类可以没有无参构造器,但实现Externalizable接口的需要序列化的类必须有无参构造器,否在在反序列化时会失败。
—实现Serializable接口的类自动存储必要信息,而实现Externalizable接口的类由程序员决定存储哪些信息。
—实现Serializable接口的类易于实现,只需实现该接口即可,无需任何代码支持。而实现Externalizable接口的类必须为writeExternal(),readExternal()方法提供实现
— 实现Serializable接口的类性能略差,实现Externalizable的类性能略好。