Java对象序列化与反序列化规范详解

需积分: 9 161 浏览量更新于2024-08-01 收藏 349KB PDF 举报

"serial-spec[1].pdf 是一份关于Java对象序列化和反序列化的规范文档，主要面向中高级开发人员，旨在详细阐述如何在Java系统中将对象转化为可存储或传输的序列化形式，以及如何从序列化数据恢复原始对象。此文档还讨论了不同版本的类如何能够读写兼容的序列化流，确保版本间的兼容性。" Java对象序列化是Java平台提供的一种机制，允许将对象的状态转换为字节流，以便于存储到磁盘、持久化到数据库，或者在网络间进行传输。这个过程不仅包含了对象的实例字段值，还包含了足够的类型信息，使得在任何支持Java的环境中都能重新创建出等价的对象。反序列化则是序列化的逆过程，它从字节流中恢复出原始的对象结构。重要的是，Java序列化机制设计了版本兼容性，即使类的版本发生了变化，只要遵循一定的规则，旧版本的代码依然可以正确地读取由新版本代码写出的序列化流。文档中的"Revision 1.4.4"表明这是该规范的一个特定修订版，版权归属于Sun Microsystems（现为Oracle Corporation的一部分），并提供了对实现该规范的许可条件。根据描述，Sun Microsystems授予用户一个无须额外付费、非排他性的、不可转让的、永久的、全球范围内的有限许可证，但不包括转授权的权利，并且仅限于创建和分发基于当前版本规范的“清洁室”实现。这里的“清洁室实现”通常指的是不参考源代码，而是独立实现规范所描述的功能。 Java序列化涉及的关键概念和组件包括： 1. `Serializable`接口：要序列化的类必须实现此接口，表明它们支持序列化。 2. `ObjectOutputStream`：用于写入序列化对象的输出流，它处理将Java对象转换为字节流的工作。 3. `ObjectInputStream`：用于从字节流中恢复对象的输入流，执行反序列化操作。 4. `writeObject()`和`readObject()`方法：这两个方法分别用于序列化和反序列化自定义类型的对象，允许开发者控制序列化过程。 5. `serialVersionUID`：每个可序列化类都有一个唯一的`serialVersionUID`，用于版本控制，防止因为类的修改导致序列化兼容性问题。此外，文档可能还会涵盖序列化过程中的优化技巧，如标记为transient或static的字段不会被序列化，以及如何处理复杂的对象图（包括循环引用）等高级主题。对于中高级开发人员来说，深入理解这份规范有助于编写更高效、更安全的序列化和反序列化代码。

Page 4 Java™ Object Serialization Specification

ObjectInputStream can be extended to utilize customized information in the

stream about classes or to replace objects that have been deserialized. Refer to the

resolveClass and resolveObject method descriptions for details.

1.4 Object Streams as Containers

Object Serialization produces and consumes a stream of bytes that contain one or more

primitives and objects. The objects written to the stream, in turn, refer to other objects,

which are also represented in the stream. Object Serialization produces just one stream

format that encodes and stores the contained objects.

Each object that acts as a container implements an interface which allows primitives

and objects to be stored in or retrieved from it. These interfaces are the

ObjectOutput and ObjectInput interfaces which:

• Provide a stream to write to and to read from

• Handle requests to write primitive types and objects to the stream

• Handle requests to read primitive types and objects from the stream

Each object which is to be stored in a stream must explicitly allow itself to be stored

and must implement the protocols needed to save and restore its state. Object

Serialization defines two such protocols. The protocols allow the container to ask the

object to write and read its state.

To be stored in an Object Stream, each object must implement either the

Serializable or the Externalizable interface:

• For a Serializable class, Object Serialization can automatically save and

restore fields of each class of an object and automatically handle classes that evolve

by adding fields or supertypes. A serializable class can declare which of its fields

are saved or restored, and write and read optional values and objects.

• For an Externalizable class, Object Serialization delegates to the class

complete control over its external format and how the state of the supertype(s) is

saved and restored.

1.5 Deﬁning Serializable Fields for a Class

The serializable fields of a class can be defined two different ways. Default serializable

fields of a class are defined to be the non-transient and non-static fields. This default

computation can be overridden by declaring a special field in the Serializable

Chapter 1: System Architecture Page 5

class, serialPersistentFields. This field must be initialized with an array of

ObjectStreamField objects that list the names and types of the serializable fields.

The modifiers for the field are required to be private, static, and final.

For example, the following declaration duplicates the default behavior.

class List implements Serializable {

List next;

private static final ObjectStreamField[] serialPersistentFields

= {new ObjectStreamField(“next”, List.class)};

}

By using serialPersistentFields to define the Serializable fields for a class,

there no longer is a limitation that a serializable field must be a field within the current

definition of the Serializable class. The writeObject and readObject

methods of the Serializable class can map the current implementation of the class

to the serializable fields of the class using the interface that is described in Section 1.7,

“Accessing Serializable Fields of a Class.” Therefore, the fields for a Serializable

class can change in a later release, as long as it maintains the mapping back to its

Serializable fields that must remain compatible across release boundaries.

Note – There is, however, a limitation to the use of this mechanism to specify

