一、Serializable接口
java的“对象序列化”能将一个实现了Serilizable接口的对象转换成一组byte,日后要用这个对象的时候，能把这些byte数据恢复出来，并据此重构那个对象。在跨网络环境下也是如此，序列化具有跨平台性。
之所以加入对象序列化是要用它来实现两个重要功能：java远程方法调用(RMI,Remote Method Invocation)能像调用自己机器上的对象那样去调用其他机器上的对象。当向远程对象传递消息的时候，就需要通过对象序列化来传送参数和返回值。对javaBean来说，Bean的状态信息通常是在设计时配置的，这些状态信息必须保存起来，供程序启动时用。对象序列化就是负责这些工作的。
要序列化对象，必须先创建一个OutputStream，然后把它嵌进ObjectOutputStream。用writeObject()方法把对象写入OutputStream。读的时候，把InputStream嵌到ObjectInputStream里，然后再调用readObject()方法，得到一个Object的引用，根据需要进行类型转换。
对象序列化不仅能保存对象的副本，还会把它引用的对象也保存起来，然后再继续跟踪那些对象的引用。涵盖的范围不仅包括对象的成员数据，而且包含数组里的引用。（这个是自动进行的，不需要我们编写代码）
序列化能实现轻量级的persistence。（persisitence是指，对象的生命周期不是由程序是否运行决定，在程序的两次调用之间对象仍然还活着）通过将序列化处理的对象写入磁盘，等到程序再次运行的时候再把它读出来，可以达到persistence的效果，之所以是“轻量级”是因为不能用像“persistent”这样的关键词来直接定义一个对象，然后让系统处理所有的细节。相反，必须明确进行序列化和解序列化（desierialize）。
二、相关说明与案例（一）：
java有个特点就是序列化，简单地来说就是可以将这个类存储在物理空间（当然还是以文件的形式存在），那么当你从本地还原这个文件时，你可以将它转换为它本身。这可以极大地方便网络上的一些操作，但同时，因为涉及到安全问题，所以并不希望把类里面所有的东西都能存储（因为那样，别人可以通过序列化知道类里面的内容），那么我们就可以用上transient这个关键字，它的意思是临时的，即不会随类一起序列化到本地，所以当还原后，这个关键字定义的变量也就不再存在。
通常,我们写的程序都要求特定信息能持久存在或保存到磁盘上,以供一个程序使用或用在同一个程序的另一次运行上.这种持久性可以通过几种方式来实现,包括写到数据库中或是利用JAVA为对象序列化提供的支持.不管我们选用什么方法,类实例的持久性都是通过保存类的域的状态来完成的,保存这些状态,以便以后可以对它们进行访问或使用它们来创建相同的实例.然而,有可能并不是所有的域都需要被保存起来.当一个实例被持久化时,其内部的一些域却不需要持久化,则可以用trainsient修饰符告诉编译器指定的域不需要被持久保存.
首先，让我们看一些Java serialization的代码：
public class LoggingInfo implements java.io.Serializable
{
private Date loggingDate = new Date();
private String uid;
private transient String pwd;
LoggingInfo(String user, String password)
{
uid = user;
pwd = password;
}
public String toString()
{
String password=null;
if(pwd == null)
{
password = "NOT SET";
}
else
{
password = pwd;
}
return "logon info: n " ＋ "user: " ＋ uid ＋
"n logging date : " ＋ loggingDate.toString() ＋
"n password: " ＋ password;
}
}
现在我们创建一个这个类的实例，并且串行化(serialize)它 ,然后将这个串行化对象写如磁盘。
LoggingInfo logInfo = new LoggingInfo("MIKE", "MECHANICS");
System.out.println(logInfo.toString());
try
{
ObjectOutputStream o = new ObjectOutputStream(
new FileOutputStream("logInfo.out"));
o.writeObject(logInfo);
o.close();
}
catch(Exception e) {//deal with exception}
To read the object back, we can write
try
{
ObjectInputStream in =new ObjectInputStream(
new FileInputStream("logInfo.out"));
LoggingInfo logInfo = (LoggingInfo)in.readObject();
System.out.println(logInfo.toString());
}
catch(Exception e) {//deal with exception}
如果我们运行这段代码，我们会注意到从磁盘中读回(read——back (de-serializing))的对象打印password为"NOT SET"。这是当我们定义pwd域为transient时，所期望的正确结果。
现在，让我们来看一下粗心对待transient域可能引起的潜在问题。假设我们修改了类定义，提供给transient域一个默认值，
代码如下：
public class GuestLoggingInfo implements java.io.Serializable
{
private Date loggingDate = new Date();
private String uid;
private transient String pwd;
GuestLoggingInfo()
{
uid = "guest";
pwd = "guest";
}
public String toString()
{
//same as above
}
}
现在，如果我们穿行化GuestLoggingInfo的一个实例，将它写入磁盘，并且再将它从磁盘中读出，我们仍然看到读回的对象打印password 为 "NOT SET"。
当从磁盘中读出某个类的实例时，实际上并不会执行这个类的构造函数，
而是载入了一个该类对象的持久化状态，并将这个状态赋值给该类的另一个对象。
例：
Which three concerning the use of the java.io.Serializable interface are
true? (Choose three.)
A. Objects from classes that use aggregation cannot be serialized.
B. Art object serialized on one JVM can be successfully deserialized on
a different JVM.
C. The values in fields with the volatile modifier will NOT survive
serialization and deserialization.
D. The values in fields with the transient modifier will NOT survive
serialization and deserialization.
E. It is legal to serialize an object of a type that has a supertype that
does NOT implement java.io.Serializable.
Answer: BDE
三、相关说明与案例（二）：
在JAVA中，一个大的应用程序需要保存很多对象的时候，由于虚拟机内存有限，(资源宝贵啊 )有时不可能所有有用的对象都放到内存中，因此，需要将不常用的对象暂时持久化的文件中，当需要这个对象时，再从文件把对象恢复到内存中，这就是所谓对象的序列化和反序列化。本文讲实现如何将对象序列化到文件，然后再从文件反序列化到对象，你会发现其实特别简单
先看一下对象的序列化和反序列化的关键是什么
1，首先被序列化的对象必须实现 java.io.Serializable 接口，其实这个接口没定义任何方法
2，序列化时，需要用到对象输出流ObjectOutputStream ,然后通过文件输出流构造 ObjectOutputStream 对象调用writeObject写入到文件（或者是writeIntwriteShort等写入基本数据类型）
3，反之，反序列化时用到对象输入流ObjectIntputStream, 然后通过文件输出流构造 ObjectIntputStream对象调用readObject加载到内存，注意，是返回万能Object类型（或者是readIntreadShort等读入基本数据类型）
4，注意：序列化时transient变量(这个关键字的作用就是告知JAVA我不可以被序列化)和静态变量不会被序列化(关于静态变量不会序列化保留意见，本实例先不用静态变量)
5，顺序问题，如果你先序列化对象A后序列化B，那么在反序列化的时候一定记着JAVA规定先读到的对象是先被反序列化的对象，不要先接收对象B，那样会报错，所以反序列化时要还是先反序列化A再B
好了，现在我们做一个实例，我们现在要序列化一个会员对象到文件里，然后再把它读出来
先创建会员类
Java代码
| |
1. import java.io.*;
2. import java.util.*;
3.
4. //一定要实现Serializable接口才能被序列化
5. public class UserInfo implements Serializable {
6. public String userName;
7. public String userPass;
8. //注意，userAge变量前面的transient
9. public transient int userAge;
10.
11. public UserInfo(){
12. }
13.
14. public UserInfo(String username,String userpass,int userage){
15. this.userName=username;
16. this.userPass=userpass;
17. this.userAge=userage;
18. }
19.
20. public String toString(){
21. return "用户名: "＋this.userName＋";密码："＋this.userPass＋
22. ";年龄："＋this.userAge;
23. }
24. }
import java.io.*;
import java.util.*;
//一定要实现Serializable接口才能被序列化
public class UserInfo implements Serializable {
public String userName;
public String userPass;
//注意，userAge变量前面的transient
public transient int userAge;
public UserInfo(){
}
public UserInfo(String username,String userpass,int userage){
this.userName=username;
this.userPass=userpass;
this.userAge=userage;
}
public String toString(){
return "用户名: "＋this.userName＋";密码："＋this.userPass＋
";年龄："＋this.userAge;
}
}
接着我们开始写如何序列化和反序列化，初学认真看哦
Java代码
| |
3343
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
