鸿蒙OS ObjectInputStream

ObjectInputStream

java.lang.Object

|—java.io.InputStream

|—|—java.io.ObjectInputStream

public class ObjectInputStream
extends InputStream
implements ObjectInput, ObjectStreamConstants

ObjectInputStream 反序列化以前使用 ObjectOutputStream 编写的原始数据和对象。

当分别与 FileOutputStream 和 FileInputStream 一起使用时，ObjectOutputStream 和 ObjectInputStream 可以为应用程序提供对象图的持久存储。 ObjectInputStream 用于恢复之前序列化的那些对象。 其他用途包括使用套接字流在主机之间传递对象或在远程通信系统中编组和解组参数和参数。

ObjectInputStream 确保从流创建的图中所有对象的类型与 Java 虚拟机中存在的类匹配。 使用标准机制根据需要加载类。

只有支持 java.io.Serializable 或 java.io.Externalizable 接口的对象才能从流中读取。

readObject 方法用于从流中读取对象。 应该使用 Java 的安全转换来获得所需的类型。 在 Java 中，字符串和数组是对象，在序列化过程中被视为对象。 读取时需要将它们转换为预期的类型。

可以使用 DataInput 上的适当方法从流中读取原始数据类型。

对象的默认反序列化机制将每个字段的内容恢复为写入时的值和类型。反序列化过程会忽略声明为瞬态或静态的字段。对其他对象的引用会导致根据需要从流中读取这些对象。使用参考共享机制正确恢复对象图。反序列化时总是分配新对象，这样可以防止现有对象被覆盖。

读取对象类似于运行新对象的构造函数。为对象分配内存并初始化为零 (NULL)。为不可序列化类调用无参数构造函数，然后从流中恢复可序列化类的字段，从最接近 java.lang.object 的可序列化类开始，到对象最具体的类结束。

例如，从 ObjectOutputStream 中的示例编写的流中读取：

      FileInputStream fis = new FileInputStream("t.tmp");
      ObjectInputStream ois = new ObjectInputStream(fis);

      int i = ois.readInt();
      String today = (String) ois.readObject();
      Date date = (Date) ois.readObject();

      ois.close();

类通过实现 java.io.Serializable 或 java.io.Externalizable 接口来控制它们的序列化方式。

实现 Serializable 接口允许对象序列化保存和恢复对象的整个状态，它允许类在写入流和读取流之间演变。 它自动遍历对象之间的引用，保存和恢复整个图形。

在序列化和反序列化过程中需要特殊处理的可序列化类应实现以下方法：

 private void writeObject(java.io.ObjectOutputStream stream)
     throws IOException;
 private void readObject(java.io.ObjectInputStream stream)
     throws IOException, ClassNotFoundException;
 private void readObjectNoData()
     throws ObjectStreamException;

readObject 方法负责使用由相应的 writeObject 方法写入流的数据读取和恢复其特定类的对象状态。该方法不需要关注属于其超类或子类的状态。通过从 ObjectInputStream 读取各个字段的数据并对对象的适当字段进行分配来恢复状态。 DataInput 支持读取原始数据类型。

任何超出相应 writeObject 方法写入的自定义数据边界的对象数据的读取尝试都将导致抛出 OptionalDataException，并且 eof 字段值为 true。超过分配数据结尾的非对象读取将反映数据的结尾，就像它们指示流的结尾一样：按字节读取将返回 -1 作为字节读取或读取的字节数，以及原始读取将抛出 EOFExceptions。如果没有对应的 writeObject 方法，则默认序列化数据的结尾标志着分配数据的结尾。

从 readExternal 方法中发出的原始和对象读取调用的行为方式相同 – 如果流已经位于相应 writeExternal 方法写入的数据的末尾，则对象读取将抛出 OptionalDataExceptions 并将 eof 设置为 true，按字节读取将返回 -1，原始读取将抛出 EOFExceptions。请注意，此行为不适用于使用旧的 ObjectStreamConstants.PROTOCOL_VERSION_1 协议编写的流，其中 writeExternal 方法写入的数据的结尾未划分，因此无法检测到。

