序列化---Serializable

最新推荐文章于 2024-07-24 21:47:59 发布

l0979365428

最新推荐文章于 2024-07-24 21:47:59 发布

阅读量418

点赞数

分类专栏： Java学习资料文章标签： tree object string exception stream java

Java学习资料专栏收录该内容

10 篇文章 0 订阅

订阅专栏

public interface Serializable

类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。序列化接口没有方法或字段，仅用于标识可序列化的语义。

要允许不可序列化类的子类型序列化，可以假定该子类型负责保存和还原超类型的公用 (public)、受保护的 (protected) 和（如果可访问）包 (package) 字段的状态。仅在子类型扩展的类有一个可访问的无参数构造方法来初始化该类的状态时，才可以假定子类型有此责任。如果不是这种情况，则声明一个类为可序列化类是错误的。该错误将在运行时检测到。

在反序列化过程中，将使用该类的公用或受保护的无参数构造方法初始化不可序列化类的字段。可序列化的子类必须能够访问无参数的构造方法。可序列化子类的字段将从该流中还原。

当遍历一个图形时，可能会遇到不支持可序列化接口的对象。在此情况下，将抛出 NotSerializableException，并将标识不可序列化对象的类。

在序列化和反序列化过程中需要特殊处理的类必须使用下列准确签名来实现特殊方法：

private void writeObject(java.io.ObjectOutputStream out)
throws IOException
private void readObject(java.io.ObjectInputStream in)
throws IOException, ClassNotFoundException;

writeObject 方法负责写入特定类的对象的状态，以便相应的 readObject 方法可以还原它。通过调用 out.defaultWriteObject 可以调用保存 Object 的字段的默认机制。该方法本身不需要涉及属于其超类或子类的状态。状态是通过使用 writeObject 方法或使用 DataOutput 支持的用于基本数据类型的方法将各个字段写入 ObjectOutputStream 来保存的。

readObject 方法负责从流中读取并还原类字段。它可以调用 in.defaultReadObject 来调用默认机制，以还原对象的非静态和非瞬态字段。defaultReadObject 方法使用流中的信息来分配流中通过当前对象中相应命名字段保存的对象的字段。这用于处理类发展后需要添加新字段的情形。该方法本身不需要涉及属于其超类或子类的状态。状态是通过使用 writeObject 方法或使用 DataOutput 支持的用于基本数据类型的方法将各个字段写入 ObjectOutputStream 来保存的。

将对象写入流时需要指定要使用的替代对象的可序列化类，应使用准确的签名来实现此特殊方法：

ANY-ACCESS-MODIFIER Object writeReplace() throws ObjectStreamException;

此 writeReplace 方法将由序列化调用，前提是如果此方法存在，而且它可以通过被序列化对象的类中定义的一个方法访问。因此，该方法可以拥有私有 (private)、受保护的 (protected) 和包私有 (package-private) 访问。子类对此方法的访问遵循 java 访问规则。

在从流中读取类的一个实例时需要指定替代的类应使用的准确签名来实现此特殊方法。

ANY-ACCESS-MODIFIER Object readResolve() throws ObjectStreamException;

此 readResolve 方法遵循与 writeReplace 相同的调用规则和访问规则。

序列化运行时使用一个称为 serialVersionUID 的版本号与每个可序列化类相关联，该序列号在反序列化过程中用于验证序列化对象的发送者和接收者是否为该对象加载了与序列化兼容的类。如果接收者加载的该对象的类的 serialVersionUID 与对应的发送者的类的版本号不同，则反序列化将会导致 InvalidClassException。可序列化类可以通过声明名为 "serialVersionUID" 的字段（该字段必须是静态 (static)、最终 (final) 的 long 型字段）显式声明其自己的 serialVersionUID：

ANY-ACCESS-MODIFIER static final long serialVersionUID = 42L;

如果可序列化类未显式声明 serialVersionUID，则序列化运行时将基于该类的各个方面计算该类的默认 serialVersionUID 值，如“Java(TM) 对象序列化规范”中所述。不过，强烈建议所有可序列化类都显式声明 serialVersionUID 值，原因计算默认的 serialVersionUID 对类的详细信息具有较高的敏感性，根据编译器实现的不同可能千差万别，这样在反序列化过程中可能会导致意外的 InvalidClassException。因此，为保证 serialVersionUID 值跨不同 java 编译器实现的一致性，序列化类必须声明一个明确的 serialVersionUID 值。还强烈建议使用 private 修改器显示声明 serialVersionUID（如果可能），原因是这种声明仅应用于立即声明类 -- serialVersionUID 字段作为继承成员没有用处。

==============================================================================

初探序列化---Serializable

　　Java的"对象序列化"能让你将一个实现了Serializable接口的对象转换成一组byte，这样日后要用这个对象时候，你就能把这些byte数据恢复出来，并据此重新构建那个对象了。

　　要想序列化对象，你必须先创建一个OutputStream，然后把它嵌进ObjectOutputStream。这时，你就能用writeObject( )方法把对象写入OutputStream了。

　　读的时候，你得把InputStream嵌到ObjectInputStream里面，然后再调用readObject( )方法。不过这样读出来的，只是一个Object的reference，因此在用之前，还得先下传。readObject 方法负责从流中读取并还原类字段。它可以调用 in.defaultReadObject 来调用默认机制，以还原对象的非静态和非瞬态字段。

