¿Cómo construir un documento XML en Java de forma concisa?

Question

Necesito construir un documento XML a partir de una jerarquía de objetos Java. Tanto las clases Java como el formato XML son fijos. Por lo tanto, no puedo usar un serializador XML como XStream : basa el formato XML en las clases de Java. Del mismo modo, una tecnología de enlace XML Java como JAXB no funcionará, ya que crea clases Java a partir del esquema XML [ ed: pero ver abajo]. Necesito un enfoque manual.

La ruta StringBuilder de baja tecnología da como resultado un código frágil y con errores (¡al menos para mí!).

Una API como JAXP o JDOM conduce a un código mucho más robusto, pero estos son bastante detallados.

Groovy tiene un elegante MarkupBuilder :

def writer = new StringWriter()
def xml = new MarkupBuilder(writer)
xml.records() {
  car(name:'HSV Maloo', make:'Holden', year:2006) {
    country('Australia')
    record(type:'speed', 'Production Pickup Truck with speed of 271kph')
  }
  car(name:'P50', make:'Peel', year:1962) {
    country('Isle of Man')
    record(type:'size', 'Smallest Street-Legal Car at 99cm wide and 59 kg')
  }
}

Otros idiomas (por ejemplo, Ruby ) tienen incluso mejores, aunque quiero quedarme con Java puro. Parece que hay algunos nuevos constructores XML para Java, como practicexml y James Murty's xmlbuilder .

¿Cuáles son los enfoques más elegantes para crear documentos XML en Java?

Resumen :

Jon Doe sugirió dom4j y jdom .

CurtainDog me recomendó usar JAXB de todos modos, y jherico me dio una idea de que se trataba de una sugerencia pertinente: luego podría usar Dozer para mapear entre mis JavaBeans actuales y los JavaBeans JAXB.

thaggie recomienda JIBX y acordó con CurtainDog y jherico que las tecnologías de enlace son realmente prácticas.

StaxMan recomienda StaxMate .

De las cosas que he visto, prácticoxml y xmlbuilder de James Murty parecen ser los constructores más concisos, aunque son bastante nuevos. Las tecnologías vinculantes como JAXB parecen ofrecer seguridad / automatización adicional. De las opciones principales, dom4j parece decente, aunque todavía es bastante detallado. Ofrece una "interfaz fluida" (los mutadores devuelven una referencia al objeto mutado para que puedan encadenarse), lo que me gusta:

public Document createDocument() {
    Document document = DocumentHelper.createDocument();
    Element root = document.addElement( "root" );
    Element author2 = root.addElement( "author" )
      .addAttribute( "name", "Toby" )
      .addAttribute( "location", "Germany" )
      .addText( "Tobias Rademacher" );
    Element author1 = root.addElement( "author" )
      .addAttribute( "name", "James" )
      .addAttribute( "location", "UK" )
      .addText( "James Strachan" );
    return document;
}

Para ser concisos, puede envolver una fachada delgada sobre esta API para proporcionar sinónimos concisos para algunos de estos métodos (por ejemplo, attr () en lugar de addAttribute ()).

¡Gracias a todos!

PD: Stephan Schmidt trabajó en un Java MarkupBuilder , aunque parece no haberlo publicado.

Answer 1

dom4j o jdom son probablemente los más elegantes, puedes escribir código como quieras. Dom4j tiene constructores, si recuerdo, y sí, el código es más detallado.

Element.addElement("x").setAttribute("x", "y").xxxxx;

Answer 2

Eche un vistazo a XOM . Es rápido, simple, correcto y no es detallado.

Answer 3

¿Por qué no usas JAXB de todos modos? ... entonces el problema se convierte en un mapeo de objeto a objeto muy simple y evitas xml por completo.

Answer 4

Aunque no es tan conciso como los constructores en lenguajes de script, StaxMate hace las cosas bastante simples; generalmente tan simple como los modelos de árbol estructuralmente, pero también admite la adición escrita (conversiones implícitas). Y todo esto directamente en una transmisión, lo que significa un uso de memoria muy bajo (y alta velocidad si eso es importante).

Por lo que vale, también admite un estilo fluido (a partir de 2.0.x), ya que a menudo tiene sentido. El principal beneficio sobre las soluciones de enlace de datos completo (y modelo de árbol) es probablemente el bajo uso de memoria; se mantiene muy poco estado, toda la salida sale a destino lo antes posible.

Answer 5

Puede considerar JIBX , puede definir un mapeo de sus clases de modelo de dominio a su esquema XML de destino.

Alternativamente, si eso no es posible, aunque sé que declaras que has descontado el uso de tecnologías vinculantes, te animo a que revises esa decisión, copiar de tu modelo de dominio en un modelo generado probablemente hará que sea más limpio y más Código mantenible y menos propenso a errores que el que está proponiendo (que JIBX también puede hacer).

Probablemente debería agregar, en mi experiencia, hacer preguntas sobre JIBX aquí es infructuoso, pero su lista de correo es muy útil.