tutorial - xml parsing java

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

Question

Necesito crear un documento XML desde una jerarquía de objetos Java. Tanto las clases de Java como el formato XML son fijos. Así que 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 de Java como JAXB no funcionará, ya que crea clases de Java a partir del esquema XML [ed: pero ver más abajo]. Necesito un enfoque manual.

La ruta de baja tecnología StringBuilder da como resultado un código frágil y defectuoso (¡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 seguir usando Java puro. Parece que hay algunos nuevos creadores de XML para Java, como practicalxml y xmlbuilder James Murty.

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

Resumen:

Jon Doe sugirió dom4j y JDOM .

CurtainDog recomendó el uso de JAXB de todos modos, y Jherico me dijo que esta era una sugerencia pertinente: luego podría usar Dozer para mapear entre mi JavaBeans actual y el JavaBeans JAXB.

thaggie recomienda JIBX y estuvo de acuerdo con CurtainDog y jherico en que las tecnologías de unión 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 de unión como JAXB parecen ofrecer seguridad / automatización adicionales. De las opciones principales, dom4j parece decente, aunque todavía algo verboso. Ofrece una "interfaz fluida" (los mutadores devuelven una referencia al objeto mutado para que puedan ser encadenados), 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 una mayor concisión, podría ajustar 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

¿Por qué no usas JAXB de todos modos? Entonces, el problema se convierte en un objeto muy simple para la asignación de objetos y evitas el xml por completo.

Answer 2

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

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

Answer 3

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

Answer 4

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

Alternativamente, si eso no es posible, aunque sé que declara que ha descontado el uso de tecnologías de enlace, le recomiendo que revise esa decisión, copiar de su modelo de dominio en un modelo generado probablemente será más limpio, más fácil de mantener y menos código propenso a errores que lo que está proponiendo, (lo 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.

Answer 5

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

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