java.lang.Object

java.io.InputStream

java.io.ObjectInputStream

所有已实现的接口：: Closeable , DataInput , ObjectInput , ObjectStreamConstants , AutoCloseable

public class ObjectInputStream extends InputStream implements ObjectInput , ObjectStreamConstants

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

Warning: Deserialization of untrusted data is inherently dangerous and should be avoided. Untrusted data should be carefully validated according to the "Serialization and Deserialization" section of the Secure Coding Guidelines for Java SE. Serialization Filtering describes best practices for defensive use of serial filters.

禁用反序列化攻击的关键是防止任意类的实例被反序列化，从而防止直接或间接执行它们的方法。 ObjectInputFilter 描述了如何使用过滤器，ObjectInputFilter.Config 描述了如何配置过滤器和过滤器工厂。每个流都有一个可选的反序列化过滤器，用于在反序列化期间检查类和资源限制。 JVM 范围的过滤器工厂确保可以在每个 ObjectInputStream 上设置一个过滤器，并且可以检查从流中读取的每个对象。 ObjectInputStream 构造函数调用过滤器工厂来选择可以由 setObjectInputFilter(java.io.ObjectInputFilter) 更新或替换的初始过滤器。

如果 ObjectInputStream 有过滤器，ObjectInputFilter 可以检查类、数组长度、流中的引用数、深度和从输入流消耗的字节数是否被允许，如果不允许，则可以终止反序列化。

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

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

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

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

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

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

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

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

  try (FileInputStream fis = new FileInputStream("t.tmp");
     ObjectInputStream ois = new ObjectInputStream(fis)) {
    String label = (String) ois.readObject();
    LocalDateTime dateTime = (LocalDateTime) ois.readObject();
    // Use label and dateTime
  } catch (Exception ex) {
    // handle exception
  }

类通过实现 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 接口的对象的字段或为其赋值。不可序列化的对象的子类可以是可序列化的。在这种情况下，不可序列化的类必须有一个无参数的构造方法来允许初始化它的字段。在这种情况下，子类有责任保存和恢复不可序列化类的状态。通常情况下，该类的字段是可访问的（public、package 或 protected），或者存在可用于恢复状态的 get 和 set 方法。

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

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

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

记录的序列化不同于普通的可序列化或可外部化的对象。在反序列化过程中，调用记录的规范构造函数来构造记录对象。对于可序列化记录，某些与序列化相关的方法（例如 readObject 和 writeObject）将被忽略。有关更多信息，请参阅 Java 对象序列化规范， Section 1.13, "Serialization of Records"。

自从：

1.1

参见：

内部类总结

内部类

修饰符和类型

类

描述

static class

ObjectInputStream.GetField

提供对从输入流中读取的持久字段的访问。
字段摘要

在接口 java.io.ObjectStreamConstants 中声明的字段
baseWireHandle, PROTOCOL_VERSION_1, PROTOCOL_VERSION_2, SC_BLOCK_DATA, SC_ENUM, SC_EXTERNALIZABLE, SC_SERIALIZABLE, SC_WRITE_METHOD, SERIAL_FILTER_PERMISSION, STREAM_MAGIC, STREAM_VERSION, SUBCLASS_IMPLEMENTATION_PERMISSION, SUBSTITUTION_PERMISSION, TC_ARRAY, TC_BASE, TC_BLOCKDATA, TC_BLOCKDATALONG, TC_CLASS, TC_CLASSDESC, TC_ENDBLOCKDATA, TC_ENUM, TC_EXCEPTION, TC_LONGSTRING, TC_MAX, TC_NULL, TC_OBJECT, TC_PROXYCLASSDESC, TC_REFERENCE, TC_RESET, TC_STRING
构造方法总结

构造方法

修饰符

构造方法

描述

protected

ObjectInputStream()

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

ObjectInputStream(InputStream in)

创建一个从指定 InputStream 读取的 ObjectInputStream。
方法总结

修饰符和类型

方法

描述

int

available()

返回可以无阻塞读取的字节数。

void

close()

关闭此输入流并释放与该流关联的所有系统资源。

void

defaultReadObject()

从此流中读取当前类的非静态和非瞬态字段。

protected boolean

enableResolveObject(boolean enable)

使流能够替换从流中读取的对象。

final ObjectInputFilter

getObjectInputFilter()

返回此流的反序列化过滤器。

