What Java XML library do you recommend (to replace dom4j)?

I'm looking for something like dom4j, but without dom4j's warts, such as bad or missing documentation and seemingly stalled development status.

Background: I've been using and advocating dom4j, but don't feel completely right about it because I know the library is far from optimal (example: see how methods in XSLT related Stylesheet class are documented; what would you pass to run() as the String mode parameter?)

Requirements: The library should make basic XML handling easier than it is when using pure JDK (javax.xml and org.w3c.dom packages). Things like this:

• Read an XML document (from file or String) into an object, easily traverse and manipulate the DOM, do XPath queries and run XSLT against it.
• Build an XML document in your Java code, add elements and attributes and data, and finally write the document into a file or String.

I really like what dom4j promises, actually: "easy to use, open source library for working with XML, XPath and XSLT [...] with full support for DOM, SAX and JAXP." And upcoming dom4j 2.0 does claim to fix everything: fully utilise Java 5 and add missing documentation. But unfortunately, if you look closer:

> Warning: dom4j 2.0 is in pre-alpha > stage. It is likely it can't be > compiled. In case it can be compiled > at random it is likely it can't run. > In case it runs occasionally it can > explode suddenly. If you want to use > dom4j, you want version 1.6.1. Really.

...and the website has said that for a long time. So is there a good alternative to dom4j? Please provide some justification for your preferred library, instead of just dumping names and links. :-)

Sure, XOM :-)

> XOM is designed to be easy to learn > and easy to use. It works very > straight-forwardly, and has a very > shallow learning curve. Assuming > you're already familiar with XML, you > should be able to get up and running > with XOM very quickly.

I use XOM for several years now, and I still like it very much. Easy to use, plenty of documentation and articles on the web, API doesn't change between releases. 1.2 was released recently.

> XOM is the only XML API that makes no > compromises on correctness. XOM only > accepts namespace well-formed XML > documents, and only allows you to > create namespace well-formed XML > documents. (In fact, it's a little > stricter than that: it actually > guarantees that all documents are > round-trippable and have well-defined > XML infosets.) XOM manages your XML so > you don't have to. With XOM, you can > focus on the unique value of your > application, and trust XOM to get the > XML right.

Check out web page http://www.xom.nu/ for FAQ, Cookbook, design rationale, etc. If only everything was designed with so much love :-)

Author also wrote about What's Wrong with XML APIs (and how to fix them). (Basically, reasons why XOM exists in the first place)

Here is also 5-part Artima interview with author about XOM, where they talk about what's wrong with XML APIs, The Good, the Bad, and the DOM, A Design Review of JDOM, Lessons Learned from JDOM and finally Design Principles and XOM.

The one built into the JDK ... with a few additions.

Yes, it's painful to use: it is modeled after W3C specs that were clearly designed by committee. However, it is available anywhere, and if you settle on it you don't run into the "I like Dom4J," "I like JDOM," "I like StringBuffer" arguments that come from third-party libraries. Especially since such arguments can turn into different pieces of code using different libraries ...

However, as I said, I do enhance slightly: the Practical XML library is a collection of utility classes that make it easier to work with the DOM. Other than the XPath wrapper, there's nothing complex here, just a bunch of routines that I found myself rewriting for every job.

I've been using [XMLTool][1] for replacing Dom4j and it's working pretty well.

XML Tool uses Fluent Interface pattern to facilitate XML manipulations:

XMLTag tag = XMLDoc.newDocument(false)
   .addDefaultNamespace("http://www.w3.org/2002/06/xhtml2/")
   .addNamespace("wicket", "http://wicket.sourceforge.net/wicket-1.0")
   .addRoot("html")
   .addTag("wicket:border")
   .gotoRoot().addTag("head")
   .addNamespace("other", "http://other-ns.com")
   .gotoRoot().addTag("other:foo");
System.out.println(tag.toString());

It's made for Java 5 and it's easy to create an iterable object over selected elements:

for (XMLTag xmlTag : tag.getChilds()) {
   System.out.println(xmlTag.getCurrentTagName());
}

[1]: https://github.com/mycila/xmltool "XMLTool"

I've always liked jdom. It was written to be more intuitive than DOM parsing(and SAX parsing always seems clumsy anyway).

From the mission statement:

> There is no compelling reason for a > Java API to manipulate XML to be > complex, tricky, unintuitive, or a > pain in the neck. JDOMTM is both > Java-centric and Java-optimized. It > behaves like Java, it uses Java > collections, it is completely natural > API for current Java developers, and > it provides a low-cost entry point for > using XML.

That's pretty much been my experience - fairly intuitive navigation of node trees.

I use XStream, its a simple library to serialize objects to XML and back again.

it can be annotation-driven (like JAXB), but it has very simple and easy to use api and you can even generate JSON.

I'll add to the built-in answer by @kdgregory by saying why not JAXB?

With a few annotations its pretty easy to model most XML documents. I mean your probably going to parse the stuff and put in an object right?

JAXB 2.0 is built in to JDK 1.6 and unlike many other builtin javax libraries this one is pretty good (Kohusuke worked on it so you know its good).

In a recent project I had to do some XML parsing, and ended up using Simple Framework, recommended by a colleague.

I was quite happy with it in the end. It uses an annotation-based approach of mapping XML elements and attributes to Java classes and fields.

<example>
  <a>
    <b>
      <x>foo</x>
    </b>
    <b>
      <y>bar</y>
    </b>
  </a>
</example>

Corresponding Java code:

@Root
public class Example {

   @Path("a/b[1]")
   @Element
   private String x;

   @Path("a/b[2]")
   @Element
   private String y;
}

It's all quite different from dom4j or XOM. You avoid writing silly, boilerplatey XML handling code, but at first you'll probably bang your head against a wall for a while trying to get the annotations right.

(It was me who asked this question 4 years ago. While XOM seems a decent and quite popular dom4j replacement, I haven't come to fully embrace it. Curious that no-one had mentioned Simple Framework here. I decided to fix that, as I'd probably use it again.)

In our project we are using http://www.castor.org/ but just for small XML files. It's really easy to learn, needs just a mapping XML file (or none if the XML tags match perfectly class attributes) and it's done. It supports listeners (like callbacks) to perform additional processing. The cons: it is not a Java EE standard like JAXB.

you can try JAXB, with annotations its very handy and simple to do: Java Architecture for XML Binding.

I'm sometimes using Jericho, which is primarily HTML parser, but can parse any XML-like structure.

Of course it is only for the simplest XML operations, such as finding tags with given name, iterating through structure, replacing tags and its attributes, but aren't this the most use cases?

For building XML documetns, I suggest xmlenc. It is used in cassandra.