如果序列化流未将给定类列为被反序列化对象的超类，readObjectNoData 方法负责为其特定类初始化对象的状态。这可能发生在接收方使用与发送方不同版本的反序列化实例类的情况下，并且接收方的版本扩展了发送方版本未扩展的类。如果序列化流已被篡改，也可能发生这种情况；因此，尽管存在“敌对”或不完整的源流，但 readObjectNoData 对于正确初始化反序列化对象很有用。

序列化不会读取或赋值给任何未实现 java.io.Serializable 接口的对象的字段。不可序列化的对象的子类可以是可序列化的。在这种情况下，不可序列化的类必须有一个无参数的构造函数来允许其字段被初始化。在这种情况下，子类负责保存和恢复不可序列化类的状态。通常情况下，该类的字段是可访问的（公共的、包的或受保护的），或者存在可用于恢复状态的 get 和 set 方法。

反序列化对象时发生的任何异常都将被 ObjectInputStream 捕获并中止读取过程。

实现 Externalizable 接口允许对象完全控制对象序列化形式的内容和格式。调用 Externalizable 接口的方法 writeExternal 和 readExternal 来保存和恢复对象状态。当由一个类实现时，它们可以使用 ObjectOutput 和 ObjectInput 的所有方法写入和读取自己的状态。对象负责处理发生的任何版本控制。

枚举常量的反序列化方式与普通可序列化或可外部化对象不同。枚举常量的序列化形式仅由其名称组成；不传输常量的字段值。为了反序列化一个枚举常量，ObjectInputStream 从流中读取常量名；然后通过使用枚举常量的基类型和接收的常量名称作为参数调用静态方法 Enum.valueOf(Class, String) 来获得反序列化的常量。与其他可序列化或可外部化的对象一样，枚举常量可以充当随后出现在序列化流中的反向引用的目标。无法自定义枚举常量的反序列化过程：在反序列化过程中，将忽略枚举类型定义的任何特定于类的 readObject、readObjectNoData 和 readResolve 方法。同样，任何 serialPersistentFields 或 serialVersionUID 字段声明也将被忽略——所有枚举类型都有一个固定的 serialVersionUID 为 0L。

Since:

JDK1.1

嵌套类摘要

字段摘要

构造函数摘要

方法总结

构造函数详细信息

ObjectInputStream

public ObjectInputStream(InputStream in) throws IOException

创建一个从指定 InputStream 读取的 ObjectInputStream。 从流中读取序列化流标头并进行验证。 此构造函数将阻塞，直到相应的 ObjectOutputStream 已写入并刷新标头。

如果安装了安全管理器，则此构造函数将在由覆盖 ObjectInputStream.readFields 或 ObjectInputStream.readUnshared 方法的子类的构造函数直接或间接调用时检查“enableSubclassImplementation”SerializablePermission。

参数：

Throws:

ObjectInputStream

protected ObjectInputStream() throws IOException, SecurityException

为完全重新实现 ObjectInputStream 的子类提供一种方法，使其不必分配刚刚由 ObjectInputStream 的实现使用的私有数据。

如果安装了安全管理器，此方法首先调用安全管理器的 checkPermission 方法，并带有 SerializablePermission(“enableSubclassImplementation”) 权限，以确保可以启用子类化。

Throws:

方法详情

readObject

public final Object readObject() throws ClassNotFoundException, IOException

从 ObjectInputStream 中读取一个对象。读取对象的类、类的签名以及类及其所有超类型的非瞬态和非静态字段的值。可以使用 writeObject 和 readObject 方法覆盖类的默认反序列化。此对象引用的对象被传递读取，以便通过 readObject 重建对象的完整等效图。

当根对象的所有字段和它引用的对象完全恢复时，根对象将完全恢复。此时，对象验证回调将根据其注册的优先级按顺序执行。回调由对象注册（在 readObject 特殊方法中），因为它们是单独恢复的。

对于 InputStream 的问题和不应反序列化的类会引发异常。所有异常对 InputStream 来说都是致命的，并使其处于不确定状态；由调用者忽略或恢复流状态。

