JAVA Object 序列化与反序列化，以及控制Object 部分序列化与反序列化

1.JAVA Object 序列化与反序列化

所谓的JAVA序列化与反序列化，序列化就是将JAVA 对象以一种的形式保持，比如存放到硬盘，或是用于传输。反序列化是序列化的一个逆过程

JAVA规定被序列化的对象必须实现java.io.Serializable这个接口，我们假设序列化类为Person

举例如下：

被序列化的对象类

package com.models;

import java.io.Serializable;

public class Person implements Serializable{

/**
* JAVA序列化对象
*/
private static final long serialVersionUID = 1L;
private String Uid;
private String name;
private Integer age;
public Person(){

}
public Person(String uid, String name, Integer age) {
super();
Uid = uid;
this.name = name;
this.age = age;
}
public String getUid() {
return Uid;
}
public void setUid(String uid) {
Uid = uid;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}


@Override
public String toString() {

return this.Uid+"-"+this.name+"-"+this.age;
}

}

自己写的一个序列化的工具类JavaSerializableUtil

package com.utils;

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

import com.models.Person;

public class JavaSerializableUtil {

public final static void serializable(String outputFile,Object object) throws IOException{
FileOutputStream fos = new FileOutputStream(outputFile);
ObjectOutputStream oos = new ObjectOutputStream(fos);
if(object instanceof Person){
Person person = (Person)object;
System.out.println("序列化： "+person);
}
oos.writeObject(object);
oos.flush();
oos.close();
}
public final static void deserializable(String inputFile,Object object) throws IOException, ClassNotFoundException{
FileInputStream fis = new FileInputStream(inputFile);
ObjectInputStream ois = new ObjectInputStream(fis);
Person person = (Person)ois.readObject();
System.out.println("反序列化： "+person);

}

}

编写测试类Main

package com.test;

import java.io.IOException;

import com.models.Person;
import com.utils.JavaSerializableUtil;

public class Main {

/**
* @param args
*/
public static void main(String[] args) throws IOException, ClassNotFoundException {
Person object = new Person("xxxxxuuuiiiidd","aven",60);
//JavaSerializableUtil.serializable("c:\\javaserializable.txt", object);
JavaSerializableUtil.deserializable("c:\\javaserializable.txt",Person.class);
}
}

以上程序运行结果如下：

序列化： xxxxxuuuiiiidd-aven-60
反序列化： xxxxxuuuiiiidd-aven-60

2.控制Object 部分序列化与反序列化

我们知道JAVA，规定凡是被transisent，static 修饰的变量，将不被序列化。

此外，还有一种方法可以更加动态的控制序列类的哪一些属性被序列化，哪些不被序列化。这也是这一小节要讲的主要内容。

这个类是java.io.Externalizable这个接口，这个接口继承了Serializable接口。

让被序列化的对象Person实现这个接口，通过重写里这的readExternal(),writeExternal()两个方法，在这两个方法里边拦节对象的属性，控制在序列化时，对象的哪些属性被序列，哪些不被序列；控制在反序列化时，对象的哪些属性被反序列化，哪些属性不被反序列化，从而以保证信息的安全

举例

只需要将上面的序列化对象Person修改如下即可

package com.models;

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

public class Person implements Externalizable{

/**
* JAVA序列化对象
*/
private static final long serialVersionUID = 1L;
private String Uid;
private String name;
private Integer age;
public Person(){

}
public Person(String uid, String name, Integer age) {
super();
Uid = uid;
this.name = name;
this.age = age;
}
public String getUid() {
return Uid;
}
public void setUid(String uid) {
Uid = uid;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}


@Override
public String toString() {

return this.Uid+"-"+this.name+"-"+this.age;
}
@Override
public void writeExternal(ObjectOutput out) throws IOException {
// 只序列化name
System.out.println("只序列化Person对象的name: "+this.name);
out.writeUTF(this.name);


}
@Override
public void readExternal(ObjectInput in) throws IOException,
ClassNotFoundException {
// 读出序列化对象的name
System.out.println("读出序列化Person对象的name "+in.readUTF());


}

}