人生在世，还不是有时笑笑人家，有时给人家笑笑

对象串行化

对象的寿命通常随着生成该对象的程序的终止而终止。有时候，可能需要将对象的状态保存下来，在需要时再将对象恢复。我们把对象的这种能记录自己的状态以便将来再生的能力。叫作对象的持续性(persistence)。
对象通过写出描述自己状态的数值来记录自己，这个过程叫对象的串行化(Serialization)。也就是说能够将对象进行存档。
串行化的主要任务是写出对象实例变量的数值。如果变量是另一对象的引用，则引用的对象也要串行化。
串行化可以使得对象成为永久性，对象在创建它的程序外仍能够存在和起作用，被存储的对象中包含了可在程序中恢复的信息。

什么时候需要串行化？

当你想把的内存中的对象状态（也就是实例变量，不是方法）保存到一个文件中或者数据库中时候。
当你想用套接字在网络上传送对象的时候。
当你想通过RMI传输对象的时候；

串行化注意事项

序列化时，只能保存对象的非静态成员变量，不能保存任何的成员方法和静态的成员变量，而且串行化保存的只是变量的值，对于变量的任何修饰符，都不能保存。
当一个父类实现序列化，子类自动实现序列化，不需要显式实现Serializable接口；
当一个对象的实例变量引用其他对象，序列化该对象时也把引用对象进行序列化；
创建串行化对象时，要考虑是否保存该对象的所有实例变量，如果需要将某个实例变量排除在串行化中，可以使用限定符transient。是否串行某个实例变量需要考虑：
(1) 安全方面的原因：比如一个对象拥有private，public等变量在序列化进行传输的过程中，这个对象的private等域是不受保护的。如果对象中存储了敏感信息（如对某个资源访问的密码），将密码串行化到文件中将把它置于危险的境地。
(2) 资源分配方面的原因：对于有些实例变量，每当恢复对象时都需要重新创建，例如引用文件或者输入流的对象，每次从对象流中读取被串行化的对象时，对于其中的引用文件或输入流的对象都必须重新创建。还有例如socket，thread类，如果可以序列化，进行传输或者保存，也无法对他们进行重新的资源分配，而且，也是没有必要这样实现。
(3) ：考虑存储变量占用的空间的问题：如果变量的值无需通过串行化就可以确定，则不应对其进行串行化。

如何实现串行化和

在java.io包中，接口Serializable用来作为实现对象串行化的工具，只有实现了Serializable的类的对象才可以被串行化。它不包含任何必须实现的方法，Serializable的唯一用处就是指出类的对象可以以串行化的方式被存储和检索。
要串行化一个对象，必须与一定的对象输入/输出流联系起来，通过对象输出流（ObjectOutputStream）将对象状态保存下来，再通过对象输入流（ObjectInputStream）将对象状态恢复。
串行化将数据分解成字节流，以便存储在文件中或在网络上传输。反串行化就是打开字节流并重构对象。对象串行化化不仅要将基本数据类型转换成字节表示，有时还要恢复数据。恢复数据要求有恢复数据的对象实例。

对象串行化实现步骤

1、定义一个可串行化对象

package SerializableDemo;

import java.io.Serializable;

public class serializableDemo {

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

}

class Hero implements Serializable{
	/**
	 * 这是一个可串行化的对象
	 */
	
	//是自动生成的唯一标识
	private static final long serialVersionUID = 1L;
	
	//对象属性
	private String nickName;
	private transient String password;//该变量为暂存变量，不被串行化。
	int level;

	//构造函数
	public Hero(){
		
	}
	public Hero(String nickName,String password,int level){
		 this.nickName = nickName;
		 this.password = password;
		 this.level=level;
	}
	
	//setter和getter
	public String getNickName() {
		return nickName;
	}
	public void setNickName(String nickName) {
		this.nickName = nickName;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public int getLevel() {
		return level;
	}
	public void setLevel(int level) {
		this.level = level;
	}
}

2、创建输出流，讲对象写入到文件中

public class serializableDemo {

	static String filePath = "C:/Users/asus-pc/Desktop/javaProject/Demo/src/SerializableDemo/myHero.dat";
	private static OutputStream ops = null;
	private static ObjectOutputStream objectOutputStream = null;
	private static  Hero myHero  = null;
	public static void main(String[] args) {
    	//要写入到文件中的对象
		myHero = new Hero("fight", "753951", 15);
		try {
			//创建对象输出流
			ops = new FileOutputStream(filePath);
			objectOutputStream = new ObjectOutputStream(ops);
			//将对象写入文件
			objectOutputStream.writeObject(myHero);
			System.out.println("写入成功");
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		
	}

}

3、将对象反串行化到程序中

