Java 使用xstream生成子类从xml解组

我正在尝试使用XStream将XML转换为对象树。我希望基于属性创建一个特定的子类

我该怎么做呢

<items>
    <item>
        <event type="aaa">
            <timestamp>2014-04-10 15:58:08 UTC</timestamp>
        </event>
        <event type="bbb">
            <timestamp>2014-04-03 11:58:08 UTC</timestamp>
        </event>
    </item>
</items>

但是，我希望XStream为每个事件类型创建一个不同的类。 我有两个类EventAAA和EventBBB，它们都是从抽象事件扩展而来的。如何让XStream在解组时考虑到这一点？XStream当前总是尝试实例化事件，但由于它是抽象的，所以失败了

---

干杯

执行所需操作（及更多操作）的示例代码：

import com.thoughtworks.xstream.xstream；
导入com.thoughtworks.xstream.converters.Converter；
导入com.thoughtworks.xstream.converters.MarshallingContext；
导入com.thoughtworks.xstream.converters.UnmarshallingContext；
导入com.thoughtworks.xstream.io.HierarchycalStreamReader；
导入com.thoughtworks.xstream.io.HierarchycalStreamWriter；
导入java.util.ArrayList；
导入java.util.array；
/**
* http://stackoverflow.com/posts/23792750
*/
公共类应用程序{
公共静态类项目{
私人ArrayList e；
公共项目（ArrayList e）{
这个。e=e；
}
}
公共静态类项{
私人ArrayList e；
公共项目（ArrayList e）{
这个。e=e；
}
}
公共静态void main（字符串[]args）{
项目=新项目(
新阵列列表(
Arrays.asList(
新项目(
新阵列列表(
Arrays.asList（新的EventAAA（），新的EventBBB（））
)
)
)
)
);
XStream xs=新的XStream（）；
registerConverter（新的EventConverter（））；
registerConverter（newitemconverter（））；
别名（“item”，item.class）；
附加材料（项目类别“e”）；
别名（“items”，items.class）；
X.addImplicitArray（Items.class，“e”）；
System.out.println（“序列化单个事件对象：”）；
System.out.println（xs.toXML（neweventaaa（））；
System.out.println（xs.toXML（neweventbbb（））；
System.out.println（“反序列化单个事件对象：”）；
System.out.println（xs.fromXML（xs.toXML（neweventaaa（））.toString（））；
System.out.println（xs.fromXML（xs.toXML（neweventAAA（））.getClass（）.getName（））；
System.out.println（xs.fromXML（xs.toXML（neweventbbb（））.toString（））；
System.out.println（xs.fromXML（xs.toXML（neweventbbb（））.getClass（）.getName（））；
System.out.println（“显示ArrayList项的序列化：”）；
System.out.println（xs.toXML（items））；
System.out.println（“显示ArrayList项的反序列化：”）；
System.out.println（xs.fromXML（xs.toXML（items））；
System.out.println（“为e:”中的元素反序列化显示正确的类型信息”）；
Items items2=（Items）xs.fromXML（xs.toXML（Items））；
用于（项目i：项目2.e）{
对于（事件e：即）{
System.out.println（e.getClass（）.getName（））；
}
}
}
公共静态类时间戳{
公共时间戳（字符串时间戳）{
}
}
公共静态抽象类事件{
公共抽象字符串getTypeName（）；
私有时间戳时间戳=新时间戳（“”）；
公共无效设置时间戳（时间戳t）{
this.timestamp=t；
}
公共时间戳getTimestamp（）{
返回时间戳；
}
}
公共静态类EventAAA扩展事件{
@凌驾
公共字符串getTypeName（）{
返回“aaa”；
}
}
公共静态类EventBBB扩展事件{
@凌驾
公共字符串getTypeName（）{
返回“bbb”；
}
}
公共静态类ItemConverter实现转换器{
@凌驾
公共无效封送处理（对象o、HierarchycalStreamWriter编写器、封送上下文mc）{
第i项=第o项；
对于（事件e：即）{
作者：startNode（“事件”）；
mc.另一（e）；
writer.endNode（）；
}
}
@凌驾
公共对象解组（HierarchycalStreamReader阅读器，解组上下文uc）{
项目i=新项目（新ArrayList（））；
while（reader.hasMoreChildren（））{
i、 添加（（事件）uc.convertOther（i，事件类））；
}
返回i；
}
@凌驾
公共布尔canConvert（类类型）{
返回（type.equals（Item.class））；
}
}
公共静态类EventConverter实现转换器{
公共布尔canConvert（类clazz）{
返回Event.class.isAssignableFrom（clazz）；
}
公共无效封送处理（对象值、HierarchycalStreamWriter编写器、，
编组（上下文）{
事件e=（事件）值；
writer.addAttribute（“type”，例如getTypeName（））；
writer.startNode（“时间戳”）；
writer.setValue（例如getTimestamp（）.toString（））；
writer.endNode（）；
}
公共对象解组（HierarchycalStreamReader，
解组（上下文）{
字符串类型=reader.getAttribute（“类型”）；
事件e；
if（类型等于（“aaa”））{
e=新事件AAA（）；
}else if（类型等于（“bbb”））{
e=新事件bbb（）；
}否则{
抛出新的IllegalArgumentException（“遇到非法类型的事件：“+type”）；
}
reader.moveDown（）；
e、 setTimestamp（新的时间戳（reader.getValue（））；
reader.moveUp（）；
返回e；
}
}
}