int

read()

读取一个字节的数据。

int

read(byte[] buf, int off, int len)

读入字节数组。

boolean

readBoolean()

读入boolean。

byte

readByte()

读取一个 8 位字节。

char

readChar()

读取 16 位字符。

protected ObjectStreamClass

readClassDescriptor()

从序列化流中读取类描述符。

double

readDouble()

读取 64 位双精度数。

ObjectInputStream.GetField

readFields()

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

float

readFloat()

读取 32 位浮点数。

void

readFully(byte[] buf)

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

void

readFully(byte[] buf, int off, int len)

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

int

readInt()

读取 32 位 int。

String

readLine()

已弃用。
此方法不能正确地将字节转换为字符。

long

readLong()

读取 64 位长。

final Object

readObject()

从 ObjectInputStream 中读取一个对象。

protected Object

readObjectOverride()

此方法由使用受保护的无参数构造方法构造 ObjectInputStream 的 ObjectInputStream 的受信任子类调用。

short

readShort()

读取 16 位短。

protected void

readStreamHeader()

提供了 readStreamHeader 方法以允许子类读取和验证自己的流标头。

Object

readUnshared()

从 ObjectInputStream 中读取一个“非共享”对象。

int

readUnsignedByte()

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

int

readUnsignedShort()

读取一个无符号的 16 位短整数。

String

readUTF()

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

void

registerValidation(ObjectInputValidation obj, int prio)

在返回图形之前注册要验证的对象。

protected Class<?>

resolveClass(ObjectStreamClass desc)

加载与指定流类描述等效的本地类。

protected Object

resolveObject(Object obj)

此方法将允许 ObjectInputStream 的受信任子类在反序列化期间用一个对象替换另一个对象。

protected Class<?>

resolveProxyClass(String[] interfaces)

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

final void

setObjectInputFilter(ObjectInputFilter filter)

为流设置反序列化过滤器。

int

skipBytes(int len)

跳过字节。

在类 java.io.InputStream 中声明的方法
mark, markSupported, nullInputStream, read, readAllBytes, readNBytes, readNBytes, reset, skip, skipNBytes, transferTo

在类 java.lang.Object 中声明的方法
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

在接口 java.io.ObjectInput 中声明的方法
read, skip

构造方法详细信息
- ObjectInputStream
  
  public ObjectInputStream(InputStream in) throws IOException
  
  创建一个从指定 InputStream 读取的 ObjectInputStream。从流中读取并验证序列化流标头。此构造方法将阻塞，直到相应的 ObjectOutputStream 已写入并刷新标头。
  构造函数将反序列化过滤器初始化为通过调用从 ObjectInputFilter.Config.getSerialFilterFactory() 返回的串行过滤器工厂返回的过滤器，其中 null 用于当前过滤器，静态 JVM 范围的过滤器用于请求的过滤器。如果串行过滤器或串行过滤器工厂属性无效，则会抛出 IllegalStateException 。当过滤器工厂 apply 方法被调用时，它可能会抛出一个运行时异常，阻止 ObjectInputStream 被构造。
  
  如果安装了安全管理器，则当由重写 ObjectInputStream.readFields 或 ObjectInputStream.readUnshared 方法的子类的构造方法直接或间接调用时，此构造方法将检查“enableSubclassImplementation”SerializablePermission。
  参数：
  
  in - 要读取的输入流
  
  抛出：
  
  StreamCorruptedException - 如果流标头不正确
  
  IOException - 如果在读取流头时发生 I/O 错误
  
  SecurityException - 如果不受信任的子类非法覆盖安全敏感方法
  
  IllegalStateException - 如果 ObjectInputFilter.Config 的初始化由于串行过滤器或串行过滤器工厂属性无效而失败。
  
  NullPointerException - 如果 in 是 null
  
  参见：
  
  ObjectInputStream()
  
  readFields()
  
  ObjectOutputStream(OutputStream)
