AI 助理
文档备案控制台
开发者社区 开发与运维 文章 正文

Java基础系列8：Java的序列化与反序列化（修）

2017-11-27 995
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

一 简介

对象序列化就是把一个对象变成二进制的数据流的一种方法，通过对象序列化可以方便地实现对象的传输和存储。

把对象转换为字节序列的过程称为对象的序列化

把字节序列恢复为对象的过程称为对象的反序列化

对象的序列化主要有两种用途：
1） 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；
2） 在网络上传送对象的字节序列。

对象序列化包括如下步骤：
1） 创建一个对象输出流，它可以包装一个其他类型的目标输出流，如文件输出流；
2） 通过对象输出流的writeObject()方法写对象。

对象反序列化包括如下步骤：
1） 创建一个对象输入流，它可以包装一个其他类型的源输入流，如文件输入流；
2） 通过对象输入流的readObject()方法读取对象。

在很多应用中，需要对某些对象进行序列化，让它们离开内存空间，入住物理硬盘，以便长期保存。比如最常见的是Web服务器中的Session对象，当有 10万用户并发访问，就有可能出现10万个Session对象，内存可能吃不消，于是Web容器就会把一些seesion先序列化到硬盘中，等要用了，再把保存在硬盘中的对象还原到内存中。

当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。发送方需要把这个Java对象转换为字节序列，才能在网络上传送；接收方则需要把字节序列再恢复为Java对象。


二 Java中的序列化API

如果一个类的对象想被序列化，那么该对象所在的类必须实现java.io.Serializable接口，此接口的定义如下：

public interface Serializable{}

可以发现此接口并没有定义任何的方法，只是一个标识接口，表示一个类可以被序列化，如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package  cn.zifangsky.serializable;
 
import  java.io.Serializable;
 
public  class  Person  implements  Serializable {
     private  static  final  long  serialVersionUID = 2651243789670519969L;
 
     private  String name;
     private  int  age;
 
     public  Person(String name,  int  age) {
         this .name = name;
         this .age = age;
     }
 
     public  String toString() {
         return  "Person [name="  + name +  ", age="  + age +  "]" ;
     }
 
}

就像上面这个Person类一样，实现了序列化接口表明此类的对象可以经过二进制的数据流进行传输了。但是如果想要完成对象的输入和输出，还需要借助对象输出流（ObjectOutputStream）和对象输入流（ObjectInputStream）

java.io.ObjectOutputStream代表对象输出流，它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中；java.io.ObjectInputStream代表对象输入流，它的readObject()方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回

只有实现了Serializable或Externalizable接口的类的对象才能被序列化。Externalizable接口继承自 Serializable接口，实现Externalizable接口的类完全由自身来控制序列化的行为，而仅实现Serializable接口的类可以 采用默认的序列化方式 。


三 使用Serializable接口实现的实例

首先定义了一个实现了Serializable接口WebSite的实体类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
package  cn.zifangsky.serializable;
 
import  java.io.Serializable;
 
public  class  WebSite  implements  Serializable {
     private  static  final  long  serialVersionUID = 1835573222135484360L;
 
     private  String siteName;
     private  String siteUrl;
     private  String webMaster;
 
     public  WebSite() {
 
     }
 
     public  WebSite(String siteName, String siteUrl, String webMaster) {
         this .siteName = siteName;
         this .siteUrl = siteUrl;
         this .webMaster = webMaster;
     }
 
     public  String getSiteName() {
         return  siteName;
     }
 
     public  void  setSiteName(String siteName) {
         this .siteName = siteName;
     }
 
     public  String getSiteUrl() {
         return  siteUrl;
     }
 
     public  void  setSiteUrl(String siteUrl) {
         this .siteUrl = siteUrl;
     }
 
     public  String getWebMaster() {
         return  webMaster;
     }
 
     public  void  setWebMaster(String webMaster) {
         this .webMaster = webMaster;
     }
 
