首先,我知道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());
}
通过使用
List
将XMLEncoder
保存到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/