首先,我知道SO中有许多与此相关的帖子,但是我可以找到一个对我的案例有帮助的帖子。

所以,我正在做的是得到一个非常简单的父对象,其中可能有多个子对象。
这两个对象均符合Java Bean规范(所有变量均使用no-args构造函数,setter和getter)。

可能有多个父级,这些父级保存在这样的存储库类中:

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

每次创建新的父级时,存储库类都会保存从parentItems列表构建的父级列表,如下所示:
public List<Parent> getParents() {
    return new ArrayList<Parent>(parentItems.values());
}

通过使用ListXMLEncoder保存到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);
    }
}

这一切都很好。现在,我想向父对象添加一些子对象,而只是向子List添加新的子对象,然后重新运行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>

有关创建持久性委托(delegate)的更多信息,请参见XML Encoder文章。

关于java - 如何使用XMLEncoder使Arraylist线程安全和可序列化,我们在Stack Overflow上找到一个类似的问题:https://stackoverflow.com/questions/24432095/

10-10 18:24
查看更多