串行化是指存储和获取磁盘文件、内存或其他地方中的对象。在串行化时,所有的实例数据都保存到存储介质上,
在取消串行化时,对象会被还原,且不能与其原实例区别开来。只需给类添加Serializable属性,就可以实现串行化实
的成员。
反串行化是串行化的逆过程,数据从存储介质中读取出来,并赋给类的实例变量。
串行化/序列化:将java对象转换成某种格式(JVM定义的)的字节数组
串行化使用场景:
将对象用户网络间传输或者是本地化储存。
反串行化:将字节数组恢复成java对象。
package com.yongjun.io;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import org.junit.Test;
class ObejctSerializeDemo {
/**
* 串行化方法javabean
* @throws Exception
*/
@Test
public void serializePerson() throws Exception {
Person p=new Person("tom",12);
System.out.println(p);
FileOutputStream fos=new FileOutputStream("e:/p.data");
ObjectOutputStream oos=new ObjectOutputStream(fos);
oos.writeObject(p);
oos.close();
fos.close();
}
/**
* 反串行化方法javabean
* @throws Exception
*/
@Test
public void DeSerializePerson() throws Exception {
FileInputStream fis=new FileInputStream("e:/p.data");
ObjectInputStream ois=new ObjectInputStream(fis);
Person p=(Person)ois.readObject();
ois.close();
fis.close();
System.out.println(p.getName()+p.getMarried());
}
}
串行化和反串行化实现深度复制:
/**
* 深度复制,复制的是整个对象
* @author Frenzy Fan
*
*/
public class DeepCopyDemo {
@Test
public void Seria() throws Exception, Exception {
Person p=new Person();
Son s=new Son();
Dog d=new Dog();
//设置关联关系
s.setPerson(p);
d.setSon=(s);
//串行化,串行到磁盘了,如果很大,读取很慢,所以要穿行到内存字节数组
ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("e:/kk.data"));
oos.writeObject(d);
oos.close();
}
/**
* 使用byteArrayInputStream+ByteArrayOutputStream实现对象的深度复制
* @throws Exception
*/
public void deeplyCopyInBAOS() throws Exception {
Person p=new Person();
Son s=new Son();
Dog d=new Dog();
//设置关联
s.setPerson(p);
d.setSon(s);
//串行化过程到内存中
ByteArrayOutputStream baos=new ByteArrayOutputStream();
ObjectOutputStream oos=new ObjectOutputStream(baos);
oos.writeObject(d);
oos.close();
baos.close();
//提取内存中的数据
byte []bytes=baos.toByteArray();
//反串行化过程
ByteArrayInputStream bais=new ByteArrayInputStream(bytes);
ObjectInputStream ois=new ObjectInputStream(bais);
d=(Dog)ois.readObject();
ois.close();
bais.close();
System.out.println(d.getSon().getName());
}
@Test
/**
* 反串行化
*/
public void deSeria()throws Exception{
ObjectInputStream oos=new ObjectInputStream(new FileInputStream("e:/kk.data"));
Dog d=(Dog)oos.readObject();
oos.close();
System.out.println(d.getSon());
}
/**
* 持续写入数据
*/
@Test
public void continusWrite()throws Exception{
Person p=new Person();
p.setName("tom");
Son s=new Son();
s.setName("jerry");
Dog d=new Dog();
d.setName("yellow");
//串行
ByteArrayOutputStream baos=new ByteArrayOutputStream();
ObjectOutputStream oos=new ObjectOutputStream(baos);
oos.writeObject(p);
oos.writeObject(s);
oos.writeObject(d);
oos.close();
baos.close();
byte[]bytes=baos.toByteArray();
//反串行
ObjectInputStream ois=new ObjectInputStream(new ByteArrayInputStream(bytes));
Person pe=(Person)ois.readObject();
Son s2=(Son)ois.readObject();
Dog d2=(Dog)ois.readObject();
ois.close();
}
}
class Person implements Serializable {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
class Son implements Serializable{
private String name;
//transient临时的,暂时的。
private transient Person person;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Person getPerson() {
return person;
}
public void setPerson(Person person) {
this.person = person;
}
}
class Dog implements Serializable{
public Son setSon;
private String name;
private Son son;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Son getSon() {
return son;
}
public void setSon(Son son) {
this.son = son;
}
}