- ObjectInputStream
  
  protected ObjectInputStream() throws IOException , SecurityException
  
  为完全重新实现 ObjectInputStream 的子类提供一种方法，使其不必分配仅由该 ObjectInputStream 实现使用的私有数据。
  构造函数将反序列化过滤器初始化为通过调用从 ObjectInputFilter.Config.getSerialFilterFactory() 返回的串行过滤器工厂返回的过滤器，其中 null 用于当前过滤器，静态 JVM 范围的过滤器用于请求的过滤器。如果串行过滤器或串行过滤器工厂属性无效，则会抛出 IllegalStateException 。当过滤器工厂 apply 方法被调用时，它可能会抛出一个运行时异常，阻止 ObjectInputStream 被构造。
  
  如果安装了安全管理器，此方法首先调用具有SerializablePermission("enableSubclassImplementation") 权限的安全管理器的checkPermission 方法以确保可以启用子类化。
  抛出：
  
  SecurityException - 如果安全管理器存在且其 checkPermission 方法拒绝启用子类化。
  
  IOException - 如果在创建此流时发生 I/O 错误
  
  IllegalStateException - 如果 ObjectInputFilter.Config 的初始化由于串行过滤器或串行过滤器工厂属性无效而失败。
  
  参见：
  
  SecurityManager.checkPermission(java.security.Permission)
  
  SerializablePermission
方法详情
- readObject
  
  public final Object readObject() throws IOException , ClassNotFoundException
  
  从 ObjectInputStream 中读取一个对象。读取对象的类、类的签名、类的非瞬态和非静态字段的值及其所有超类型。可以使用 writeObject 和 readObject 方法重写类的默认反序列化。传递地读取此对象引用的对象，以便通过 readObject 重建对象的完整等效图。
  当根对象的所有字段和它引用的对象都完全恢复时，根对象就完全恢复了。此时，对象验证回调将根据其注册的优先级按顺序执行。回调由对象注册（在 readObject 特殊方法中），因为它们是单独恢复的。
  
  反序列化过滤器，当不是 null 时，为每个读取的对象（常规或类）调用以重建根对象。有关详细信息，请参阅 setObjectInputFilter 。
  
  InputStream 的问题和不应反序列化的类会抛出异常。所有异常对 InputStream 都是致命的，并使其处于不确定状态；忽略或恢复流状态取决于调用者。
  
  指定者：
  
  readObject 在接口 ObjectInput 中
  
  返回：
  
  从流中读取的对象
  
  抛出：
  
  ClassNotFoundException - 找不到序列化对象的类。
  
  InvalidClassException - 反序列化使用的类有问题。
  
  StreamCorruptedException - 流中的控制信息不一致。
  
  OptionalDataException - 在流中找到原始数据而不是对象。
  
  IOException - 任何常见的输入/输出相关异常。
- readObjectOverride
  
  protected Object readObjectOverride() throws IOException , ClassNotFoundException
  
  此方法由使用受保护的无参数构造方法构造 ObjectInputStream 的 ObjectInputStream 的受信任子类调用。子类应提供带有修饰符“final”的重写方法。
  返回：
  
  从流中读取的对象。
  
  抛出：
  
  ClassNotFoundException - 找不到序列化对象的类定义。
  
  OptionalDataException - 在流中找到原始数据而不是对象。
  
  IOException - 如果从底层流读取时发生 I/O 错误
  
  自从：
  
  1.2
  
  参见：
  
  ObjectInputStream()
  
  readObject()
- readUnshared
  
  public Object readUnshared() throws IOException , ClassNotFoundException
  从 ObjectInputStream 中读取一个“非共享”对象。此方法与 readObject 相同，只是它阻止对 readObject 和 readUnshared 的后续调用返回对通过此调用获得的反序列化实例的其他引用。具体来说：
  
  如果调用 readUnshared 来反序列化反向引用（之前已写入流的对象的流表示），将抛出 ObjectStreamException。
  
  如果 readUnshared 成功返回，则任何后续尝试反序列化对由 readUnshared 反序列化的流句柄的反向引用都将导致抛出 ObjectStreamException。
  
  通过 readUnshared 反序列化对象会使与返回对象关联的流句柄无效。请注意，这本身并不总是保证 readUnshared 返回的引用是唯一的；反序列化的对象可以定义一个 readResolve 方法，该方法返回一个对其他方可见的对象，或者 readUnshared 可以返回一个 Class 对象或可在流的其他地方或通过外部方式获得的枚举常量。如果反序列化对象定义了一个 readResolve 方法并且该方法的调用返回一个数组，则 readUnshared 返回该数组的浅表克隆；这保证返回的数组对象是唯一的，并且不能通过调用 ObjectInputStream 上的 readObject 或 readUnshared 再次获得，即使底层数据流已被操作。
  反序列化过滤器，当不是 null 时，为每个读取的对象（常规或类）调用以重建根对象。有关详细信息，请参阅 setObjectInputFilter 。
  
  重写此方法的 ObjectInputStream 子类只能在拥有“enableSubclassImplementation”SerializablePermission 的安全上下文中构造；任何未经此许可而实例化此类子类的尝试都将导致抛出 SecurityException。
  返回：
  
  对反序列化对象的引用
  
  抛出：
  
  ClassNotFoundException - 如果找不到要反序列化的对象的类
  
  StreamCorruptedException - 如果流中的控制信息不一致
  
  ObjectStreamException - 如果要反序列化的对象已经出现在流中
  
  OptionalDataException - 如果原始数据是流中的下一个
  
  IOException - 如果在反序列化期间发生 I/O 错误
  
  自从：
  
  1.4