指定者：

接口 ObjectInput 中的 readObject

返回：

从流中读取的对象

Throws:

readObjectOverride

protected Object readObjectOverride() throws ClassNotFoundException, IOException

此方法由使用受保护的无参数构造函数构造 ObjectOutputStream 的 ObjectOutputStream 的受信任子类调用。 子类应提供带有修饰符“final”的覆盖方法。

返回:

从流中读取的对象。

Throws:

Since:

1.2

readUnshared

public Object readUnshared() throws ClassNotFoundException, IOException

从 ObjectInputStream 中读取一个“非共享”对象。 此方法与 readObject 相同，只是它阻止对 readObject 和 readUnshared 的后续调用返回对通过此调用获得的反序列化实例的附加引用。 具体来说：

• 如果调用 readUnshared 来反序列化反向引用（之前已写入流的对象的流表示），将抛出 ObjectStreamException。
• 如果 readUnshared 成功返回，则任何后续尝试反序列化对由 readUnshared 反序列化的流句柄的反向引用将导致抛出 ObjectStreamException。

通过 readUnshared 反序列化对象会使与返回对象关联的流句柄无效。请注意，这本身并不总是保证 readUnshared 返回的引用是唯一的；反序列化的对象可以定义一个 readResolve 方法，该方法返回一个对其他方可见的对象，或者 readUnshared 可以返回一个 Class 对象或枚举常量，可在流中的其他地方或通过外部方式获得。如果反序列化的对象定义了一个 readResolve 方法并且该方法的调用返回一个数组，那么 readUnshared 返回该数组的一个浅克隆；这保证了返回的数组对象是唯一的，并且不能从 ObjectInputStream 上的 readObject 或 readUnshared 调用第二次获得，即使底层数据流已被操作。

覆盖此方法的 ObjectInputStream 子类只能在拥有“enableSubclassImplementation”SerializablePermission 的安全上下文中构造；任何尝试在没有此权限的情况下实例化此类子类都将导致抛出 SecurityException。

返回：

对反序列化对象的引用

Throws:

Since:

1.4

defaultReadObject

public void defaultReadObject() throws ClassNotFoundException, IOException

从此流中读取当前类的非静态和非瞬态字段。 这只能从被反序列化的类的 readObject 方法中调用。 如果以其他方式调用它将抛出 NotActiveException。

Throws:

readFields

public ObjectInputStream.GetField readFields() throws ClassNotFoundException, IOException

从流中读取持久字段并通过名称使它们可用。

返回:

表示正在反序列化的对象的持久字段的 GetField 对象

Throws:

Since:

1.2

registerValidation

public void registerValidation(ObjectInputValidation obj, int prio) throws InvalidObjectException, NotActiveException

在返回图之前注册一个要验证的对象。 虽然与 resolveObject 类似，但这些验证是在整个图重构后调用的。 通常，readObject 方法会将对象注册到流中，以便在恢复所有对象时可以执行最终的一组验证。

参数：

Throws:

resolveClass

protected Class<?> resolveClass(ObjectStreamClass desc) throws ClassNotFoundException, IOException

加载指定流类描述的本地类等价物。 子类可以实现此方法以允许从备用源获取类。

ObjectOutputStream 中对应的方法是annotateClass。 对于流中的每个唯一类，该方法只会被调用一次。 此方法可由子类实现以使用备用加载机制，但必须返回 Class 对象。 一旦返回，如果该类不是数组类，则将其serialVersionUID与序列化类的serialVersionUID进行比较，如果不匹配，则反序列化失败并抛出InvalidClassException。

ObjectInputStream中该方法的默认实现返回调用的结果

     Class.forName(desc.getName(), false, loader) 

其中 loader 确定如下：如果当前线程的堆栈上有一个方法，其声明类是由用户定义的类加载器定义的（并且不是为实现反射调用而生成的），则 loader 是对应于最近的类加载器 这种方法对当前执行的帧； 否则，加载程序为空。 如果此调用导致 ClassNotFoundException 并且传递的 ObjectStreamClass 实例的名称是原始类型或 void 的 Java 语言关键字，则将返回表示该原始类型或 void 的 Class 对象（例如，名称为“int”的 ObjectStreamClass ” 将被解析为 Integer.TYPE)。 否则，ClassNotFoundException 将被抛出给该方法的调用者。