Ou

    xstream.alias("items", Items.class);
    xstream.alias("event", Event.class);

import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.converters.Converter;
import com.thoughtworks.xstream.converters.MarshallingContext;
import com.thoughtworks.xstream.converters.UnmarshallingContext;
import com.thoughtworks.xstream.io.HierarchicalStreamReader;
import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
import java.util.ArrayList;
import java.util.Arrays;

/**
 * http://stackoverflow.com/posts/23792750
 */
public class App {

    public static class Items {

        private ArrayList<Item> e;

        public Items(ArrayList<Item> e) {
            this.e = e;
        }

    }

    public static class Item {

        private ArrayList<Event> e;

        public Item(ArrayList<Event> e) {
            this.e = e;
        }

    }

    public static void main(String[] args) {
        Items items = new Items(
                new ArrayList<Item>(
                        Arrays.asList(
                                new Item(
                                        new ArrayList(
                                                Arrays.<Event>asList(new EventAAA(), new EventBBB())
                                        )
                                )
                        )
                )
        );

        XStream xs = new XStream();

        xs.registerConverter(new EventConverter());
        xs.registerConverter(new ItemConverter());
        xs.alias("item", Item.class);
        xs.addImplicitArray(Item.class, "e");
        xs.alias("items", Items.class);
        xs.addImplicitArray(Items.class, "e");

        System.out.println("Serialize individual event objects:");
        System.out.println(xs.toXML(new EventAAA()));
        System.out.println(xs.toXML(new EventBBB()));
        System.out.println("De-serialize individual event objects:");
        System.out.println(xs.fromXML(xs.toXML(new EventAAA())).toString());
        System.out.println(xs.fromXML(xs.toXML(new EventAAA())).getClass().getName());
        System.out.println(xs.fromXML(xs.toXML(new EventBBB())).toString());
        System.out.println(xs.fromXML(xs.toXML(new EventBBB())).getClass().getName());

        System.out.println("Show serialization of ArrayList<Item> items:");
        System.out.println(xs.toXML(items));

        System.out.println("Show de-serialization of ArrayList<Item> items:");
        System.out.println(xs.fromXML(xs.toXML(items)));

        System.out.println("Show correct type information in de-serialization for elements in e:");
        Items items2 = (Items) xs.fromXML(xs.toXML(items));
        for (Item i : items2.e) {
            for (Event e : i.e) {
                System.out.println(e.getClass().getName());
            }
        }
    }

    public static class Timestamp {

        public Timestamp(String timestamp) {

        }
    }

    public static abstract class Event {

        public abstract String getTypeName();

        private Timestamp timestamp = new Timestamp("");

        public void setTimestamp(Timestamp t) {
            this.timestamp = t;
        }

        public Timestamp getTimestamp() {
            return timestamp;
        }
    }

    public static class EventAAA extends Event {

        @Override
        public String getTypeName() {
            return "aaa";
        }

    }

    public static class EventBBB extends Event {

        @Override
        public String getTypeName() {
            return "bbb";
        }

    }

    public static class ItemConverter implements Converter {

        @Override
        public void marshal(Object o, HierarchicalStreamWriter writer, MarshallingContext mc) {
            Item i = (Item) o;
            for (Event e : i.e) {
                writer.startNode("event");
                mc.convertAnother(e);
                writer.endNode();
            }
        }

        @Override
        public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext uc) {
            Item i = new Item(new ArrayList<>());
            while (reader.hasMoreChildren()) {
                i.e.add((Event) uc.convertAnother(i, Event.class));
            }
            return i;
        }

        @Override
        public boolean canConvert(Class type) {
            return (type.equals(Item.class));
        }

    }

    public static class EventConverter implements Converter {

        public boolean canConvert(Class clazz) {
            return Event.class.isAssignableFrom(clazz);
        }

        public void marshal(Object value, HierarchicalStreamWriter writer,
                MarshallingContext context) {
            Event e = (Event) value;
            writer.addAttribute("type", e.getTypeName());
            writer.startNode("timestamp");
            writer.setValue(e.getTimestamp().toString());
            writer.endNode();
        }

        public Object unmarshal(HierarchicalStreamReader reader,
                UnmarshallingContext context) {
            String type = reader.getAttribute("type");
            Event e;
            if (type.equals("aaa")) {
                e = new EventAAA();
            } else if (type.equals("bbb")) {
                e = new EventBBB();
            } else {
                throw new IllegalArgumentException("Encountered illegal type of event: " + type);
            }
            reader.moveDown();
            e.setTimestamp(new Timestamp(reader.getValue()));
            reader.moveUp();
            return e;
        }

    }

}

Serialize individual event objects:
<App_-EventAAA type="aaa">
  <timestamp>App$Timestamp@184cf7cf</timestamp>
</App_-EventAAA>
<App_-EventBBB type="bbb">
  <timestamp>App$Timestamp@5bfa9431</timestamp>
</App_-EventBBB>
De-serialize individual event objects:
App$EventAAA@48fa0f47
App$EventAAA
App$EventBBB@161479c6
App$EventBBB
Show serialization of ArrayList<Item> items:
<items>
  <item>
    <event type="aaa">
      <timestamp>App$Timestamp@5c909414</timestamp>
    </event>
    <event type="bbb">
      <timestamp>App$Timestamp@65466a6a</timestamp>
    </event>
  </item>
</items>
Show de-serialization of ArrayList<Item> items:
App$Items@3eb7fc54
Show correct type information in de-serialization for elements in e:
App$EventAAA
App$EventBBB