- defaultReadObject
  
  public void defaultReadObject() throws IOException , ClassNotFoundException
  
  从此流中读取当前类的非静态和非瞬态字段。这只能从被反序列化的类的 readObject 方法调用。如果以其他方式调用，它将抛出 NotActiveException。
  
  抛出：
  
  ClassNotFoundException - 如果找不到序列化对象的类。
  
  IOException - 如果发生 I/O 错误。
  
  NotActiveException - 如果流当前没有读取对象。
- readFields
  
  public ObjectInputStream.GetField readFields() throws IOException , ClassNotFoundException
  
  从流中读取持久字段并按名称使它们可用。
  
  返回：
  
  GetField 对象表示被反序列化的对象的持久字段
  
  抛出：
  
  ClassNotFoundException - 如果找不到序列化对象的类。
  
  IOException - 如果发生 I/O 错误。
  
  NotActiveException - 如果流当前没有读取对象。
  
  自从：
  
  1.2
- registerValidation
  
  public void registerValidation(ObjectInputValidation obj, int prio) throws NotActiveException , InvalidObjectException
  
  在返回图形之前注册要验证的对象。与 resolveObject 类似，这些验证是在整个图形被重构后调用的。通常，readObject 方法会将对象注册到流中，以便在恢复所有对象时可以执行最后一组验证。
  
  参数：
  
  obj - 接收验证回调的对象。
  
  prio - 控制回调的顺序；零是一个很好的默认值。使用较大的数字可以更早地回调，使用较低的数字可以更晚地回调。在优先级内，回调的处理没有特定顺序。
  
  抛出：
  
  NotActiveException - 流当前未读取对象，因此注册回调无效。
  
  InvalidObjectException - 验证对象为空。
- resolveClass
  
  protected Class <?> resolveClass(ObjectStreamClass desc) throws IOException , ClassNotFoundException
  加载与指定流类描述等效的本地类。子类可以实现此方法以允许从备用源获取类。
  ObjectOutputStream 中对应的方法是 annotateClass 。对于流中的每个唯一类，此方法只会被调用一次。此方法可以由子类实现以使用备用加载机制，但必须返回一个 Class 对象。一旦返回，如果该类不是数组类，则将其 serialVersionUID 与序列化类的 serialVersionUID 进行比较，如果不匹配，则反序列化失败并抛出 InvalidClassException 。
  
  ObjectInputStream中该方法的默认实现返回调用的结果
  
  Class.forName(desc.getName(), false, loader)
  
  其中 loader 是当前线程堆栈上的第一个类加载器（从当前执行的方法开始），它既不是平台类加载器也不是它的祖先；否则，loader 是 platform class loader。如果此调用导致 ClassNotFoundException 并且传递的 ObjectStreamClass 实例的名称是原始类型或 void 的 Java 语言关键字，则将返回表示该原始类型或 void 的 Class 对象（例如，名称为 "int" 的 ObjectStreamClass 将解决为 Integer.TYPE ）。否则，ClassNotFoundException 将被抛给此方法的调用者。
  参数：
  
  desc - 类 ObjectStreamClass 的实例
  
  返回：
  
  对应于 desc 的 Class 对象
  
  抛出：
  
  IOException - 任何常见的输入/输出异常。
  
  ClassNotFoundException - 如果找不到序列化对象的类。