参数：

返回:

对应于 desc 的 Class 对象

Throws:

resolveProxyClass

protected Class<?> resolveProxyClass(String[] interfaces) throws ClassNotFoundException, IOException

返回实现代理类描述符中命名的接口的代理类； 子类可以实现此方法以从流中读取自定义数据以及动态代理类的描述符，从而允许它们为接口和代理类使用备用加载机制。

对于流中的每个唯一代理类描述符，该方法只调用一次。

ObjectOutputStream 中对应的方法是annotateProxyClass。 对于覆盖此方法的给定 ObjectInputStream 子类，ObjectOutputStream 相应子类中的 annotateProxyClass 方法必须写入此方法读取的任何数据或对象。

ObjectInputStream 中此方法的默认实现返回调用 Proxy.getProxyClass 的结果，其中包含接口参数中命名的接口的 Class 对象列表。 每个接口名称 i 的 Class 对象是调用返回的值

     Class.forName(i, false, loader) 

其中 loader 是执行堆栈上第一个非空类加载器的加载器，如果堆栈上没有非空类加载器（与 resolveClass 方法使用的类加载器选择相同），则为 null。 除非任何已解析的接口是非公开的，否则 loader 的相同值也是传递给 Proxy.getProxyClass 的类加载器； 如果存在非公共接口，则传递它们的类加载器（如果遇到多个非公共接口类加载器，则抛出 IllegalAccessError）。 如果 Proxy.getProxyClass 引发 IllegalArgumentException，resolveProxyClass 将引发包含 IllegalArgumentException 的 ClassNotFoundException。

参数：

返回:

指定接口的代理类

Throws:

Since:

1.3

resolveObject

protected Object resolveObject(Object obj) throws IOException

此方法将允许 ObjectInputStream 的受信任子类在反序列化期间用一个对象替换另一个对象。在调用 enableResolveObject 之前，禁用替换对象。 enableResolveObject 方法检查请求解析对象的流是否可信。每个对可序列化对象的引用都会传递给 resolveObject。为了确保对象的私有状态不会无意暴露，只有受信任的流可以使用 resolveObject。

在读取对象之后但在从 readObject 返回之前调用此方法。默认的 resolveObject 方法只返回相同的对象。

当子类替换对象时，它必须确保被替换的对象与将存储引用的每个字段兼容。类型不是字段或数组元素类型的子类的对象通过引发异常中止序列化并且不存储该对象。

此方法仅在第一次遇到每个对象时调用一次。对该对象的所有后续引用都将重定向到新对象。

参数：

返回:

被替换的对象

Throws:

enableResolveObject

protected boolean enableResolveObject(boolean enable) throws SecurityException

启用流以允许替换从流中读取的对象。 启用后，将为每个要反序列化的对象调用 resolveObject 方法。

如果 enable 为 true，并且安装了安全管理器，则此方法首先调用安全管理器的 checkPermission 方法，并具有 SerializablePermission(“enableSubstitution”) 权限，以确保可以启用流以允许替换从流中读取的对象。

参数：

返回:

调用此方法之前的先前设置

Throws:

readStreamHeader

protected void readStreamHeader() throws IOException, StreamCorruptedException

提供 readStreamHeader 方法是为了允许子类读取和验证它们自己的流标头。 它读取并验证幻数和版本号。

Throws:

readClassDescriptor

protected ObjectStreamClass readClassDescriptor() throws ClassNotFoundException, IOException

从序列化流中读取类描述符。 当 ObjectInputStream 期望类描述符作为序列化流中的下一项时，将调用此方法。 ObjectInputStream 的子类可以覆盖此方法以读取以非标准格式编写的类描述符（通过覆盖 writeClassDescriptor 方法的 ObjectOutputStream 的子类）。 默认情况下，此方法根据对象序列化规范中定义的格式读取类描述符。