     public  String toString() {
         return  "WebSite [siteName="  + siteName +  ", siteUrl="  + siteUrl +  ", webMaster="  + webMaster +  "]" ;
     }
 
}

然后进行序列化和反序列化测试：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
package  cn.zifangsky.serializable;
 
import  java.io.File;
import  java.io.FileInputStream;
import  java.io.FileNotFoundException;
import  java.io.FileOutputStream;
import  java.io.IOException;
import  java.io.ObjectInputStream;
import  java.io.ObjectOutputStream;
 
public  class  TestSerialize {
 
     public  static  void  main(String[] args)  throws  FileNotFoundException, IOException, ClassNotFoundException {
         TestSerialize.serializeWebSite();
         TestSerialize.deserializeWebSite();
     }
     
     /**
      * 使用ObjectOutputStream 序列化WebSite
      * @throws IOException 
      * @throws FileNotFoundException 
      * 
      * */
     public  static  void  serializeWebSite()  throws  FileNotFoundException, IOException{
         WebSite webSite =  new  WebSite();
         webSite.setSiteName( "zifangsky的个人博客" );
         webSite.setSiteUrl( "http://www.zifangsky.cn" );
         webSite.setWebMaster( "zifangsky" );
         
         //序列化
         ObjectOutputStream objectOutputStream =  new  ObjectOutputStream( new  FileOutputStream( new  File( "C:/Users/Administrator/Desktop/test.txt" )));
         objectOutputStream.writeObject(webSite);
         objectOutputStream.flush();
         objectOutputStream.close();
     }
     
     /**
      * 使用ObjectInputStream 反序列化WebSite
      * @throws IOException 
      * @throws FileNotFoundException 
      * @throws ClassNotFoundException 
      * 
      * */
     public  static  void  deserializeWebSite()  throws  FileNotFoundException, IOException, ClassNotFoundException{
         ObjectInputStream objectInputStream =  new  ObjectInputStream( new  FileInputStream( new  File( "C:/Users/Administrator/Desktop/test.txt" )));
         //反序列化
         WebSite webSite = (WebSite) objectInputStream.readObject();
         objectInputStream.close();
 
         System.out.println(webSite);
     }
     
}

输出：