- resolveProxyClass
  
  protected Class <?> resolveProxyClass(String [] interfaces) throws IOException , ClassNotFoundException
  返回一个代理类，该代理类实现了代理类描述符中命名的接口；子类可以实现此方法以从流中读取自定义数据以及动态代理类的描述符，从而允许它们为接口和代理类使用备用加载机制。
  对于流中的每个唯一代理类描述符，只调用一次此方法。
  
  ObjectOutputStream 中对应的方法是 annotateProxyClass 。对于覆盖此方法的 ObjectInputStream 的给定子类，ObjectOutputStream 的相应子类中的 annotateProxyClass 方法必须写入此方法读取的任何数据或对象。
  
  ObjectInputStream 中此方法的默认实现返回调用 Proxy.getProxyClass 的结果，其中包含在 interfaces 参数中命名的接口的 Class 对象列表。每个接口名称i的Class对象是调用返回的值
  
  Class.forName(i, false, loader)
  
  其中 loader 是当前线程堆栈上的第一个类加载器（从当前执行的方法开始），它既不是平台类加载器也不是它的祖先；否则，loader 是 platform class loader。除非任何已解析的接口是非公共的，否则 loader 的相同值也是传递给 Proxy.getProxyClass 的类加载器；如果存在非公共接口，则传递它们的类加载器（如果遇到多个非公共接口类加载器，则抛出 IllegalAccessError）。如果 Proxy.getProxyClass 抛出一个 IllegalArgumentException，resolveProxyClass 将抛出一个包含 IllegalArgumentException 的 ClassNotFoundException。
  参数：
  
  interfaces - 在代理类描述符中反序列化的接口名称列表
  
  返回：
  
  指定接口的代理类
  
  抛出：
  
  IOException - 底层 InputStream 抛出的任何异常
  
  ClassNotFoundException - 如果找不到代理类或任何命名接口
  
  自从：
  
  1.3
  
  参见：
  
  ObjectOutputStream.annotateProxyClass(Class)
- resolveObject
  
  protected Object resolveObject(Object obj) throws IOException
  
  此方法将允许 ObjectInputStream 的受信任子类在反序列化期间用一个对象替换另一个对象。在调用 enableResolveObject 之前，替换对象是禁用的。 enableResolveObject 方法检查请求解析对象的流是否可信。对可序列化对象的每个引用都传递给 resolveObject。为确保对象的私有状态不会无意中暴露，只有受信任的流可以使用 resolveObject。
  在读取对象之后但在从 readObject 返回之前调用此方法。默认的 resolveObject 方法只返回同一个对象。
  
  当子类替换对象时，它必须确保被替换的对象与将存储引用的每个字段兼容。类型不是字段或数组元素类型的子类的对象会通过引发异常来中止反序列化，并且不会存储该对象。
  
  当第一次遇到每个对象时，只调用一次此方法。对该对象的所有后续引用都将重定向到新对象。
  
  参数：
  
  obj - 要替换的对象
  
  返回：
  
  被替换的对象
  
  抛出：
  
  IOException - 任何常见的输入/输出异常。
- enableResolveObject
  
  protected boolean enableResolveObject(boolean enable) throws SecurityException
  
  使流能够替换从流中读取的对象。启用后，将为每个反序列化的对象调用 resolveObject(java.lang.Object) 方法。
  如果当前未启用对象替换，并且enable为真，并且安装了安全管理器，则此方法首先以SerializablePermission("enableSubstitution")权限调用安全管理器的checkPermission方法，以确保允许调用者启用流来进行对象替换从流中读取。
  参数：
  
  enable - 为每个被反序列化的对象启用 resolveObject 时为真
  
  返回：
  
  调用此方法之前的先前设置
  
  抛出：
  
  SecurityException - 如果安全管理器存在且其 checkPermission 方法拒绝启用流来替换从流中读取的对象。
  
  参见：
  
  SecurityManager.checkPermission(java.security.Permission)
  
  SerializablePermission
- readStreamHeader
  
  protected void readStreamHeader() throws IOException , StreamCorruptedException
  
  提供了 readStreamHeader 方法以允许子类读取和验证自己的流标头。它读取并验证幻数和版本号。
  
  抛出：
  
  IOException - 如果从底层 InputStream 读取时出现 I/O 错误
  
  StreamCorruptedException - 如果流中的控制信息不一致
