JAVA对象串行化

   在RMI分布式应用系统中，服务器与客户机之间传递的Java对象必须是可序列化的对象。不可序列化的对象不能在对象流中进行传递。对象序列化扩展了核心Java输入/输出类，同时也支持对象。对象序列化支持把对象编码以及将通过它们可访问到的对象编码变成字节流；同时，它也支持流中对象图形的互补重构造。序列化用于轻型持久性和借助于套接字或远程方法调用(RMI)进行的通信。序列化中现在包括一个   API（Application   Programming   Interface，应用程序接口），允许独立于类的域指定对象的序列化数据，并允许使用现有协议将序列化数据域写入流中或从流中读取，以确保与缺省读写机制的兼容性。  
   
   为编写应用程序，除多数瞬态应用程序外，都必须具备存储和检索   Java对象的能力。以序列化方式存储和检索对象的关键在于提供重新构造该对象所需的足够对象状态。存储到流的对象可能会支持   Serializable（可序列化）或   Externalizable（可外部化）接口。对于Java对象，序列化形式必须能标识和校验存储其内容的对象所属的   Java类，并且将该内容还原为新的实例。对于可序列化对象，流将提供足够的信息将流的域还原为类的兼容版本。对于可外部化对象，类将全权负责其内容的外部格式。序列化   Java   对象的目的是：提供一种简单但可扩充的机制，以序列化方式维护   Java对象的类型及安全属性；具有支持编组和解编的扩展能力以满足远程对象的需要；具有可扩展性以支持   Java   对象的简单持久性；只有在自定义时，才需对每个类提供序列化自实现；允许对象定义其外部格式。

   串行化是java.io包中的一部分，它被用来将对象转换成一串字节。在串行化的过程中，将一个实体转变成一系列表示对象的字节，这些字节可以写入文档以备后用，通过网络连接传输到其他程序，用来对初始对象进行拷贝等等。

   如果你需要串行化一个类，那么就必须对这个类执行java.io.Serializable，并且提供一个无争议的构造器。Serializable接口不需要任何方法，因此你的这个类不再需要别的了。

   如果你有一个简单的类似bean的类，而这个类仅仅是把原始的、可串行化对象作为属性，那么你就不需要再做别的了。当你需要将对象串行化为一系列字节或由一系列字节串行化而来时，Java可以负责所有的细节。

   以下是一个可以供你进行实验的完整串行化例子： 

import java.io.FileInputStream; 
import java.io.FileOutputStream; 
import java.io.EOFException; 
import java.io.IOException; 
import java.io.ObjectInputStream; 
import java.io.ObjectOutputStream; 
import java.io.Serializable; 
import java.util.Random; 

public class SerializableTipHelper {
 private static final String STORE_FILE = "bytes.out";    
    private static final boolean VERBOSE = true;    
    public static void main(String[] args) {    
        if ( args.length != 1 && args.length != 2 ) {    
            System.out.println("use: SerializableTipHelper (read|write) [numberToWrite]");    
            return;    
        }    
        if ( args[0].equals("write") ) {    
            try {    
                write(Integer.parseInt(args[1]));    
            }    
            catch (IOException e) {    
                e.printStackTrace();    
            }    
        }    
        // defaults to read    
        else {    
            try {    
                read();    
            }    
            catch (IOException e) {    
                e.printStackTrace();    
            }    
            catch (ClassNotFoundException e) {    
                e.printStackTrace();    
  
  
            }    
        }    
    }    
  
    public static void read() throws IOException, ClassNotFoundException {    
        ObjectInputStream in = new ObjectInputStream(new FileInputStream(STORE_FILE));    
        int numRead = 0;    
        Object o = null;    
        try {    
            while ( (o = in.readObject()) != null ) {    
                numRead++ ;    
                if ( VERBOSE ) {    
                    System.out.println("read" + numRead + ": " + o);   
                }    
            }    
        }    
        catch (EOFException e) {    
            // suppress    
        }    
    }    
  
    public static void write(int num) throws IOException {    
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(STORE_FILE));  
        Random rand = new Random(System.currentTimeMillis());    
  
        for (int i = 0; i < num; i++ ) {    
            SerializableTip st = new SerializableTip();    
            st.setAge(rand.nextInt(1000));    
            st.setEmployed(rand.nextBoolean());    
            st.setName("instance-" + i);    
            Employee e = new Employee();    
            e.setId(rand.nextInt());    
            e.setName("employee-" + i);    
            st.setEmployee(e);    
            if ( VERBOSE ) {    
                System.out.println("writing: st");    
            }    
            out.writeObject(st);    
        }    
        out.close();    
    }    
}

 

import java.io.*;

public class SerializableTip implements Serializable {    
    private String name;    
    private int age;    
    private boolean employed;    
    private Employee employee;    
    private int weight;    
    public int getAge() {    
        return age;    
    }    
    public String getName() {    
  
        return name;    
    }    
    public void setAge(int i) {    
        age = i;    
    }    
    public void setName(String string) {    
  
        name = string;    
    }    
  
  
    public boolean isEmployed() {    
        return employed;    
    }    
    public void setEmployed(boolean b) {    
        employed = b;    
    }    
    public Employee getEmployee() {    
        return employee;    
    }    
    public void setEmployee(Employee employee) {    
        this.employee = employee;    
    }    
    public String toString() {    
        StringBuffer me = new StringBuffer();    
        me.append("[").append(super.toString())    
        .append(",name=").append(this.name)    
        .append(",age=").append(this.age)    
        .append(",employed=").append(this.employed)    
        .append(",employee=").append(this.employee)    
        .append("]");    
        return me.toString();    
    }    
    public int getWeight() {    
        return weight;    
    }    
    public void setWeight(int i) {    
        weight = i;    
    }    
}

 

public class Employee implements Serializable {    
    private int id;    
    private String name;    
    public int getId() {    
        return id;    
    }    
    public void setId(int id) {    
        this.id = id;    
    }    
    public java.lang.String getName() {    
        return name;    
    }    
    public void setName(java.lang.String name) {    
        this.name = name;    
    }    
    public String toString() {    
        StringBuffer me = new StringBuffer();    
        me.append("[").append(super.toString())    
        .append(",id=").append(this.id)    
        .append(",name=").append(this.name)    
        .append("]");    
        return me.toString();    
    }    
}

 

   以上是本人做网络笔记为自己提供分析认识的，如需更加详细了解串行化细节，还请网友多参考一些专业资料。本文参考于其他同行对此问题的认识，在此非常感谢！