java - 如何使用 XMLEncoder 使 Arraylist 线程安全且可序列化-6ren

java - 如何使用 XMLEncoder 使 Arraylist 线程安全且可序列化

转载作者：行者123 更新时间：2023-11-29 08:47:23

首先:我知道 SO 中有很多关于此的相关帖子，但我能找到的一篇对我的情况有所帮助。

所以，我正在做的是得到一个非常简单的父对象，它可能有多个子对象。这两个对象都符合 java bean 规范(所有变量的无参数构造函数、setter 和 getter)。

可能有多个父类，它们保存在这样的存储库类中:

private final Map<String, Parent> parentItems = new ConcurrentHashMap<String, Parent>();

每次创建新父级时，存储库类都会保存从 parentItems 列表构建的父级列表，如下所示:

public List<Parent> getParents() {
    return new ArrayList<Parent>(parentItems.values());
}

保存操作是通过使用XMLEncoder 将List 保存到一个xml 文件中完成的。它看起来像这样:

public void saveParents(OutputStream os) {

    ClassLoader cl = Thread.currentThread().getContextClassLoader();
    XMLEncoder encoder = null;
    try {
        Thread.currentThread().setContextClassLoader(Parent.class.getClassLoader());

        encoder = new XMLEncoder(os);
        encoder.writeObject(getParents());
        encoder.flush();
    } finally {
        if (encoder != null) {
            encoder.close();
        }
        Thread.currentThread().setContextClassLoader(cl);
    }
}

一切正常。现在我想将一些子对象添加到父对象，然后将新的子对象添加到子列表并重新运行 saveParents()。这是我的麻烦开始的地方:

如果我在父级中使用 ArrayList 来保存子级，如下所示:

private ArrayList<Child> children = new ArrayList<Child>();

一切正常。对象将保存在 xml 文件中的父对象中。它看起来像这样:

<?xml version="1.0" encoding="UTF-8"?>
<java version="1.7.0_45" class="java.beans.XMLDecoder">
 <object class="java.util.ArrayList">
  <void method="add">
   <object class="org.mypackage.Parent" id="Parent0">
    <void property="children">
     <void method="add">
      <object class="org.mypackage.Child">
       <void property="displayName">
        <string>Child1</string>
       </void>
       <void property="id">
        <string>myid1</string>
       </void>
       <void property="parent">
        <object idref="Parent0"/>
       </void>
      </object>
     </void>
     <void method="add">
      <object class="org.mypackage.Child">
       <void property="displayName">
        <string>Child2</string>
       </void>
       <void property="id">
        <string>myid2</string>
       </void>
       <void property="parent">
        <object idref="Parent0"/>
       </void>
      </object>
     </void>
    </void>
    <void property="displayName">
     <string>Parent1</string>
    </void>
    <void property="id">
     <string>myid</string>
    </void>
   </object>
  </void>
 </object>
</java>

但是:我们知道 ArrayList 不是线程安全的，而且我知道父对象可能会被多人更改。那么如何解决呢？使用 synchronizedList(...) - 对吗？像...

private List<Child> children = Collections.synchronizedList(new ArrayList<Child>());