- readClassDescriptor
  
  protected ObjectStreamClass readClassDescriptor() throws IOException , ClassNotFoundException
  
  从序列化流中读取类描述符。当 ObjectInputStream 期望类描述符作为序列化流中的下一项时，将调用此方法。 ObjectInputStream 的子类可以覆盖此方法以读取以非标准格式编写的类描述符（通过覆盖了 writeClassDescriptor 方法的 ObjectOutputStream 的子类）。默认情况下，此方法根据对象序列化规范中定义的格式读取类描述符。
  返回：
  
  读取的类描述符
  
  抛出：
  
  IOException - 如果发生 I/O 错误。
  
  ClassNotFoundException - 如果找不到类描述符表示中使用的序列化对象的类
  
  自从：
  
  1.3
  
  参见：
  
  ObjectOutputStream.writeClassDescriptor(java.io.ObjectStreamClass)
- read
  
  public int read() throws IOException
  
  读取一个字节的数据。如果没有输入可用，此方法将阻塞。
  
  指定者：
  
  read 在接口 ObjectInput 中
  
  指定者：
  
  read 在类 InputStream 中
  
  返回：
  
  读取的字节，如果到达流的末尾则为 -1。
  
  抛出：
  
  IOException - 如果发生 I/O 错误。
- read
  
  public int read(byte[] buf, int off, int len) throws IOException
  
  读入字节数组。此方法将阻塞，直到某些输入可用。考虑使用 java.io.DataInputStream.readFully 来准确读取“长度”字节。
  指定者：
  
  read 在接口 ObjectInput 中
  
  重写：
  
  read 在类 InputStream 中
  
  参数：
  
  buf - 读取数据的缓冲区
  
  off - 目标数组中的起始偏移量 buf
  
  len - 读取的最大字节数
  
  返回：
  
  读入缓冲区的字节总数，如果因为已到达流的末尾而没有更多数据，则为 -1。
  
  抛出：
  
  NullPointerException - 如果 buf 是 null。
  
  IndexOutOfBoundsException - 如果 off 为负，len 为负，或 len 大于 buf.length - off。
  
  IOException - 如果发生 I/O 错误。
  
  参见：
  
  DataInputStream.readFully(byte[],int,int)
- available
  
  public int available() throws IOException
  
  返回可以无阻塞读取的字节数。
  
  指定者：
  
  available 在接口 ObjectInput 中
  
  重写：
  
  available 在类 InputStream 中
  
  返回：
  
  可用字节数。
  
  抛出：
  
  IOException - 如果从底层 InputStream 读取时出现 I/O 错误
- close
  
  public void close() throws IOException
  
  关闭此输入流并释放与该流关联的所有系统资源。
  
  指定者：
  
  close 在接口 AutoCloseable 中
  
  指定者：
  
  close 在接口 Closeable 中
  
  指定者：
  
  close 在接口 ObjectInput 中
  
  重写：
  
  close 在类 InputStream 中
  
  抛出：
  
  IOException - 如果发生 I/O 错误。
- readBoolean
  
  public boolean readBoolean() throws IOException
  
  读入boolean。
  
  指定者：
  
  readBoolean 在接口 DataInput 中
  
  返回：
  
  boolean读取。
  
  抛出：
  
  EOFException - 如果到达文件末尾。
  
  IOException - 如果发生其他 I/O 错误。
- readByte
  
  public byte readByte() throws IOException
  
  读取一个 8 位字节。
  
  指定者：
  
  readByte 在接口 DataInput 中
  
  返回：
  
  读取的 8 位字节。
  
  抛出：
  
  EOFException - 如果到达文件末尾。
  
  IOException - 如果发生其他 I/O 错误。
- readUnsignedByte
  
  public int readUnsignedByte() throws IOException
  
  读取一个无符号的 8 位字节。
  
  指定者：
  
  readUnsignedByte 在接口 DataInput 中
  
  返回：
  
  读取的 8 位字节。
  
  抛出：
  
  EOFException - 如果到达文件末尾。
  
  IOException - 如果发生其他 I/O 错误。
- readChar
  
  public char readChar() throws IOException
  
  读取 16 位字符。
  
  指定者：
  
  readChar 在接口 DataInput 中
  
  返回：
  
  读取的 16 位字符。
  
  抛出：
  
  EOFException - 如果到达文件末尾。
  
  IOException - 如果发生其他 I/O 错误。
