接口java.io.Serializable 详细总结

最新推荐文章于 2025-05-15 22:48:31 发布

原创最新推荐文章于 2025-05-15 22:48:31 发布 · 1.6w 阅读

18 ·

CC 4.0 BY-SA版权

文章标签：

#Integer #java #null #Serializable

java 专栏收录该内容

5 篇文章

订阅专栏

本文详细介绍了Java对象序列化的基本概念、应用场景以及实现方式。序列化是将对象状态转化为字节流的过程，便于存储和传输。文章还探讨了序列化的隐患、注意事项以及如何通过transient关键字来控制序列化过程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1、java.io.Serializable，表示序列化，是一个空接口，也就是说这个接口没有声明任何的方法，所以实现这个接口的类也就不需要实现任何的方法。

2、序列化用在将对象编码成字节流（序列化）及从字节流编码重构对象（反序列化）。
序列化为远程通信提供了标准的wire-level协议。

序列化是什么：

序列化就是将一个对象的状态（各个属性量）保存起来，然后在适当的时候再获得。

序列化分为两大部分：序列化和反序列化。序列化是这个过程的第一部分，将数据分解成字节流，以便存储在文件中或在网络上传输。反序列化就是打开字节流并重构对象。对象序列化不仅要将基本数据类型转换成字节表示，有时还要恢复数据。

3、要使类的实例实现序列化，只要在它的声明中加入implements java.io.Serializable
但是却由一些隐患
1 》实现了序列化后，一旦发布，讲削弱改变类实现的灵活性。
2 》增加了bug和安全漏洞的的可能性
3 》当你的新版本发布时增加了相关的测试上的问题。
这个接口使得所有的实现它的类具有一个特殊的（mixin）类型，从而使JVM知道这个类可以安全地串行化。

4、如果你需要把一个Bean实例通过网络传输或者写到磁盘文件的话，那么实现Serializable接口是最简单的,你可以直接通过ObjectInputStream,ObjectOutputStream进行读入或者写出

实用意义:

一：对象序列化可以实现分布式对象。

主要应用例如：RMI要利用对象序列化运行远程主机上的服务，就像在本地机上运行对象时一样。

二：java对象序列化不仅保留一个对象的数据，而且递归保存对象引用的每个对象的数据。可以将整个对象层次写入字节流中，可以保存在文件中或在网络

连接上传递。利用对象序列化可以进行对象的“深复制”，即复制对象本身及引用的对象本身。序列化一个对象可能得到整个对象序列。

EP:

import java.io.Serializable;

import java.io.FileOutputStream;

import java.io.ObjectOutputStream;

import java.io.FileInputStream;

import java.io.ObjectInputStream;

class MeTree implements Serializable {

private static final long serialVersionUID = 42L;

public MeTree left;

public MeTree right;

public int id;

public int level;

private static int count  =   0 ; 

public  MeTree( int  depth)   {

      id  = count ++ ;

      level  =  depth;

     if  (depth  >   0 )   {



        left  =   new  MeTree(depth - 1 );

        right  =   new  MeTree(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( " MeTree.tmp " );

         /**/ /* 创建输出流 */ 

        ObjectOutputStream p  =   new  ObjectOutputStream(ostream);

         /**/ /* 创建一个二层的树。 */ 

        MeTree base  =   new  MeTree( 2 );

        p.writeObject(base);  // 将树写入流中。

         p.writeObject( " LiLy is 惠止南国 " );

        p.flush();

        ostream.close();     // 关闭文件。



          /**/ /* 打开文件并设置成从中读取对象。 */ 

        FileInputStream istream  =   new  FileInputStream( " MeTree.tmp " );

        ObjectInputStream q  =   new  ObjectInputStream(istream);

         /**/ /* 读取树对象，以及所有子树 */ 

        MeTree new_MeTree  =  (MeTree)q.readObject();

        new_MeTree.print( 2 );   // 打印出树形结构的最上面 ２级

         String name  =  (String)q.readObject();

        System.out.println( " /n " + name);

    }   catch  (Exception ex)   {

        ex.printStackTrace();

    } 

 }

}

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

在序列化时，有几点要注意的：

　１：当一个对象被序列化时，只保存对象的非静态成员变量，不能保存任何的成员方法和静态的成员变量。

　　２：如果一个对象的成员变量是一个对象，那么这个对象的数据成员也会被保存。

　　３：如果一个可序列化的对象包含对某个不可序列化的对象的引用，那么整个序列化操作将会失败，并且会抛出一个NotSerializableException。我们可以将这个引用标记为transient，那么对象仍然可以序列化

还有我们对某个对象进行序列化时候，往往对整个对象全部序列化了，比如说类里有些数据比较敏感，不希望序列化，一个方法可以用transient来标识，另一个方法我们可以在类里重写

可以通过指定关键transient使对象中的某个数据元素不被还原，这种方式常用于安全上的保护。比如对象中保存的密码。

//**

transient 只能用在类的成员变量上,不能用在方法里.

transient 变量不能是final和static的

transient（临时）关键字

控制序列化过程时，可能有一个特定的子对象不愿让Java的序列化机制自动保存与恢复。一般地，若那个子对象包含了不想序列化的敏感信息（如密码），就会面临这种情况。即使那种信息在对象中具有“private”（私有）属性，但一旦经序列化处理，人们就可以通过读取一个文件，或者拦截网络传输得到它。

为防止对象的敏感部分被序列化，一个办法是将自己的类实现为Externalizable，就象前面展示的那样。这样一来，没有任何东西可以自动序列化，只能在writeExternal()明确序列化那些需要的部分。

然而，若操作的是一个Serializable对象，所有序列化操作都会自动进行。为解决这个问题，

可以用transient（临时）逐个字段地关闭序列化，它的意思是“不要麻烦你（指自动机制）保存或恢复它了——我会自己处理的”。

例如，假设一个Login对象包含了与一个特定的登录会话有关的信息。校验登录的合法性时，一般都想将数据保存下来，但不包括密码。

为做到这一点，最简单的办法是实现Serializable，并将password字段设为transient。

password被设为transient，

所以不会自动保存到磁盘；另外，自动序列化机制也不会作恢复它的尝试。

一旦对象恢复成原来的样子，password字段就会变成null。注意必须用toString()检查password是否为null，因为若用过载的“+”运算符来装配一个String对象，而且那个运算符遇到一个null句柄，就会造成一个名为NullPointerException的违例（新版Java可能会提供避免这个问题的代码）。

我们也发现date字段被保存到磁盘，并从磁盘恢复，没有重新生成。

由于Externalizable对象默认时不保存它的任何字段，所以transient关键字只能伴随Serializable使用。

**//　还有我们对某个对象进行序列化时候，往往对

整个对象全部序列化了，比如说类里有些数据比较敏感，不希望序列化，一个方法可以用transient来标识，另一个方法我们可以在类里重写