1
WebSite [siteName=zifangsky的个人博客, siteUrl=http://www.zifangsky.cn, webMaster=zifangsky]

四 使用Externalizable接口实现的实例

被Serializable接口声明的类的对象的内容都将被序列化，如果现在用户希望自己制定序列化的内容，则可以让一个类实现Externalizable接口，此接口的定义如下：

public interface Externalizable extends java.io.Serializable {
 
    void writeExternal(ObjectOutput out) throws IOException;

    void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
}

其中，这两个方法的作用是：

i）writeExternal(ObjectOutput out) ：在此方法中制定要保存的属性信息，对象序列化时调用

ii）readExternal(ObjectInput in) ： 在此方法中读取被保存的信息，对象反序列化时调用


下面将以一个具体的实例来简单说明序列化和反序列化过程：

（1）实现了Externalizable接口的实体类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
package  cn.zifangsky.serializable;
 
import  java.io.Externalizable;
import  java.io.IOException;
import  java.io.ObjectInput;
import  java.io.ObjectOutput;
 
public  class  ExternalizableDemo  implements  Externalizable{
     private  String name;
     static  {
         System.out.println( "调用静态代码块" );
     }
 
     public  ExternalizableDemo() {
         System.out.println( "调用无参构造方法" );
     }
 
     public  ExternalizableDemo(String name) {
         this .name = name;
         System.out.println( "调用有参构造方法" );
     }
 
     public  String getName() {
         return  name;
     }
 
     public  void  setName(String name) {
         this .name = name;
     }
 
     public  String toString() {
         return  "ExternalizableDemo [name="  + name +  "]" ;
     }
     
     /**
      * ObjectOutputStream会调用writeExternal(ObjectOutput out))这个方法进行序列化
      * */
     public  void  writeExternal(ObjectOutput out)  throws  IOException {
         out.writeObject(name);
     }
 
     /**
      * ObjectInputStream会调用readExternal(ObjectInput in)这个方法进行反序列化
      * */
     public  void  readExternal(ObjectInput in)  throws  IOException, ClassNotFoundException {
         name = (String) in.readObject();
     }
 
}

（2）然后进行序列化和反序列化测试：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package  cn.zifangsky.serializable;
 
import  java.io.File;
import  java.io.FileInputStream;
import  java.io.FileNotFoundException;
import  java.io.FileOutputStream;
import  java.io.IOException;
import  java.io.ObjectInputStream;
import  java.io.ObjectOutputStream;
 
public  class  TestExternalizable {
 
     public  static  void  main(String[] args)  throws  FileNotFoundException, IOException, ClassNotFoundException {
         ExternalizableDemo demo =  new  ExternalizableDemo( "hello" );
         // 序列化
         ObjectOutputStream objectOutputStream =  new  ObjectOutputStream(
                 new  FileOutputStream( new  File( "C:/Users/Administrator/Desktop/test2.txt" )));
         objectOutputStream.writeObject(demo);
         objectOutputStream.flush();
         objectOutputStream.close();
         
         //反序列化
         ObjectInputStream objectInputStream =  new  ObjectInputStream( new  FileInputStream( new  File( "C:/Users/Administrator/Desktop/test2.txt" )));
         ExternalizableDemo demo2 = (ExternalizableDemo) objectInputStream.readObject();
         objectInputStream.close();
         System.out.println(demo2);     
     }
 
}

输出：

1
2
3
4
调用静态代码块
调用有参构造方法
调用无参构造方法
ExternalizableDemo [name=hello]

注：

（1）使用Externalizable进行序列化时，当读取对象时，会调用被序列化类的无参构造器去创建一个新的对象，然后再将被保存对象的字段的值分别填充到新对象中

（2）Externalizable接口与Serializable接口实现序列化的区别：

区别 Serializable Externalizable
实现负责度 实现简单，Java对其有内建支持 实现负责，由开发人员自己完成
执行效率 所有对象由Java统一保存，性能较低 开发人员自己决定保存那些对象，可能造成速度提升
保存信息 保存时占用空间大 部分存储，可能造成空间减小

（3）一个对象被序列化后，到底哪些内容被保存了下来，是属性还是方法？

答：只有属性被序列化。因为每个对象都有相同的方法，但是每个对象的属性却不一定相同，因此对象保存的只有属性信息，那么同样道理在进行序列化操作时也只有属性被序列化


五 transient关键字

当使用Serializable接口实现序列化操作时，如果一个对象中的某个属性不希望被序列化，那么就可以使用transient关键字进行声明

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package  cn.zifangsky.serializable;
import  java.io.Serializable;
 
public  class  WebSite  implements  Serializable {
     private  static  final  long  serialVersionUID = 1835573222135484360L;
 
     private  String siteName;
     private  String siteUrl;
     private  transient  String webMaster;
 
     public  WebSite(String siteName, String siteUrl, String webMaster) {
         this .siteName = siteName;
         this .siteUrl = siteUrl;
         this .webMaster = webMaster;
     }
 
     public  String toString() {
         return  "WebSite [siteName="  + siteName +  ", siteUrl="  + siteUrl +  ", webMaster="  + webMaster +  "]" ;
     }
 
}

在上面这个类中，不希望webMaster这个属性被序列化，因此把它用transient关键字进行修饰，接下来就是序列化与反序列化测试：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
package  cn.zifangsky.serializable;
 
import  java.io.File;
import  java.io.FileInputStream;
import  java.io.FileNotFoundException;
import  java.io.FileOutputStream;
import  java.io.IOException;
import  java.io.ObjectInputStream;
import  java.io.ObjectOutputStream;
 
public  class  TestSerialize {
 
     public  static  void  main(String[] args)  throws  FileNotFoundException,
             IOException, ClassNotFoundException {
         TestSerialize.serializeWebSite();
         TestSerialize.deserializeWebSite();
     }
 
     /**
      * 使用ObjectOutputStream 序列化WebSite
      * 
      * @throws IOException
      * @throws FileNotFoundException
      * 
      * */
     public  static  void  serializeWebSite()  throws  FileNotFoundException,
             IOException {
         WebSite webSite =  new  WebSite( "zifangsky的个人博客" , "http://www.zifangsky.cn" , "zifangsky" );
 
         // 序列化
         ObjectOutputStream objectOutputStream =  new  ObjectOutputStream(
                 new  FileOutputStream( new  File(
                         "C:/Users/Administrator/Desktop/test.txt" )));
         objectOutputStream.writeObject(webSite);
         objectOutputStream.flush();
         objectOutputStream.close();
     }
 
     /**
      * 使用ObjectInputStream 反序列化WebSite
      * 
      * @throws IOException
      * @throws FileNotFoundException
      * @throws ClassNotFoundException
      * 
      * */
     public  static  void  deserializeWebSite()  throws  FileNotFoundException,
             IOException, ClassNotFoundException {
         ObjectInputStream objectInputStream =  new  ObjectInputStream(
                 new  FileInputStream( new  File(
                         "C:/Users/Administrator/Desktop/test.txt" )));
         // 反序列化
         WebSite webSite = (WebSite) objectInputStream.readObject();
         objectInputStream.close();
 
         System.out.println(webSite);
     }
 
}

输出：

1
WebSite [siteName=zifangsky的个人博客, siteUrl=http://www.zifangsky.cn, webMaster=null]

从上面的输出可以看出，webMaster这个属性并没有被序列化




本文转自 pangfc 51CTO博客，原文链接：http://blog.51cto.com/983836259/1758247，如需转载请自行联系原作者

文章标签：
Java
技术小阿哥
目录
相关文章
凉凉心.
|
JSON 网络协议 安全
【Java】（10）进程与线程的关系、Tread类；讲解基本线程安全、网络编程内容；JSON序列化与反序列化
几乎所有的操作系统都支持进程的概念，进程是处于运行过程中的程序，并且具有一定的独立功能，进程是系统进行资源分配和调度的一个独立单位一般而言，进程包含如下三个特征。独立性动态性并发性。
凉凉心.
708 1
凉凉心.
|
JSON 网络协议 安全
【Java基础】（1）进程与线程的关系、Tread类；讲解基本线程安全、网络编程内容；JSON序列化与反序列化
几乎所有的操作系统都支持进程的概念，进程是处于运行过程中的程序，并且具有一定的独立功能，进程是系统进行资源分配和调度的一个独立单位一般而言，进程包含如下三个特征。独立性动态性并发性。
凉凉心.
635 1
程序员小假
|
JSON 安全 Java
说一说 Java 反序列化漏洞
我是小假 期待与你的下一次相遇 ~
程序员小假
470 1
说一说 Java 反序列化漏洞
啦啦啦191
|
存储 Java 程序员
Java 基础知识点全面梳理包含核心要点及难点解析 Java 基础知识点
本文档系统梳理了Java基础知识点，涵盖核心特性、语法基础、面向对象编程、数组字符串、集合框架、异常处理及应用实例，帮助初学者全面掌握Java入门知识，提升编程实践能力。附示例代码下载链接。
啦啦啦191
648 0
啦啦啦191
|
存储 安全 Java
2025 年最新 40 个 Java 基础核心知识点全面梳理一文掌握 Java 基础关键概念
本文系统梳理了Java编程的40个核心知识点，涵盖基础语法、面向对象、集合框架、异常处理、多线程、IO流、反射机制等关键领域。重点包括：JVM运行原理、基本数据类型、封装/继承/多态三大特性、集合类对比（ArrayList vs LinkedList、HashMap vs TreeMap）、异常分类及处理方式、线程创建与同步机制、IO流体系结构以及反射的应用场景。这些基础知识是Java开发的根基，掌握后能为后续框架学习和项目开发奠定坚实基础。文中还提供了代码资源获取方式，方便读者进一步实践学习。
啦啦啦191
3431 2
蓝易云
|
存储 安全 Java
深入理解Java序列化接口及其实现机制
记住，序列化不仅仅是把对象状态保存下来那么简单，它涉及到类的版本控制、安全性和性能等多个重要方面。正确理解和实现Java序列化机制对于构建高效、安全和可维护的Java应用至关重要。
蓝易云
453 0
热爱技术的小郑
|
存储 Java
【IO面试题 四】、介绍一下Java的序列化与反序列化
Java的序列化与反序列化允许对象通过实现Serializable接口转换成字节序列并存储或传输，之后可以通过ObjectInputStream和ObjectOutputStream的方法将这些字节序列恢复成对象。
热爱技术的小郑
566 2
程序员小假
|
JSON Java 数据库连接
Java 序列化和反序列化为什么要实现 Serializable 接口
我是小假 期待与你的下一次相遇 ~
程序员小假
455 1
游客moiomvrp3vyac2
|
存储 安全 Java
Java编程中的对象序列化与反序列化
【10月更文挑战第22天】在Java的世界里，对象序列化和反序列化是数据持久化和网络传输的关键技术。本文将带你了解如何在Java中实现对象的序列化与反序列化，并探讨其背后的原理。通过实际代码示例，我们将一步步展示如何将复杂数据结构转换为字节流，以及如何将这些字节流还原为Java对象。文章还将讨论在使用序列化时应注意的安全性问题，以确保你的应用程序既高效又安全。
游客moiomvrp3vyac2
311 4
历年考试不作弊
|
存储 安全 Java
Java编程中的对象序列化与反序列化
【10月更文挑战第3天】在Java编程的世界里，对象序列化与反序列化是实现数据持久化和网络传输的关键技术。本文将深入探讨Java序列化的原理、应用场景以及如何通过代码示例实现对象的序列化与反序列化过程。从基础概念到实践操作，我们将一步步揭示这一技术的魅力所在。
历年考试不作弊
352 4

热门文章

最新文章

  • 1
    【原创】ASP.NET WebApi接收xml文件 xml序列化
  • 2
    几种Java常用序列化框架的选型与对比
  • 3
    C# 对象二进制序列化
  • 4
    Gson流式序列化JsonWriter
  • 5
    Netty 使用 Protobuf 序列化，太强大了！
  • 6
    关于对象的序列化
  • 7
    Java JSON序列化杂谈
  • 8
    跨语言的艺术:Weblogic 序列化漏洞和 IIOP 协议
  • 9
    Gson序列化输出Ignore策略 -- Map篇
  • 10
    Java 序列化笔记
  • 1
    Java 设计模式之策略模式：灵活切换算法的艺术
    3069
  • 2
    Java 设计模式之观察者模式：构建松耦合的事件响应系统
    961
  • 3
    Java 设计模式之状态模式：让对象的行为随状态优雅变化
    1332
  • 4
    java零基础学习者入门课程
    1005
  • 5
    Java 设计模式之责任链模式：优雅处理请求的艺术
    1371
  • 6
    【Azure Storage Account】Java Code访问Storage Account File Share的上传和下载代码示例
    836
  • 7
    百宝箱开放平台 ✖️ Java SDK
    2066
  • 8
    《深入理解Spring》：现代Java开发的核心框架
    1410
  • 9
    用Java语言实现一个自定义的ArrayList类
    658
  • 10
    从混沌到秩序：Java共享内存模型如何通过显式约束驯服并发？
    658

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0
    • 下一篇
    一条命令迁移，帮你实现 OpenClaw 与 Hermes Agent 记忆互通！