- readShort
  
  public short readShort() throws IOException
  
  读取 16 位短。
  
  指定者：
  
  readShort 在接口 DataInput 中
  
  返回：
  
  16 位短读。
  
  抛出：
  
  EOFException - 如果到达文件末尾。
  
  IOException - 如果发生其他 I/O 错误。
- readUnsignedShort
  
  public int readUnsignedShort() throws IOException
  
  读取一个无符号的 16 位短整数。
  
  指定者：
  
  readUnsignedShort 在接口 DataInput 中
  
  返回：
  
  16 位短读。
  
  抛出：
  
  EOFException - 如果到达文件末尾。
  
  IOException - 如果发生其他 I/O 错误。
- readInt
  
  public int readInt() throws IOException
  
  读取 32 位 int。
  
  指定者：
  
  readInt 在接口 DataInput 中
  
  返回：
  
  读取的 32 位整数。
  
  抛出：
  
  EOFException - 如果到达文件末尾。
  
  IOException - 如果发生其他 I/O 错误。
- readLong
  
  public long readLong() throws IOException
  
  读取 64 位长。
  
  指定者：
  
  readLong 在接口 DataInput 中
  
  返回：
  
  读取 64 位长。
  
  抛出：
  
  EOFException - 如果到达文件末尾。
  
  IOException - 如果发生其他 I/O 错误。
- readFloat
  
  public float readFloat() throws IOException
  
  读取 32 位浮点数。
  
  指定者：
  
  readFloat 在接口 DataInput 中
  
  返回：
  
  读取的 32 位浮点数。
  
  抛出：
  
  EOFException - 如果到达文件末尾。
  
  IOException - 如果发生其他 I/O 错误。
- readDouble
  
  public double readDouble() throws IOException
  
  读取 64 位双精度数。
  
  指定者：
  
  readDouble 在接口 DataInput 中
  
  返回：
  
  64位双读。
  
  抛出：
  
  EOFException - 如果到达文件末尾。
  
  IOException - 如果发生其他 I/O 错误。
- readFully
  
  public void readFully(byte[] buf) throws IOException
  
  读取字节，阻塞直到读取所有字节。
  
  指定者：
  
  readFully 在接口 DataInput 中
  
  参数：
  
  buf - 读取数据的缓冲区
  
  抛出：
  
  NullPointerException - 如果 buf 是 null。
  
  EOFException - 如果到达文件末尾。
  
  IOException - 如果发生其他 I/O 错误。
- readFully
  
  public void readFully(byte[] buf, int off, int len) throws IOException
  
  读取字节，阻塞直到读取所有字节。
  
  指定者：
  
  readFully 在接口 DataInput 中
  
  参数：
  
  buf - 读取数据的缓冲区
  
  off - 数据数组 buf 的起始偏移量
  
  len - 要读取的最大字节数
  
  抛出：
  
  NullPointerException - 如果 buf 是 null。
  
  IndexOutOfBoundsException - 如果 off 为负，则 len 为负，或者 len 大于 buf.length - off。
  
  EOFException - 如果到达文件末尾。
  
  IOException - 如果发生其他 I/O 错误。
- skipBytes
  
  public int skipBytes(int len) throws IOException
  
  跳过字节。
  
  指定者：
  
  skipBytes 在接口 DataInput 中
  
  参数：
  
  len - 要跳过的字节数
  
  返回：
  
  实际跳过的字节数。
  
  抛出：
  
  IOException - 如果发生 I/O 错误。
- readLine
  
  @Deprecated public String readLine() throws IOException
  
  已弃用。
  此方法不能正确地将字节转换为字符。有关详细信息和替代方案，请参阅 DataInputStream。
  
  读取以 \n、\r、\r\n 或 EOF 终止的行。
  
  指定者：
  
  readLine 在接口 DataInput 中
  
  返回：
  
  该行的字符串副本。
  
  抛出：
  
  IOException - 如果从底层 InputStream 读取时出现 I/O 错误
- readUTF
  
  public String readUTF() throws IOException
  
  读取修改后的 UTF-8 格式的字符串。
  
  指定者：
  
  readUTF 在接口 DataInput 中
  
  返回：
  
  字符串。
  
  抛出：
  
  IOException - 如果从底层 InputStream 读取时出现 I/O 错误
  
  UTFDataFormatException - 如果读取的字节不代表字符串的有效修改后的 UTF-8 编码