	//将对象从文件中读出来
			System.out.println("成功读出");
			ips = new FileInputStream(filePath);
			objectInputStream =new ObjectInputStream(ips);
			 Hero readHero = (Hero) objectInputStream.readObject();
			 //由于密码被transient限制，所以没有写入到文件中，也无法读出
			 System.out.println("readHero的昵称："+readHero.getNickName()+"\n密码："+readHero.getPassword()+"\n级别"+readHero.getLevel());

运行结果
写入成功
成功读出
readHero的昵称：fight
密码：null
级别15

全部程序代码

package SerializableDemo;

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

public class serializableDemo {

	static String filePath = "C:/Users/asus-pc/Desktop/javaProject/Demo/src/SerializableDemo/myHero.dat";
	private static OutputStream ops = null;
	private static ObjectOutputStream objectOutputStream = null;
	private static  Hero myHero  = null;

	private static InputStream ips =null;
	private static ObjectInputStream objectInputStream = null;
	public static void main(String[] args) {
		myHero = new Hero("fight", "753951", 15);
		try {
			//创建对象输出流
			ops = new FileOutputStream(filePath);
			objectOutputStream = new ObjectOutputStream(ops);
			
			//将对象写入文件
			objectOutputStream.writeObject(myHero);
			System.out.println("写入成功");
			
			//将对象从文件中读出来
			System.out.println("成功读出");
			ips = new FileInputStream(filePath);
			objectInputStream =new ObjectInputStream(ips);
			 Hero readHero = (Hero) objectInputStream.readObject();
			 //由于密码被transient限制，所以没有写入到文件中，也无法读出
			 System.out.println("readHero的昵称："+readHero.getNickName()+"\n密码："+readHero.getPassword()+"\n级别"+readHero.getLevel());
	
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		
	}

}

class Hero implements Serializable{
	/**
	 * 这是一个可串行化的对象
	 */
	
	//是自动生成的唯一标识
	private static final long serialVersionUID = 1L;
	
	//对象属性
	private String nickName;
	private transient String password;//该变量为暂存变量，不被串行化。
	int level;

	//构造函数
	public Hero(){
		
	}
	public Hero(String nickName,String password,int level){
		 this.nickName = nickName;
		 this.password = password;
		 this.level=level;
	}
	
	//setter和getter
	public String getNickName() {
		return nickName;
	}
	public void setNickName(String nickName) {
		this.nickName = nickName;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public int getLevel() {
		return level;
	}
	public void setLevel(int level) {
		this.level = level;
	}
}

串行化对象和字节数组的转换

通过ByteArrayInputStream和ByteArrayOutputStream可以将串行化的对象和字节数组进行转化

package testDemo;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Date;

public class testDemo  {
	
	public byte[] objectToBytes(Object obj){
		  byte bytes[] =null;
		   ByteArrayOutputStream bArrayOutputStream =new ByteArrayOutputStream();
		   try {
			ObjectOutputStream objectOutputStream =new ObjectOutputStream(bArrayOutputStream);
		   objectOutputStream.writeObject(obj);
		   bytes =bArrayOutputStream.toByteArray();
		   
		   } catch (IOException e) {
			e.printStackTrace();
		}
		   return bytes;
	}
	public Object bytesToObject(byte bytes[]){
		  ByteArrayInputStream bArrayInputStream =new ByteArrayInputStream(bytes);
	      Object obj =null;
		  try {
			  ObjectInputStream objectInputStream =new ObjectInputStream(bArrayInputStream);
	          obj =objectInputStream.readObject();
		  } catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		return obj;  
	}
	
	public static void main(String[] args) {
		testDemo myTestDemo =new testDemo();
		byte b[] =myTestDemo.objectToBytes(new Date()); 
		//将日期这个对象转换成字节数组
		System.out.println(myTestDemo.bytesToObject(b));
		//将转换成的数组转换成对象，输出
	}
	
}

运行结果

Mon Nov 19 21:19:19 CST 2018

java-串行化

对象串行化

什么时候需要串行化？

串行化注意事项

如何实现串行化和

对象串行化实现步骤

串行化对象和字节数组的转换

猜你喜欢