java序列化传输泪 java序列化实现

Java对象以及类的基本信息在JVM内存中随着JVM停止而消失，JVM下次启动又会重新加载字节码。但是假如系统下次启动后，某对象A需要依赖系统本次对象A的值的时候，就需要考虑对象A“持久化”的问题。看到“持久化”都会想到数据库或者缓存，这里注重面向对象的思维来“持久化”对象，所以数据库和缓存的方式不适合这种情况。基于对象能够在程序不运行的情况下仍能存在并保存其信息的需求，对象的序列化功能孕育而生。

对象的序列化是指通过某种方法把对象以字节序列的形式保存起来。反之通过字节序列得到原对象就是反序列化。

实现序列化，简单来说，只要对象实现了Serializable接口，该对象就可以进行序列化。Serializable接口只是一个标记接口，不包括任何属性和方法。下面写个简单的例子说明序列化的过程。
被序列化类：

import java.io.Serializable;

public class Person implements Serializable {
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	private String name;
	private int age;
	private String sex;

	public Person(String name, int age, String sex) {
		this.name = name;
		this.age = age;
		this.sex = sex;
	}
public String toString() {
		return "name=" + name + ", age=" + age + ", sex=" + sex;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}	
}

序列化person对象：

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.util.Date;

public class objectTest {
	public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
		//序列化对象
		ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("F:\\objectFile.txt"));
		Person person = new Person("小明", 18, "男");
		out.writeObject("你好");//写入字面值常量
		out.writeObject(new Date());//写入匿名Date对象
		out.writeObject(person);//写入对象
		out.close();
		
		//反序列化
		ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("F:\\objectFile.txt"));
		System.out.println("obj1 " + (String) inputStream.readObject());//读取字面值常量
		System.out.println("obj2 " + (Date) inputStream.readObject());//读取匿名Date对象
		Person obj3 = (Person)inputStream.readObject(); //读取对象
		System.out.println("obj3 " + obj3);
		inputStream.close();
	}
}

输出结果：

这里person对象序列化到本地文件"F:\\objectFile.txt"(存储的文件名和后缀名可随意取)内，具体过程是调用ObjectOutputStream对象的writeObject()；反序列化则是调用ObjectInputStream对象的readObject()方法。

注意：Person类中的serialVersionUID是实现Serializable接口的类都要生成的一个静态常量，有两种生成方式：一是直接定义为1L，一是随机生成；其作用是为了保证反序列化时找到正确的版本。

 

跟踪ObjectOutputStream对象的writeObject()方法，不难发现最后以byte形式存储对象，这种存储就是字节序列存储，也是序列化名字的由来。.class文件是字节码文件，所以序列化后的文件与.class文件类似，那么字节序列的存储形式也就很明显。下面以十六进制方式查看序列化后的具体内容：

//字节byte读取
FileInputStream in = new FileInputStream("F:\\objectFile.txt");
//将文件数据读取到字节数组byte中,数组大小由in的可读大小决定
byte[] b = new byte[in.available()];
while(in.read(b) != -1 ){}
//确定十六进制的书写方式
String str = "0123456789ABCDEF";
//将字节转化为十六进制
for(byte a : b){
	//取字节的高四位,与0x0f与运算,得到该十六进制数据对应的索引(0~15)
	System.out.print(str.charAt((a >> 4) & 0x0f));
	//字节的低四位
	System.out.print(str.charAt(a & 0x0f));
	System.out.print(" ");
}
in.close();

输出结果：

这是person对象序列化后，用十六进制表示的形式。

对象的序列化不是为了保存在本地(而是保存对象某时刻的状态)，而是用于系统之间的通信。系统间都是通过接口传递信息，信息除了是常见的自定义bean对象和集合对象(常见的Map)外，还有XML格式的报文。所以当上游系统发送序列化的bean或者XML格式的报文后，下游系统可以同步或者异步的接收信息并进行处理。

 

序列化和反序列化的过程：

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

public class objectTest {
	public static void main(String[] args) throws Exception {
		// 序列化
		System.out.println("..............序列化开始..............................");
		ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("F://obj.txt"));
		obj o = new obj(6);
		outputStream.writeObject(o);
		outputStream.flush();
		outputStream.close();
        System.out.println("..............序列化结束..............................");
        
      //反序列化
      System.out.println("..............反序列化开始..............................");
      ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("F://obj.txt"));
      obj o2 = (obj)inputStream.readObject();
      inputStream.close();
      System.out.println(o2.getI());
      System.out.println("..............反序列化结束..............................");
	}
}
class obj implements Serializable {

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	private int i;
	public obj(){
		System.out.println("obj : 不带参数的构造方法");
	}
	public obj(int i) {
		this.i = i;
		System.out.println("obj: 带参数的构造方法");
	}
	public int getI() {
		return i;
	}
	public void setI(int i) {
		this.i = i;
	}
}

输出结果:

表明反序列化过程不会调用类的构造方法，而是直接根据字节码生成对象。

 

序列化里需要注意的几个点：

1、子类能够继承父类的序列化功能

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


public class Test {
	public static void main(String[] args) throws Exception {
		Son son = new Son("小明", 20);
		ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("E://Son.txt"));
		out.writeObject(son);
		out.close();
		
		ObjectInputStream in = new ObjectInputStream(new FileInputStream("E://Son.txt"));
		Son son_ = (Son)in.readObject();
		System.out.println(son_.toString());
		in.close();
	}
}
class Dad implements Serializable {
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	private String name;
	private int age;
	
	public Dad(String name, int age) {
		this.name = name;
		this.age = age;
	}
	
	public String toString() {
		return this.getClass().getName()+ ": " + name + ", " + age;
	}
}

class Son extends Dad {
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	public Son(String name, int age) {
		super(name, age);
	}
}

2、引用类型的属性会随着对象序列化而序列化

3、并非所有的对象都可以序列化

   （1）、安全方面的原因，比如一个对象拥有private，public等field，对于一个要传输的对象，比如写到文件，或者进行rmi传输 等等，在序列化进行传输的过程中，这个对象的private等域是不受保护的。

   （2）、资源分配方面的原因，比如socket，thread类，如果可以序列化，进行传输或者保存，也无法对他们进行重新的资源分配，而且，也是没有必要这样实现