...然后快速将 getter 和 setter 更改为 List 而不是 ArrayList，我们应该没问题。好的，这应该有效 - 但你猜怎么着:它失败了 :-(

每次我添加一个子对象(然后运行 saveParent())我都会得到一个 StackOverflowException。如果我查找 XML，我会看到类似这样的内容:

<?xml version="1.0" encoding="UTF-8"?>
<java version="1.7.0_45" class="java.beans.XMLDecoder">
<void class="java.util.ArrayList">
 <void method="add">
  <object class="org.mypackage.Child" id="Child0">
   <void property="displayName">
    <string>Child1</string>
   </void>
   <void property="id">
    <string>myid</string>
   </void>
   <void property="parent">
    <object class="org.mypackage.Parent"/>
   </void>
  </object>
 </void>
</void>
<void class="java.util.ArrayList">
 <void method="add">
  <object idref="Child0"/>
 </void>
</void>
<void class="java.util.ArrayList">
 <void method="add">
  <object idref="Child0"/>
 </void>
</void>
<void class="java.util.ArrayList">
 <void method="add">
  <object idref="Child0"/>
 </void>
</void>
...... AND THIS GOES ON AND ON AND ON .......

好吧，我想我知道堆栈溢出是从哪里来的……但是为什么呢？它应该是可序列化的但是好吧，看看它......我如何获得一个不会崩溃的可序列化、线程安全的 List(或任何其他适合的数据类型)？也许您可以考虑任何解决方法以使 ArrayList(在这种情况下有效)线程安全？也许通过使整个父对象线程安全？ (然而:这可能有其他副作用，这就是为什么简单地让 synchronizedList(...) 工作将是最优雅的方式)

最佳答案

我创建了以下最小的完整可验证示例来重现您的问题:

public class Test {

    public static void main(String[] args) {
        List<Parent> parents = new ArrayList<>();
        // parents = Collections.synchronizedList(parents);

        Parent p1 = new Parent();
        Child c1 = new Child();
        Child c2 = new Child();
        p1.getChildren().add(c1);
        c1.setParent(p1);
        p1.getChildren().add(c2);
        c2.setParent(p1);

        parents.add(p1);

        try (XMLEncoder encoder = new XMLEncoder(System.out)) {
            encoder.writeObject(parents);
        }
    }

    public static class Parent {
        private List<Child> children = new ArrayList<>();

        public List<Child> getChildren() { return children; }
        public void setChildren(List<Child> children) { this.children = children; }
    }

    public static class Child {
        private Parent parent;

        public Parent getParent() { return parent; }
        public void setParent(Parent p) { parent = p; }
    }
}

上面的非同步集合代码有效，并生成您想要的 XML 编码。取消注释 parents = Collections.synchronizedList(parents);行，以及 StackOverflowException结果。现在修复它。

问题似乎源于 parents列表被序列化为 ArrayList<> ，事实并非如此。它实际上是一个非公开的 java.util.Collections$SynchronizedRandomAccessList .如果StackOverflowException没有发生，你的问题应该是“我序列化了一个 synchronizedList-wrapped-ArrayList ，但反序列化为一个 ArrayList ，这是错误的”。您想要正确编码同步列表。为此，您需要一个 PersistenceDelegate .

public class SynchronizedArrayListPD extends DefaultPersistenceDelegate {
    @Override
    protected Expression instantiate(Object oldInstance, Encoder out) {
        return new Expression(oldInstance, Collections.class, "synchronizedList",
                new Object[] { new ArrayList<>() });
    }

    @Override
    protected void initialize(Class<?> type, Object oldInstance, Object newInstance,
            Encoder out) {
        super.initialize(type, oldInstance, newInstance, out);

        List<?> list = (List<?>) oldInstance;
        for (Object item : list) {
            out.writeStatement(new Statement(oldInstance, "add", new Object[] { item }));
        }
    }
}

此委托(delegate)将创建指令以通过传递给 Collections.synchronizedList() 来反序列化列表。方法ArrayList<> ，然后将成员添加到结果 List<>目的。在创建 XMLEncoder 之后简单地安装委托(delegate).

try (XMLEncoder encoder = new XMLEncoder(System.out)) {
    encoder.setPersistenceDelegate(parents.getClass(), new SynchronizedArrayListPD());
    encoder.writeObject(parents);
}

#setPersistanceDelegate(cls, delegate)需要 Class<?>目的。通常，我们会使用类似 SynchronizedArrayList.class 的东西，但实际类不是公共(public)类，所以我们从对象本身获取实际类。这不是类型安全的；如果你改变了 parents成为(比方说)一个同步链表，SynchronizedArrayListPD将用于同步那个，这是错误的。添加适当的注意事项。

生成的 XML 编码:

<java version="1.8.0_101" class="java.beans.XMLDecoder">  
<object class="java.util.Collections" method="synchronizedList">  
  <object class="java.util.ArrayList"/>  
  <void method="add">  
   <object class="xml.Test$Parent" id="Test$Parent0">  
    <void property="children">  
     <void method="add">  
      <object class="xml.Test$Child">  
       <void property="parent">  
        <object idref="Test$Parent0"/>  
       </void>  
      </object>  
     </void>  
     <void method="add">  
      <object class="xml.Test$Child">  
       <void property="parent">  
        <object idref="Test$Parent0"/>  
       </void>  
      </object>  
     </void>  
    </void>  
   </object>  
  </void>  
 </object>  
</java>