返回:

类描述符读取

Throws:

Since:

1.3

read

public int read() throws IOException

读取一个字节的数据。 如果没有可用的输入，此方法将阻塞。

指定者：

读入接口 ObjectInput

指定者：

读入类 InputStream

返回:

读取的字节，如果到达流的末尾，则为 -1。

Throws:

read

public int read(byte[] buf, int off, int len) throws IOException

读入一个字节数组。 此方法将阻塞，直到某些输入可用。 考虑使用 java.io.DataInputStream.readFully 准确读取“长度”字节。

指定者：

读入接口 ObjectInput

覆盖：

读入类 InputStream

参数：

返回:

实际读取的字节数，到达流末尾时返回-1。

Throws:

available

public int available() throws IOException

返回可以在不阻塞的情况下读取的字节数。

指定者：

在接口 ObjectInput 中可用

覆盖：

在类 InputStream 中可用

返回:

可用字节数。

Throws:

close

public void close() throws IOException

关闭输入流。 必须调用以释放与流关联的任何资源。

指定者：

在接口 AutoCloseable 中关闭

指定者：

在接口Closeable中关闭

指定者：

在接口 ObjectInput 中关闭

覆盖：

在类 InputStream 中关闭

Throws:

readBoolean

public boolean readBoolean() throws IOException

以布尔值读取。

指定者：

接口 DataInput 中的 readBoolean

返回:

布尔读取。

Throws:

readByte

public byte readByte() throws IOException

读取一个 8 位字节。

指定者：

接口 DataInput 中的 readByte

返回:

8位字节读取。

Throws:

readUnsignedByte

public int readUnsignedByte() throws IOException

读取一个无符号的 8 位字节。

指定者：

接口 DataInput 中的 readUnsignedByte

返回:

8位字节读取。

Throws:

readChar

public char readChar() throws IOException

读取 16 位字符。

指定者：

接口 DataInput 中的 readChar

返回:

读取 16 位字符。

Throws:

readShort

public short readShort() throws IOException

读取 16 位短。

指定者：

接口 DataInput 中的 readShort

返回:

16位短读。

Throws:

readUnsignedShort

public int readUnsignedShort() throws IOException

读取无符号 16 位短。

指定者：

接口 DataInput 中的 readUnsignedShort

返回:

16位短读。

Throws:

readInt

public int readInt() throws IOException

读取 32 位整数。

指定者：

接口 DataInput 中的 readInt

返回:

读取的 32 位整数。

Throws:

readLong

public long readLong() throws IOException

读取 64 位长。

指定者：

接口 DataInput 中的 readLong

返回:

读取 64 位长。

Throws:

readFloat

public float readFloat() throws IOException

读取 32 位浮点数。

指定者：

接口 DataInput 中的 readFloat

返回:

32 位浮点数读取。

Throws:

readDouble

public double readDouble() throws IOException

读取 64 位双精度。

指定者：

接口 DataInput 中的 readDouble

返回:

64位双读。

Throws:

readFully

public void readFully(byte[] buf) throws IOException

读取字节，阻塞直到读取所有字节。

指定者：

接口 DataInput 中的 readFully

参数：

Throws:

readFully

public void readFully(byte[] buf, int off, int len) throws IOException

读取字节，阻塞直到读取所有字节。

指定者：

接口 DataInput 中的 readFully

参数：

Throws:

skipBytes

public int skipBytes(int len) throws IOException

跳过字节。

指定者：

接口 DataInput 中的 skipBytes

参数：

返回:

跳过的实际字节数。

Throws:

readLine

@Deprecated public String readLine() throws IOException

已弃用。 此方法不能正确地将字节转换为字符。 有关详细信息和替代方案，请参阅 DataInputStream。

读取已被 \n、\r、\r\n 或 EOF 终止的行。

指定者：

接口 DataInput 中的 readLine

返回:

该行的字符串副本。

Throws:

readUTF

public String readUTF() throws IOException

以修改后的 UTF-8 格式读取字符串。

指定者：

接口 DataInput 中的 readUTF

返回:

字符串。

Throws: