有关Java对象的序列化和反序列化也算是Java基础的一部分，下面对Java序列化的机制和原理进行一些介绍。
Java序列化算法透析
Serialization（序列化）是一种将对象以一连串的字节描述的过程；反序列化deserialization是一种将这些字节重建成一个对象的过程。Java序列化API提供一种处理对象序列化的标准机制。在这里你能学到如何序列化一个对象，什么时候需要序列化以及Java序列化的算法，我们用一个实例来示范序列化以后的字节是如何描述一个对象的信息的。
序列化的必要性
Java中，一切都是对象，在分布式环境中经常需要将Object从这一端网络或设备传递到另一端。这就需要有一种可以在两端传输数据的协议。Java序列化机制就是为了解决这个问题而产生。
如何序列化一个对象
一个对象能够序列化的前提是实现Serializable接口，Serializable接口没有方法，更像是个标记。有了这个标记的Class就能被序列化机制处理。
package serializable;
import java.io.Serializable;
public class TestSerial implements Serializable {
/**
*
*/
private static final long serialVersionUID = 1L;
public byte version = 100;
public byte count = 0;
}
然后我们写个程序将对象序列化并输出。ObjectOutputStream能把Object输出成Byte流。我们将Byte流暂时存储到temp.out文件里。
package serializable;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class Test1 {
public static void main(String args[]) throws IOException {
FileOutputStream fos = new FileOutputStream("D:"+File.separator + "temp" + File.separator + "temp.out");
ObjectOutputStream oos = new ObjectOutputStream(fos);
TestSerial ts = new TestSerial();
oos.writeObject(ts);
oos.flush();
oos.close();
}
}
如果要从持久的文件中读取Bytes重建对象，我们可以使用ObjectInputStream。
package serializable;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
public class DeTest {
public static void main(String args[]) throws IOException, ClassNotFoundException {
FileInputStream fis = new FileInputStream("D:"+File.separator + "temp" + File.separator + "temp.out");
ObjectInputStream oin = new ObjectInputStream(fis);
TestSerial ts = (TestSerial) oin.readObject();
System.out.println("version="+ts.version);
}
}
执行结果为：
version=100
对象的序列化格式
将一个对象序列化后是什么样子呢？打开刚才我们将对象序列化输出的temp.out文件，以16进制方式显示。内容应该如下：
这一坨字节就是用来描述序列化以后的
TestSerial对象的，我们注意到TestSerial类中只有两个域：
public byte version = 100;
public byte count = 0;
且都是byte型，理论上存储这两个域只需要2个byte，但是实际上temp.out占据空间为64bytes，也就是说除了数据以外，还包括了对序列化对象的其他描述。
Java的序列化算法
序列化算法一般会按步骤做如下事情：
◆将对象实例相关的类元数据输出。
◆递归地输出类的超类描述直到不再有超类。
◆类元数据完了以后，开始从最顶层的超类开始输出对象实例的实际数据值。
◆从上至下递归输出实例的数据
我们用另一个更完整覆盖所有可能出现的情况的例子来说明：
package serializable;
import java.io.Serializable;
public class Parent implements Serializable {
private static final long serialVersionUID = 1L;
int parentVersion = 10;
}
package serializable;
import java.io.Serializable;
public class Contain implements Serializable {
/**
*
*/
private static final long serialVersionUID = 1L;
int containVersion = 11;
}
package serializable;
import java.io.Serializable;
public class SerialTest extends Parent implements Serializable {
/**
*
*/
private static final long serialVersionUID = 1L;
int version = 66;
Contain con = new Contain();
public int getVersion() {
return version;
}
}
package serializable;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class Test2 {
public static void main(String args[]) throws IOException {
FileOutputStream fos = new FileOutputStream("D:" +File.separator+ "temp" + File.separator + "temp.out");
ObjectOutputStream oos = new ObjectOutputStream(fos);
SerialTest st = new SerialTest();
oos.writeObject((Parent)st);
oos.flush();
oos.close();
}
}
这个例子是相当的直白啦。SerialTest类实现了Parent超类，内部还持有一个Container对象。
序列化后的格式如下：
AC ED 00 05 73 72 00 17 73 65 72 69 61 6C 69 7A
61 62 6C 65 2E 53 65 72 69 61 6C 54 65 73 74 00
00 00 00 00 00 00 01 02 00 02 49 00 07 76 65 72
73 69 6F 6E 4C 00 03 63 6F 6E 74 00 16 4C 73 65
72 69 61 6C 69 7A 61 62 6C 65 2F 43 6F 6E 74 61
69 6E 3B 78 72 00 13 73 65 72 69 61 6C 69 7A 61
62 6C 65 2E 50 61 72 65 6E 74 00 00 00 00 00 00
00 01 02 00 01 49 00 0D 70 61 72 65 6E 74 56 65
72 73 69 6F 6E 78 70 00 00 00 0A 00 00 00 42 73
72 00 14 73 65 72 69 61 6C 69 7A 61 62 6C 65 2E
43 6F 6E 74 61 69 6E 00 00 00 00 00 00 00 01 02
00 01 49 00 0E 63 6F 6E 74 61 69 6E 56 65 72 73
69 6F 6E 78 70 00 00 00 0B
我们来仔细看看这些字节都代表了啥。开头部分，见颜色：
1. AC ED: STREAM_MAGIC. 声明使用了序列化协议.
2. 00 05: STREAM_VERSION. 序列化协议版本.
3. 0x73: TC_OBJECT. 声明这是一个新的对象.
序列化算法的第一步就是输出对象相关类的描述。例子所示对象为SerialTest类实例，因此接下来输出SerialTest类的描述。见颜色：
1. 0x72: TC_CLASSDESC. 声明这里开始一个新Class。
2. 00 17: Class名字的长度.
3. 73 65 72 69 61 6C 69 7A 61 62 6C 65：serializable 序列化
4. 2E 53 65 72 69 61 6C 54 65 73 74 00：.SerialTest.类名称
5. 00 00 00 00 00 00 01: SerialVersionUID, 序列化ID，如果没有指定，则会由算法随机生成一个 8byte的ID.
6. 0x02: 标记号. 该值声明该对象支持序列化。
7. 00 02: 该类所包含的域个数。
接下来，算法输出其中的一个域，int version=66；见颜色：
1. 0x49: 域类型. 49 代表"I", 也就是Int.
2. 00 07: 域名字的长度.
3. 76 65 72 73 69 6F 6E: version,域名字描述.
然后，算法输出下一个域，contain con = new contain();这个有点特殊，是个对象。描述对象类型引用时需要使用JVM的标准对象签名表示法，见颜色：
1. 0x4C: 域的类型L.
2. 00 03: 域名字长度.
3. 63 6F 6E: 域名字描述，con
4. 0x74: TC_STRING. 代表一个new String.用String来引用对象。
5. 00 16: 该String长度.
6. 4C 73 65 72 69 61 6C 69 7A 61 62 6C 65 2F 43 6F 6E 74 69 6E 3B: Lserializable/Contain. JVM的标准对象签名表示法.
7. 0x78: TC_ENDBLOCKDATA,对象数据块结束的标志
.接下来算法就会输出超类也就是Parent类描述了，见颜色：
1. 0x72: TC_CLASSDESC. 声明这个是个新类.
2. 00 13: 类名长度.
3. 73 65 72 69 61 6C 69 7A 61 62 6C 65 2E 50 61 72 65 6E 74: serializable.Parent,类名描
述。
4. 00 00 00 00 00 00 00 01: SerialVersionUID, 序列化ID.
5. 0x02: 标记号. 该值声明该对象支持序列化.
6. 00 01: 类中域的个数.
下一步，输出parent类的域描述，int parentVersion=100;同见颜色：
1. 0x49: 域类型. 49 代表"I", 也就是Int.
2. 00 0D: 域名字长度.
3. 70 61 72 65 6E 74 56 65 72 73 69 6F 6E: parentVersion，域名字描述。
4. 0x78: TC_ENDBLOCKDATA,对象块结束的标志。
5. 0x70: TC_NULL, 说明没有其他超类的标志。.
到此为止，算法已经对所有的类的描述都做了输出。下一步就是把实例对象的实际值输出了。这时候是从parent Class的域开始的，见颜色：
1. 00 00 00 0A: 10, parentVersion域的值.
还有SerialTest类的域：
2. 00 00 00 42: 66, version域的值.
再往后的bytes比较有意思，算法需要描述contain类的信息，要记住，现在还没有对contain类进行过描述，见颜色：
1. 0x73: TC_OBJECT, 声明这是一个新的对象.
2. 0x72: TC_CLASSDESC声明这里开始一个新Class.
3. 00 14: 类名的长度.
4. 73 65 72 69 61 6C 69 7A 61 62 6C 65 2E 43 6F 6E 74 61 69 6E serializable.Contain,类名描 述.
5. 00 00 00 00 00 00 00 01: SerialVersionUID, 序列化ID
6. 0x02: Various flags. 标记号. 该值声明该对象支持序列化
7. 00 01: 类内的域个数。
.输出contain的唯一的域描述，int containVersion=11；
1. 0x49: 域类型. 49 代表"I", 也就是Int..
2. 00 0E: 域名字长度.
3. 63 6F 6E 74 61 69 6E 56 65 72 73 69 6F 6E: containVersion, 域名字描述.
4. 0x78: TC_ENDBLOCKDATA对象块结束的标志.
这时，序列化算法会检查contain是否有超类，如果有的话会接着输出。
1. 0x70:TC_NULL，没有超类了。
最后，将contain类实际域值输出。
1. 00 00 00 0B: 11, containVersion的值.
OK,我们讨论了java序列化的机制和原理，希望能对大家有所帮助。
相关推荐
java 序列化和反序列化的方法 Java 序列化和反序列化是 Java 语言中的一种机制，用于将对象转换为字节流，以便在网络上传输或存储。序列化是将对象转换为字节流的过程，而反序列化是将字节流转换回对象的过程。 在...
Java序列化是Java平台中的一种持久化机制，它允许对象的状态被转换成字节流，以便存储、网络传输或在不同时间点恢复。这个过程被称为序列化，而反向操作称为反序列化。序列化在许多场景下都非常有用，比如在分布式...
【Protocol Buffer序列化对比Java序列化】 Protocol Buffer（简称PB）是Google开发的一种高效的数据序列化协议，而Java序列化是Java平台内置的一种序列化机制。两者的主要目标都是将对象转化为字节数组，便于在网络...
Java序列化是Java平台中的一种标准机制，允许将对象的状态转换为字节流，以便存储在磁盘上、通过网络进行传输或者在某些时候恢复原来的对象状态。这一过程包括两个主要步骤：对象的序列化（将对象转换为字节流）和反...
Java反序列化是一种将已序列化的对象状态转换回对象的过程，它是Java平台中持久化数据的一种常见方式。在Java应用程序中，序列化用于保存对象的状态以便稍后恢复，或者在网络间传输对象。然而，这个过程也可能引入...
在Java编程中，序列化是将对象的状态转换为字节流的过程，以便可以存储或在网络上传输。这个过程使得对象可以在不同的时间或者不同的系统之间进行恢复。然而，有时候我们不希望序列化对象的所有属性，可能是因为某些...
Java序列化是Java平台中的一种核心机制，它允许对象的状态被转换成字节流，以便存储到磁盘、数据库，或者在网络中进行传输。这对于实现持久化、远程方法调用（RMI）以及Enterprise JavaBeans（EJB）等高级功能至关...
#### Java序列化算法透析 Java序列化的核心是将对象转换为字节流，这涉及到一系列复杂的操作步骤。 ##### 序列化算法示例 为了更好地理解序列化的过程，我们可以通过一个简单的例子来进行说明。 ```java import ...
Java序列化是Java平台中的一种标准机制，它允许将对象的状态转换为字节流，以便存储、传输或恢复。在Java中，一个类如果要实现序列化，需要实现`Serializable`接口，这是一个标记接口，不包含任何方法。下面我们将...
### Java序列化(Serializable)的作用与反序列化详解 #### 一、序列化是什么？ 序列化是指将程序中的对象转换为字节流的过程，从而方便存储或传输这些对象。通常，序列化用于将对象的状态（即其实例变量的值，而非...
Java序列化是Java平台中的一项重要技术，它允许对象的状态被转换为字节流，以便存储或通过网络进行传输。这种技术在分布式系统、持久化存储以及数据交换等场景中非常常见。本资源包含了三个流行的Java序列化框架：...
Java序列化是Java平台中的一种标准机制，允许对象的状态被保存到磁盘或者在网络中进行传输，以便在后续的时间或地点恢复这些对象。这个过程包括两个主要操作：序列化（将对象转换为字节流）和反序列化（将字节流恢复...
Java序列化是Java平台提供的一种将对象转换为字节流，以便存储、在网络上传输或者在后续时间重新创建相同对象的机制。这是Java编程中一个非常重要的概念，尤其是在分布式环境和持久化存储中。让我们深入探讨一下Java...
Xson是一个Java对象序列化和反序列化程序。支持Java对象到字节数组的序列化，和从字节数组到Java对象的反序列化。 Maven: <groupId>com.github.xsonorg</groupId> <artifactId>xson-core <version>1.0.1 ...
android(包括java)序列化一个对象传给php去做处理,或是接到php的序列化的对象在java中做处理的工具jar包以及使用方法. 使用方法: byte[] b = null; b = PHPSerializer.serialize(一个对象);//将一个对象序列化后返回...
**FST：快速Java序列化的替代方案** 在Java开发中，序列化是一个常见的需求，它允许将对象的状态转换为字节流，以便于存储或网络传输。标准的Java序列化虽然方便，但在处理大量数据时，性能往往成为瓶颈。这时，FST...
### Java序列化与反序列化详解 #### 一、Java序列化概述 Java序列化（Serialization）是一项重要的功能，它可以将对象的状态转化为一系列字节，从而实现对象的持久化存储或在网络上传输。序列化机制使得Java对象...
Java序列化面试题（10题） 在 Java 中，序列化是一种用于处理对象流的机制，它可以将对象的内容进行流化，使其可以被读写和传输。下面是 10 个与 Java 序列化相关的面试题目： 1. 什么是 Java 序列化，如何实现 ...
Java序列化是将Java对象转换为字节流的过程，以便可以在网络上传输或存储在磁盘上。这使得数据能够跨不同的系统平台进行传输和持久化。Protocol Buffers（protobuf）是Google推出的一种高效、跨平台的数据序列化协议...
而在Java中，我们可以通过实现`Serializable`接口来使类支持序列化，或者使用`java.io.ObjectOutputStream`和`java.io.ObjectInputStream`进行对象的序列化和反序列化。 接下来，我们讨论反序列化。反序列化是序列...