JAXB：将一个类中的不同XML元素编组/解组

Let's say, I have the following class:

比方说,我有以下课程:

@XmlRootElement
class Payment {
    @XmlElement
    int amount;
    @XmlElement
    Currency currency;

    @XmlElement
    IResponse response;
}

If response==null - the element is a "request", otherwise - the element is a "response". When a request, the element should be (un)marshaled to (from) the root element called PaymentRequest, when a response - to (from) PaymentResponse.

如果response == null - 该元素是“请求”,否则 - 该元素是“响应”。当一个请求时,该元素应该被(un)封送到(来自)称为PaymentRequest的根元素,当一个响应 - 来自(来自)PaymentResponse。

How can I configure such marshaling algorithm? If JAXB can't do it, maybe some other engine can?

如何配置这样的编组算法?如果JAXB无法做到,也许其他一些引擎可以吗?

2 个解决方案

#1

Create and marshal the root element like this:

像这样创建和编组根元素:

JAXBElement<Payment> jbe;
if( payment.getResponse() != null ){
    jbe = wrap( null, "PaymentResponse", payment );
} else {
    jbe = wrap( null, "PaymentRequest", payment );
}
m.marshal( jbe, sw );

with the simple helper method

用简单的帮助方法

<T> JAXBElement<T> wrap( String ns, String tag, T o ){
    QName qtag = new QName( ns, tag );
    Class<?> clazz = o.getClass();
    @SuppressWarnings( "unchecked" )
    JAXBElement<T> jbe = new JAXBElement( qtag, clazz, o );
    return jbe;
}

A simple way to make unmarshalling possible is to create two subclasses PaymentResponse and PaymentRequest which act as @XmlRootElements. The ObjectFactory contains

使编组成为可能的一种简单方法是创建两个子类PaymentResponse和PaymentRequest,它们充当@XmlRootElements。 ObjectFactory包含

@XmlElementDecl(namespace = "", name = "PaymentRequest")
public JAXBElement<PaymentRequest> 
createPaymentRequest(PaymentRequest value) {
    return new JAXBElement<PaymentRequest>(_Payment_QNAME, PaymentRequest.class, null, value);
}
@XmlElementDecl(namespace = "", name = "PaymentResponse")
public JAXBElement<PaymentResponse> 
createPaymentResponse(PaymentResponse value) {
    return new JAXBElement<PaymentResponse>(_Payment_QNAME, PaymentResponse.class, null, value);
}

Unmarshalling:

JAXBContext jc = JAXBContext.newInstance( PACKAGE );
Unmarshaller m = jc.createUnmarshaller();
JAXBElement<?> tb = null;
try {
    Payment payment = readFrom( Payment.class );
} catch( Exception e  ){
}

and the method readFrom:

和方法readFrom:

public <T> T readFrom( Class<T> type ) throws Exception {
    try {
        JAXBContext jc = JAXBContext.newInstance( PACKAGE );
        Unmarshaller u = jc.createUnmarshaller();
        JAXBElement<T> jbe = (JAXBElement<T>)u.unmarshal( new File( XMLIN ) );
        return type.cast( jbe.getValue() );
    } catch (JAXBException e) {
        e.printStackTrace();
    }
    return null;
}

#2

I've finally implemented the unmarshaling by intercepting StAX events. Here is the code:

我终于通过拦截StAX事件来实现解组。这是代码:

JAXBContext jc = JAXBContext.newInstance(RootElement.class, A.class, B.class, C.class, D.class, E.class);
Unmarshaller unmarsh = jc.createUnmarshaller();
XMLStreamReader xs = XMLInputFactory.newInstance().createXMLStreamReader(new StringReader(etalonRs));
XMLStreamReader xd = new StreamReaderDelegate(xs) {
      public static final String ROOT_ELEMENT = "TestRoot";
      public static final int REPLACEABLE_LEVEL = 2;
      public final Collection<String> sufficesToDelete = Arrays.asList("Rq", "Rs");

      protected Stack<String> elementNamesStack = new Stack<>();
      protected Set<String> replaceableNames = new HashSet<>();

      @Override
      public String getLocalName() {
          String realName = super.getLocalName();
          if (replaceableNames.contains(realName) && elementNamesStack.size() == REPLACEABLE_LEVEL) {
              for (String suffix : sufficesToDelete) {
                  if (realName.endsWith(suffix)) {
                      return realName.substring(0, realName.lastIndexOf(suffix));
                  }
              }
          }
          return realName;
      }

      @Override
      public int next() throws XMLStreamException {
          final int eventCode = super.next();
         processLevel(eventCode);
          return eventCode;
      }

      @Override
      public int nextTag() throws XMLStreamException {
          final int eventCode = super.nextTag();
          processLevel(eventCode);
          return eventCode;
      }

      private void processLevel(int eventCode) {
          switch (eventCode) {
              case XMLStreamReader.START_ELEMENT:
                  final String origElementName = super.getLocalName();
                  if ((elementNamesStack.size() + 1) == REPLACEABLE_LEVEL && elementNamesStack.peek().equals(ROOT_ELEMENT))
                      replaceableNames.add(origElementName);
                  elementNamesStack.push(origElementName);
                  break;
              case XMLStreamReader.END_ELEMENT: 
                  assert(elementNamesStack.pop().equals(super.getLocalName()));
                  break;

          }
      }
  };

Object o = unmarsh.unmarshal(xd);

Here are my test classes. Yes, the real structure in production is more complicated - there are different "payments" and their elements are not in the root, so I've had to use the @XmlAnyElement annotation:

这是我的测试课程。是的,生产中的真实结构更复杂 - 有不同的“付款”,它们的元素不在根目录中,所以我不得不使用@XmlAnyElement注释:

@XmlAccessorType(XmlAccessType.FIELD)
@XmlRootElement(name = "TestRoot")
public static class RootElement {
    @XmlElement(name = "SomeDate")
    private Date dt = new Date();

    @XmlAnyElement(lax=true)
    private A a = new C();
}

@XmlAccessorType(XmlAccessType.FIELD)
@XmlRootElement(name = "TestA")
@XmlType
public static abstract class A {
    private int fld1 = 1;

    @XmlAnyElement(lax=true)
    @XmlElementWrapper
    protected List<Object> list = new ArrayList<>();
}

@XmlAccessorType(XmlAccessType.FIELD)
@XmlRootElement(name = "TestC")
public static class C extends A {
    private int fld2  = 3;
}

Marshaling can be implemented in the same manner, but you have to write your "StreamWriterDelegate" from scratch.

编组可以以相同的方式实现,但您必须从头开始编写“StreamWriterDelegate”。

#1