Java 反序列化映射时出现OptionalDataException<；类、列表<；对象>&燃气轮机；如何找到确切的原因？

在反序列化

.ser

文件中的一些对象时，我得到了

java.io.OptionalDataException

    public static void main(String[] args) throws Exception {

        try {
            ObjectInputStream is = new ObjectInputStream(new FileInputStream(extentFile));
            BusinessObject.readExtents(is);
            is.close();

            BusinessObject.showExtent(Product.class);

            BusinessObject.showExtent(Client.class);

            BusinessObject.showExtent(Store.class);

            BusinessObject.showExtent(ShoppingCart.class);  
        } catch(OptionalDataException e) {
            e.printStackTrace();
            System.out.println(e.eof);
            System.out.println(e.length);
        }
    }
}

输出为：

java.io.OptionalDataException
    at java.io.ObjectInputStream.readObject0(Unknown Source)
    at java.io.ObjectInputStream.readObject(Unknown Source)
    at BusinessObject.readExtents(BusinessObject.java:72)
    at TestLoadingExtension.main(TestLoadingExtension.java:18)
false
1024

所以它表明流中的下一个元素是原始的，但不知道为什么。我把所有东西都放在物体里了

我的类处理扩展

public abstract class BusinessObject implements Serializable {

    private static final long serialVersionUID = -4398523594079500765L;

    private static Map<Class, List<BusinessObject>> allExtents = new Hashtable<Class, List<BusinessObject>>();

    public BusinessObject() {
        List extent = null;
        Class theClass = this.getClass();

        if (allExtents.containsKey(theClass)) {
            extent = allExtents.get(theClass);
        } else {
            extent = new ArrayList();
            allExtents.put(theClass, extent);
        }

        extent.add(this);
    }

    public static <T> Iterable<T> getExtent(Class<T> type) throws ClassNotFoundException {
        if (allExtents.containsKey(type)) {
            return (Iterable<T>) allExtents.get(type);
        }

        throw new ClassNotFoundException(String.format("%s. Stored extents: %s", type.toString(), allExtents.keySet()));
    }

    public static void showExtent(Class theClass) throws Exception {
        List extent = null;

        if (allExtents.containsKey(theClass)) {
            extent = allExtents.get(theClass);
        } else {
            throw new Exception("Unknown class " + theClass);
        }

        System.out.println("Extent of the class: " + theClass.getSimpleName());

        for (Object obj : extent) {
            System.out.println(obj);
        }
    }

    public static void writeExtents(ObjectOutputStream stream) throws IOException {
        stream.writeObject(allExtents);
    }

    public static void readExtents(ObjectInputStream stream) throws IOException, ClassNotFoundException {
        allExtents = (Map<Class, List<BusinessObject>>) stream.readObject();
    }

    public static void clearExtension() {
        allExtents = null;
    }
}

公共抽象类BusinessObject实现可序列化{
私有静态最终长serialVersionUID=-43985235940709500765L；
私有静态映射allExtents=newhashtable（）；
公共业务对象（）{
列表范围=空；
Class theClass=this.getClass（）；
if（allExtents.containsKey（类））{
extent=allExtents.get（类）；
}否则{
范围=新的ArrayList（）；
放置（类、范围）；
}
范围。添加（本）；
}
公共静态Iterable getExtent（类类型）引发ClassNotFoundException{
if（allExtents.containsKey（类型））{
return（Iterable）allExtents.get（type）；
}
抛出新的ClassNotFoundException（String.format（“%s.Storage extents:%s”），键入.toString（），allExtents.keySet（））；
}
公共静态void showExtent（类类）引发异常{
列表范围=空；
if（allExtents.containsKey（类））{
extent=allExtents.get（类）；
}否则{
抛出新异常（“未知类”+类）；
}
System.out.println（“类的范围：+theClass.getSimpleName（））；
用于（对象对象对象：范围）{
系统输出打印项次（obj）；
}
}
公共静态void writeExtents（ObjectOutputStream流）引发IOException{
stream.writeObject（allExtents）；
}
公共静态void readExtents（ObjectInputStream流）引发IOException、ClassNotFoundException{
allExtents=（Map）stream.readObject（）；
}
公共静态无效clearExtension（）{
allExtents=null；
}
}

---

怎么可能把这个修好？是否保存的在序列化过程中被损坏？

是否关闭了

ObjectOutputStream

？@user207421是的，我关闭了