- getObjectInputFilter
  
  public final ObjectInputFilter getObjectInputFilter()
  
  返回此流的反序列化过滤器。过滤器是通过构造器或最近调用 setObjectInputFilter 调用 JVM-wide filter factory 的结果。
  
  返回：
  
  流的反序列化过滤器；可能为空
  
  自从：
  
  9
- setObjectInputFilter
  
  public final void setObjectInputFilter(ObjectInputFilter filter)
  
  为流设置反序列化过滤器。反序列化过滤器设置为通过使用当前过滤器和 filter 参数调用 JVM 范围的过滤器工厂返回的过滤器。当前过滤器是通过调用 JVM 范围的过滤器工厂在 ObjectInputStream 构造函数中设置的，可能是 null 。 setObjectInputFilter(ObjectInputFilter)此方法}在从流中读取任何对象之前只能调用一次；例如，通过调用 readObject() 或 readUnshared() 。
  不允许将 non-null 过滤器替换为 null 过滤器。如果当前过滤器是 non-null，则过滤器工厂返回的值必须是 non-null。
  
  为流中的每个类和引用调用过滤器的 checkInput 方法。过滤器可以检查任何或所有类、数组长度、引用数、图的深度和输入流的大小。深度是从读取被反序列化的图的根和被反序列化的当前对象开始的嵌套 readObject 调用的数量。引用数是已从流中读取的对象和引用对象的累计数，包括当前正在读取的对象。只有在从流中读取对象时才会调用过滤器，而不会为基元调用。
  
  如果过滤器返回 Status.REJECTED 、 null 或抛出一个 RuntimeException ，活动的 readObject 或 readUnshared 抛出 InvalidClassException ，否则反序列化继续不间断。
  实现要求：
  
  当不是 null 时，过滤器在 readObject 和 readUnshared 期间为流中的每个对象（常规或类）调用。字符串被视为原语，不会调用过滤器。过滤器被要求用于：
  
  先前从流中反序列化的每个对象引用（类为 null ，arrayLength 为 -1），
  
  每个常规类（类不是 null ，arrayLength 是 -1），
  
  流中显式引用的每个接口类（流中类实现的接口不调用它），
  
  动态代理的每个接口和动态代理类本身（类不是 null ，arrayLength 是 -1），
  
  使用数组类型和数组长度过滤每个数组（类是数组类型，arrayLength是请求的长度），
  
  每个被其类的 readResolve 方法替换的对象都使用替换对象的类进行过滤，如果不是 null ，如果它是一个数组，则为 arrayLength，否则为 -1，
  
  并且每个被 resolveObject 替换的对象都使用替换对象的类进行过滤，如果不是 null ，如果它是一个数组，则为 arrayLength，否则为 -1。
  
  当调用 checkInput 方法时，它可以访问当前类、数组长度、当前已从流中读取的引用数、对 readObject 或 readUnshared 的嵌套调用深度，以及依赖于实现的从中消耗的字节数输入流。
  每次调用 readObject 或 readUnshared 都会在读取对象之前将深度增加 1，在正常或异常返回之前减少 1。深度从 1 开始，随着每个嵌套对象的增加而增加，并在每个嵌套调用返回时减少。流中的引用计数从 1 开始，并在读取对象之前增加。
  
  参数：
  
  filter - 过滤器，可能为空
  
  抛出：
  
  SecurityException - 如果有安全管理器且 SerializablePermission("serialFilter") 未被授予
  
  IllegalStateException - 如果已读取对象，如果过滤器工厂在当前过滤器不为空时返回 null，或者过滤器已设置。
  
  自从：
  
  9

类 ObjectInputStream

内部类总结

字段摘要

在接口 java.io.ObjectStreamConstants 中声明的字段

构造方法总结

方法总结

在类 java.io.InputStream 中声明的方法

在类 java.lang.Object 中声明的方法

在接口 java.io.ObjectInput 中声明的方法

构造方法详细信息

ObjectInputStream

ObjectInputStream

方法详情

readObject

readObjectOverride

readUnshared

defaultReadObject

readFields

registerValidation

resolveClass

resolveProxyClass

resolveObject

enableResolveObject

readStreamHeader

readClassDescriptor

read

read

available

close

readBoolean

readByte

readUnsignedByte

readChar

readShort

readUnsignedShort

readInt

readLong

readFloat

readDouble

readFully

readFully

skipBytes

readLine

readUTF

getObjectInputFilter

setObjectInputFilter