　　　defaultReadObject 方法使用流中的信息来分配流中通过当前对象中相应命名字段保存的对象的字段。这用于处理类发展后需要添加新字段的情形。该方法本身不需要涉及属于其超类或子类的状态。状态是通过使用 writeObject 方法或使用 DataOutput 支持的用于基本数据类型的方法将各个字段写入 ObjectOutputStream 来保存的。

　　看一个列子：
import java.io. * ;

class tree implements java.io.Serializable {
     public tree left;
     public tree right;
     public   int id;
     public   int level;

private static int count = 0 ;

     public tree( int depth) {
        id = count ++ ;
        level = depth;
         if (depth >   0 ) {
            left =   new tree(depth - 1 );
            right =   new tree(depth - 1 );
        }
    }

     public   void print( int levels) {
         for ( int i =   0 ; i < level; i ++ )
            System.out.print( "    " );
        System.out.println( " node "   + id);

if (level <= levels && left != null )
left.print(levels);

         if (level <= levels && right !=   null )
            right.print(levels);
    }

public static void main (String argv[]) {

         try   {
             /* 创建一个文件写入序列化树。 */
            FileOutputStream ostream =   new FileOutputStream( " tree.tmp " );
             /* 创建输出流 */
            ObjectOutputStream p =   new ObjectOutputStream(ostream);

/* 创建一个二层的树。 */
tree base = new tree( 2 );

            p.writeObject(base); // 将树写入流中。
             p.writeObject( " LiLy is 惠止南国 " );
            p.flush();
            ostream.close();     // 关闭文件。

              /* 打开文件并设置成从中读取对象。 */
            FileInputStream istream =   new FileInputStream( " tree.tmp " );
            ObjectInputStream q =   new ObjectInputStream(istream);

/* 读取树对象，以及所有子树 */
tree new_tree = (tree)q.readObject();

            new_tree.print( 2 );   // 打印出树形结构的最上面２级
             String name = (String)q.readObject();
            System.out.println( " /n " + name);
        }   catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}

　　最后结果如下：

node 0
node 1
node 2
node 3
node 4
node 5
node 6

LiLy is 惠止南国

　　可以看到，在序列化的时候，writeObject与readObject之间的先后顺序。readObject将最先write的object read出来。用数据结构的术语来讲就姑且称之为先进先出吧！

　　在序列化时，有几点要注意的：
　　１：当一个对象被序列化时，只保存对象的非静态成员变量，不能保存任何的成员方法和静态的成员变量。
　　２：如果一个对象的成员变量是一个对象，那么这个对象的数据成员也会被保存。
　　３：如果一个可序列化的对象包含对某个不可序列化的对象的引用，那么整个序列化操作将会失败，并且会抛出一个NotSerializableException。我们可以将这个引用标记为transient，那么对象仍然可以序列化

　　还有我们对某个对象进行序列化时候，往往对整个对象全部序列化了，比如说类里有些数据比较敏感，不希望序列化，一个方法可以用transient来标识，另一个方法我们可以在类里重写
private   void readObject(java.io.ObjectInputStream stream)
      throws IOException, ClassNotFoundException;
private   void writeObject(java.io.ObjectOutputStream stream)
      throws IOException

　　这二个方法！
　　示例：

import java.io. * ;

class ObjectSerialTest
{
     public   static   void main(String[] args) throws Exception
     {
        Employee e1 = new Employee( " zhangsan " , 25 , 3000.50 );
        Employee e2 = new Employee( " lisi " , 24 , 3200.40 );
        Employee e3 = new Employee( " wangwu " , 27 , 3800.55 );

        FileOutputStream fos = new FileOutputStream( " employee.txt " );
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(e1);
        oos.writeObject(e2);
        oos.writeObject(e3);
        oos.close();

        FileInputStream fis = new FileInputStream( " employee.txt " );
        ObjectInputStream ois = new ObjectInputStream(fis);
        Employee e;
         for ( int i = 0 ;i < 3 ;i ++ )
         {
            e = (Employee)ois.readObject();
            System.out.println(e.name + " : " + e.age + " : " + e.salary);
        }
        ois.close();
    }
}

class Employee implements Serializable
{
    String name;
     int age;
     double salary;
     transient Thread t = new Thread();
     public Employee(String name, int age, double salary)
     {
         this .name = name;
         this .age = age;
         this .salary = salary;
    }
     private   void writeObject(java.io.ObjectOutputStream oos) throws IOException
     {
        oos.writeInt(age);
        oos.writeUTF(name);
        System.out.println( " Write Object " );
    }
     private   void readObject(java.io.ObjectInputStream ois) throws IOException
     {
        age = ois.readInt();
        name = ois.readUTF();
        System.out.println( " Read Object " );
    }

}

转自：http://blog.163.com/flm_llx/blog/static/2712071220083169341435/

l0979365428

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
序列化---Serializable

public interface Serializable类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。序列化接口没有方法或字段，仅用于标识可序列化的语义。要允许不可序列化类的子类型序列化，可以假定该子类型负责保存和还原超类型的公用 (public)、受保
复制链接

扫一扫

专栏目录