Como construir um documento XML em Java concisa?

Question

Preciso criar um documento XML a partir de uma hierarquia de objetos Java. As classes Java e o formato XML são fixadas. Então eu não posso usar um serializador XML como Xstream: Baseia o formato XML nas classes Java. Da mesma forma, uma tecnologia de ligação a Java XML como JAXB Não vai funcionar, pois cria aulas de java do esquema XML [ed: mas veja abaixo]. Eu preciso de uma abordagem manual.

A rota StringBuilder de baixa tecnologia resulta em código frágil e de buggy (pelo menos para mim!).

Uma API gosta JAXP ou JDOM leva a um código muito mais robusto, mas estes são bastante detalhados.

Groovy tem um 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')
  }
}

Outros idiomas (por exemplo. Rubi) Tenha ainda melhores, embora eu queira ficar com o puro java. Parece haver alguns novos construtores de XML para Java, como Practicalxml e James Murty's xmlbuilder.

Quais são as abordagens mais elegantes para a construção de documentos XML em Java?

Resumo:

Jon Doe sugeriu DOM4J e JDOM.

O CurtainDog recomendou o uso do JAXB de qualquer maneira, e Jherico me criticou, pois essa era uma sugestão pertinante: você poderia usar o Dozer para mapear entre meus Javabeans atuais e o Jaxb Javabeans.

Thaggie recomenda Jibx e concordou com o CurtainDog e o Jherico que as tecnologias de ligação são realmente práticas.

Staxman recomenda Staxmate.

Das coisas que eu olhei, o XMLBuilder de James Murty parece ser os construtores mais concisos, embora sejam bastante novos. As tecnologias de ligação como o JAXB parecem oferecer segurança/automação extra. Das escolhas convencionais, DOM4J Parece decente, embora ainda meio detalhado. Oferece uma "interface fluente" (os mutadores retornam uma referência ao objeto mutado para que possam ser acorrentados), o que eu gosto:

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 concisão, você pode envolver uma fachada fina sobre essa API para fornecer sinônimos conciso para alguns desses métodos (por exemplo, att () em vez de addattribute ()).

Obrigado a todos!

PS: Stephan Schmidt trabalhou em um java MarkupBuilder, embora pareça não ter publicado.

Answer 1

DOM4J ou JDOM é provavelmente o mais elegante, você pode escrever código como você gosta. DOM4J tem construtores, se bem me lembro, e sim, o código é mais detalhado.

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

Answer 2

Dar uma olhada em Xom. É rápido, simples, correto e não é detalhado.

Answer 3

Por que você não usa JAXB de qualquer maneira. Então o problema se torna um objeto muito simples para mapear objetos e você evita o XML completamente.

Answer 4

Embora não seja tão conciso quanto os construtores em idiomas de script, Staxmate torna as coisas bastante simples; Geralmente tão simples quanto os modelos de árvores estruturalmente, mas também suporta adição digitada (conversões implícitas). E faz tudo isso diretamente em um fluxo, o que significa uso de memória muito baixo (e alta velocidade, se isso importa).

Pelo que vale a pena, também suporta estilo fluente (a partir de 2.0.x), pois geralmente faz sentido. O principal benefício sobre soluções completas de ligação de dados (e modelo de árvore) é provavelmente o baixo uso da memória; Muito pouco estado é mantido por perto, toda a saída sai para o destino o mais rápido possível.

Answer 5

Você pode considerar Jibx, você poderá definir um mapeamento Das suas classes de modelo de domínio ao seu esquema XML de destino.

Como alternativa, se isso não for possível, embora eu saiba que você afirma que você desconsiderou o uso de tecnologias de ligação, eu o encorajará a revisar essa decisão, copiar do seu modelo de domínio em um modelo gerado provavelmente fará com que seja mais limpo, mais sustentável e menos Código propenso a erros do que você está propondo (que o Jibx também pode fazer).

Eu provavelmente deveria acrescentar, na minha experiência, fazer perguntas sobre o JIBX aqui é infrutífero, mas a lista de e -mails deles é muito útil.