I've recently had a lot of XML generating to do in Java code. A boring job. Its an integration piece between two companies to swap some data. The XML is as simple as it can be, each data item is needed. The data is fetched from a database, a webservices and the filesystem. Very little of the XML is static.
The code is not elegant. Using a templating system like
JSP or freemarker would not be a good fit: all the data is
pulled from somewhere in Java code. There would be more code than
template.
Writing this code in Java using the standard org.w3c.dom API results in a lot of boilerplate code. For each new element you have to doc.createElement() and then reference the parent node and insert the element someElem.appendChild() then set the text content and or attributes.
I've used Dom4j and JDom before and they are nicer APIs but still nothing revolutionary.
I woke up in the middle of the night last night with a really cool fix to this problem in my head.
XPaths are a very expressive way of searching in XML, the idea was to use XPath like expressions for generating new Elements in the XML.
Still not sure about the name for this little library, for now its "XGen" and the paths are "xGenPaths".
The following xGenPath will create the expected XML output.
/html/body/div#container/table.table/tbody/tr[5]
In a oneliner!
This is much much more concise than a series of create, append lines like this
Element bodyElem = createElement("body");
htmlElem.appendChild(bodyElement);
Element divElem = createElement("div");
bodyElem.appendChild(divElement);
divElem.setAttribute("id", "container");
...
I set about development, after one false start trying to implement subclass Java's Node and NodeList. I've come up with a very neat little library in less than a day. All the objects are org.w3c.dom objects and the code is separated to helper functions.
Its very easy to mix and match between w3c APIs and the helper functions.
The ouput is an org.w3c.dom.Document.
Its simple and elegant.
The flow of typical code is like this
XGen xGen = XGenFactory.newInstance();
// New document with an xGenPath to start you off
xGen.newDocument("/html{lang=en}/head/title").setTextContent(TITLE);
// select with XPaths and create with xGenPaths
xGen.select("//head").create("link{rel=stylesheet}")
select() and create() return org.w3c.dom.NodeList instances containing the tail nodes just created or modified, and with a few bells and whistles includeing the ability to mutate all the items in the nodelist with familiar methods.
select("//div").setAttribute("foo", "baz");
creates the foo attribute on all the divs in the document and returns the list of nodes.
This enables chaining together statements to create elements and attributes and you end up with some very concise code to build up an XML doc.
XGen xGen = XGenFactory.newInstance();
xGen.newDocument("/xml")
.create("div/ul/li[3]")
.setTextContent("foo")
.setAttribute("abc", "123")
.create("a/span")
.setAttribute("class", "grey");
xGen.serialize(System.out);
The create method also contains an each() method for generating specific content for each node created with an xGenPath.
final int[]i = new int[1];
XGen xGen = XGenFactory.newInstance();
xGen.newDocument("/xml")
.create("div/ul/li[3]").setTextContent("a", "b", "c")
.each(new NodeMutator() {
public Node each(Node node) {
((Element)node).setAttribute("id", "123-" + i[0]++);
return node;
}
});
xGen.serialize(System.out);
which results in
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<xml>
<div>
<ul>
<li id="123-0">a</li>
<li id="123-1">b</li>
<li id="123-2">c</li>
</ul>
</div>
</xml>
Pretty slick if I do say so myself and crying out for lamda functions.
I'm downloading JDK-8 as we speak, slight worried there is no Icedtea JDK8 yet, but this library is going to be some much smoother with lambdas.
get it here
https://github.com/teknopaul/generation-x