serializable fields for inner classes. Inner classes can only contain final static fields that

are initialized to constants or expressions built up from constants. Consequently, it is

not possible to set serialPersistentFields for an inner class (though it is

possible to set it for static member classes). For other restrictions pertaining to

serialization of inner class instances, see section Section 1.10, “The Serializable

Interface”.

1.6 Documenting Serializable Fields and Data for a Class

It is important to document the serializable state of a class to enable interoperability

with alternative implementations of a Serializable class and to document class

evolution. Documenting a serializable field gives one a final opportunity to review

whether or not the field should be serializable. The serialization javadoc tags,

@serial, @serialField, and @serialData, provide a way to document the

serialized form for a Serializable class within the source code.

Page 6 Java™ Object Serialization Specification

• The @serial tag should be placed in the javadoc comment for a default

serializable field. The syntax is as follows:

@serial field-description

The optional field-description describes the meaning of the field and its acceptable

values. The field-description can span multiple lines. When a field is added after the

initial release, a @since tag indicates the version the field was added. The field-

description for @serial provides serialization-specific documentation and is

appended to the javadoc comment for the field within the serialized form

documentation.

• The @serialField tag is used to document an ObjectStreamField component

of a serialPersistentFields array. One of these tags should be used for each

ObjectStreamField component. The syntax is as follows:

@serialField field-name field-type field-description

• The @serialData tag describes the sequences and types of data written or read.

The tag describes the sequence and type of optional data written by writeObject

or all data written by the Externalizable.writeExternal method. The

syntax is as follows:

@serialData data-description

The javadoc application recognizes the serialization javadoc tags and generates a

specification for each Serializable and Externalizable class. See Section C.1, “Example

Alternate Implementation of java.io.File” for an example that uses these tags.

When a class is declared Serializable, the serializable state of the object is defined by

serializable fields (by name and type) plus optional data. Optional data can only be

written explicitly by the writeObject method of a Serializable class. Optional

data can be read by the Serializable class’ readObject method or serialization

will skip unread optional data.

When a class is declared Externalizable, the data that is written to the stream by the

class itself defines the serialized state. The class must specify the order, types, and

meaning of each datum that is written to the stream. The class must handle its own

evolution, so that it can continue to read data written by and write data that can be read

by previous versions. The class must coordinate with the superclass when saving and

restoring data. The location of the superclasses data in the stream must be specified.

Chapter 1: System Architecture Page 7

The designer of a Serializable class must ensure that the information saved for the

class is appropriate for persistence and follows the serialization-specified rules for

interoperability and evolution. Class evolution is explained in greater detail in

Chapter 5, “Versioning of Serializable Objects.”

1.7 Accessing Serializable Fields of a Class

Serialization provides two mechanisms for accessing the serializable fields in a stream:

• The default mechanism requires no customization

• The Serializable Fields API allows a class to explicitly access/set the serializable

fields by name and type

The default mechanism is used automatically when reading or writing objects that

implement the Serializable interface and do no further customization. The

serializable fields are mapped to the corresponding fields of the class and values are

either written to the stream from those fields or are read in and assigned respectively.

If the class provides writeObject and readObject methods, the default

mechanism can be invoked by calling defaultWriteObject and

defaultReadObject. When the writeObject and readObject methods are

implemented, the class has an opportunity to modify the serializable field values before

they are written or after they are read.

When the default mechanism cannot be used, the serializable class can use the

putFields method of ObjectOutputStream to put the values for the serializable

fields into the stream. The writeFields method of ObjectOutputStream puts the

values in the correct order, then writes them to the stream using the existing protocol

for serialization. Correspondingly, the readFields method of

ObjectInputStream reads the values from the stream and makes them available to

the class by name in any order. See Section 2.2, “The ObjectOutputStream.PutField

Class” and Section 3.2, “The ObjectInputStream.GetField Class.” for a detailed

description of the Serializable Fields API.

1.8 The ObjectOutput Interface

The ObjectOutput interface provides an abstract, stream-based interface to object

storage. It extends the DataOutput interface so those methods can be used for writing

primitive data types. Objects that implement this interface can be used to store

primitives and objects.

剩余83页未读，继续阅读

helowken

粉丝: 0
资源: 4

Java对象序列化与反序列化规范详解

serial-ata-ahci-spec-rev1-3-1.pdf+SerialATA_Revision_2_6_Gold+AHCI command manul

USB 3.0 (11132008)-final Spec.pdf

"TI-PGA2310.pdf: 世界领先技术的多路复用串行控制音频芯片

virtual-serial-port-control.msi

run gts -m GtsGmscoreHostTestCases -t com.google.android.gts.security.AttestationRootHostTest#testEcAttestationChainRemProvLength 运行时,实际执行了哪些jar

F:\file_download\Python\python\python.exe E:\pyserial-master\pyserial-master\examples\tcp_serial_redirect.py -c 119.91.237.43:9006 --develop COM12

serial.Serial

通过https服务器证书生成客户端证书

代码解释void setup() { Serial.begin(9600); setSyncProvider(RTC.get); myservo.attach(9); Serial.begin(9600); SPI.begin(); mfrc522.PCD_Init();

最新资源