So when I found myself needing to parse XML in Java at a startup, I was faced with two possibilities: 1) spend too much time and frustration using traditional, verbose Java techniques, or 2) do something to make Java see XML like Javascript sees JSON – i.e. as an hierarchial hash. The strongly typed nature of Java means this isn’t an obvious thing to do. And it’s not immediately obvious that it’s even possible to do.

So I built a simple parser, literally, that turns XML into a hierarchical hash of so-called Simple objects. With one line of code, you can request XML from an external URL and get back a fully traversable hierarchical set of hash objects, just like you would with JSON or even something like E4X. You call it like so:

Simple result = new SimpleParser().parse("http://yourDomain.com/yourXmlResponse.xml");

That’s it! Much better than parsing with SAX and creating a bunch of container classes to consume the xml as type specific objects. So what can you do now that you have the result? Well, given some XML like this:

<Team>
    <TeamName>The Bandits</TeamName>
    <Players>
        <Player id=”0” name=”Bob”/>
        <Player id=”1” name=”Sam”/>
    </Players>
</Team>

You can make calls like this:

Simple team = result.getFirst(“Team”); //returns Simple object for the Team element

ArrayList<Simple> players = team.getList(“Player”); //returns
arraylist of players

String teamName = team.getFirstText(“TeamName”);  //returns “The Bandits”

String tname = team.getName(); //returns “Team”

//returns "Bob"
String playerOneName = result.getFirst(“Team”).getFirst(“Players”).getFirst(“Player”).get(“name”);

The key to this structure is something I call the Simple object. It’s just a wrapper around a couple of properties (the original element name and any text the element contained), a reference to its parent Simple object and a hash of child objects. It has a few useful methods. Use “get” to get an attribute value. Use “getList” to get a list of child elements. Use “getFirst” to get the first element of a list of child elements. And use “getFirstText” to get the text node of the first element of the child list.  The SimpleParser just builds a tree of heirarchial Simple object nodes as it parsers the XML. There is a one-to-one correspondence between the xml nodes and nodes in the Simple tree. Just look at the XML to find out how to get the data out of the tree.

Why use this?

Because it’s quick to implement and flexible. You can point any XML structure at this parser and get exactly the same behavior. No need to muck with SAX and container classes or even to use a schema-to-class generator like JAXB. The SimpleParser just works. It’s probably a little slower than pure SAX, but that doesn’t matter at all for most normal sized XML documents (the kind you consume over the web). At any rate, use it as you like. I built this because I couldn’t find anything like it. Maybe it will be what you are looking for too.

Limitations

While I think this approach goes most of the way to providing a similar experience to JSON parsing and object access, it fails in two important ways. First, it requires an additional object construct, namely the Simple object, to work. I’m not sure this limitation is really necessary. It seems possible that the hierarchical data structure could be implemented in some other way. Second, the object accessor notation is not as satisfying and is more verbose than JSON. Calling simpleObj.getFirst(“NodeName”) is not as nice as simpleObj.NodeName[0]. I’ve got a feeling this too is possible to duplicate through some tricky use of reflection, but it’s not something Java is particularly suited for. Java wants to be told what it’s getting ahead of time – which is perfectly reasonable. However, XML is really just a big tree of labels and strings, arranged hierarchically. Sometimes you need those types to be more specific. In those cases, something like SOAP is appropriate. But in most cases it’s really not necessary at all. In those cases, the simple approach is usually the best.

The Code

SimpleTest.java

public class SimpleTest {

	public static void main(String[] args) {
		System.out.println("Requesting some random XML...");
		Simple result = new SimpleParser().parse("http://feeds.guardian.co.uk/theguardian/rss");
		System.out.println(result.getFirst("rss").getFirst("channel").getFirst("title").getText()); //prints "The Guardian World News"
	}
}

Simple.java

import java.util.HashMap;
import java.util.LinkedHashMap;
import org.w3c.dom.*;
import java.util.ArrayList;
import java.util.Iterator;

public class Simple {
	public Simple parent = null;
	public LinkedHashMap childMap = new LinkedHashMap();
	private String text = "";
	private String name = "";

        //xml attribute strings are stored as top level keys in the child hash
	public String get(String key) {
		//System.out.println("Getting " + key + " from \n " + childMap);
		if (childMap.containsKey(key)) {
			return (String)(childMap.get(key));
		} else {
			return null;
		}
	}
        //xml child elements are stored as an arraylist, keyed by the element name
	public ArrayList getList(String key) {
		//System.out.println("Getting " + key + " from \n " + childMap);
		if (childMap.containsKey(key)) {
			return (ArrayList)(childMap.get(key));
		} else {
			return null;
		}
	}
        //gets the first child element from the arraylist of elements named by key
	public Simple getFirst(String key) {
		Object obj = childMap.get(key);
		if (obj != null) {
			if (obj instanceof ArrayList) {
				Object objFirst = ((ArrayList)obj).get(0);
				if (objFirst != null) {
					return (Simple)objFirst;
				} else {
					return null;
				}
			} else {
				return null;
			}
		} else {
			return null;
		}
	}

        //finds the arraylist of child elements matching key, gets the first element, and returns its text content
	public String getFirstText(String key) {
		Simple obj = getFirst(key);
		if (obj != null) {
			return obj.getText();
		} else {
			return "";
		}
	}

        //write out the entire node tree as json
	public String toJson() {
		StringBuffer sb = new StringBuffer();
		Iterator it = childMap.keySet().iterator();
		sb.append("{name:'" + name + "', text:'" + text + "',");
		StringBuffer attsb = new StringBuffer();
		StringBuffer chsb = new StringBuffer();
		while(it.hasNext()) {
		    String key = String.valueOf(it.next());
			Object val = childMap.get(key);
			chsb.append("\t");
			if (val != null) {
				if (val instanceof String) {
					attsb.append(key + ": '" + val + "', ");
				} else if (val instanceof ArrayList) {
					//recursively child simple object toJson methods
					ArrayList sarr = (ArrayList) val;
					for (Simple cs : sarr) {
						chsb.append(cs.toJson());
					}
				}
			}
		}	

		sb.append(" attributes: {" + attsb.toString() + "}, ");
		sb.append("children: [" + chsb.toString() + "]");

		sb.append("\n}\n");	

		return sb.toString();
	}

        //the original xml elements tag name
	public String getName() {
		return name;
	}
	public void setName(String val) {
		name = val;
	}

        //the text content, if any, of the original xml element
	public String getText() {
		return text;
	}
	public void setText(String val) {
		text = val;
	}	

        //override default toString, print out the important info for the simple object, good for debugging
	public String toString() {
		return String.format("\nname: %s; parent: %s; text: %s; children: %s;", name, parent == null ? "null" : parent.name, text, childMap);
	}

        //similar to toString, but print out the simple object data in a useful way for web page debugging
	public String toHtmlString() {
		return String.format("name: %s text: %s attributes: %s", name, text, dumpAttributes(childMap));
	}	

        //print the hash contents to a string; used in debug output
	public static String dumpHash(HashMap map) {
		String output = "";
		for(Object s : map.keySet()) {
			output += s + ": " + map.get(s) + "; ";
		}
		return output;
	}

	public static String dumpAttributes(HashMap map) {
		String output = "";
		for(Object s : map.keySet()) {
			Object val = map.get(s);
			if (val instanceof String) {
				output += s + ": " + val + "; ";
			}
		}
		return output;
	}
}

SimpleParser.java

import javax.xml.parsers.*;
import org.w3c.dom.*;
import java.util.HashMap;
import java.util.ArrayList;
import java.io.*;
import java.net.URL;
import org.xml.sax.*;
import java.net.URLConnection;
import java.net.MalformedURLException;

/*simple objects from xml parser
	What's a simple object? an object that contains an xml element node and a ref to its parent and child simple objects.
	This parser is in the spirit of E4X. It takes the hierarchial data of xml and re-creates that using hash tables and array lists.
	author: will
	*/
public class SimpleParser {	

	public Simple parse (String strUrl) {

		URL url = null;
		try {
			url = new URL(strUrl);
		} catch (MalformedURLException e) {
			System.out.println(e.getMessage());
			//do something
		}

		InputStream is = null;

		try {
			URLConnection conn = url.openConnection();
			is = conn.getInputStream();
			InputSource input = new InputSource(is);
			//input.setEncoding("ISO-8859-1");
			DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
			Document doc = builder.parse(input);

			Simple simple = new Simple();
			parseNode(simple, doc);	

			return simple;
		}
		catch (Exception e) {
			// log.error("error: msg: " + e.toString());
			// log.error("error: url: " + url.toString());
			// log.error("error: response: " + (is == null ? "null" : convertStreamToString(is)));
			System.out.println(e.getMessage());
			return null;
		}		

	}
	public void parseNode(Simple simple, Node node) throws Exception {
		//Node node = simple.node;
		HashMap parentMap = simple.parent != null ? simple.parent.childMap : null;		

		if(node == null) {
			return;
		}
		int type = node.getNodeType();

		switch (type) {
			// handle document nodes
			case Node.DOCUMENT_NODE: {
				Simple docBucket = new Simple();
				docBucket.parent = simple;
				docBucket.setName("_ROOT");
				parseNode(docBucket, ((Document)node).getDocumentElement());
				break;
			}
			// handle element nodes
			case Node.ELEMENT_NODE: {
				String elementName = node.getNodeName();
				simple.setName(elementName);	

				if (parentMap != null) {
					if (!parentMap.containsKey(elementName)) {
						parentMap.put(elementName, new ArrayList());
					}

					((ArrayList)parentMap.get(elementName)).add(simple);
				}

				NamedNodeMap attrs = node.getAttributes();
				for(int i = 0 ; i<attrs.getLength() ; i++) {
					Attr att = (Attr)attrs.item(i);
					simple.childMap.put(att.getName(), att.getValue());
				}				

				NodeList childNodes = node.getChildNodes();
				if(childNodes != null) {
					int length = childNodes.getLength();
					for (int loopIndex = 0; loopIndex < length ; loopIndex++) {
						Simple childBucket = new Simple();
						Node cnode = childNodes.item(loopIndex);
						childBucket.setName(cnode.getNodeName());
						childBucket.parent = simple;
						parseNode (childBucket, cnode);
					}
				}
				break;
			}
			// handle text nodes
			case Node.TEXT_NODE: {
				String data = node.getNodeValue().trim();

				if((data.indexOf("\n")  0)) {
					simple.parent.setText(simple.parent.getText() + data);
				}
			}
		}
	}

	public static String convertStreamToString(InputStream is) {
        BufferedReader reader = new BufferedReader(new InputStreamReader(is));
        StringBuilder sb = new StringBuilder();

        String line = null;
        try {
            while ((line = reader.readLine()) != null) {
                sb.append(line + "\n");
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return sb.toString();
	}
}

I would argue that programming – what I would call intentional logic – is somewhere in the late theoretical stage. All programs aim to do something, they reach out toward some goal. That is why programming is intentional and also why it is particularly hard for code, as a medium, to reach the aesthetic stage. Certainly code can be seen as more or less elegant, and the product it creates can be more or less beautiful and usable, but programmers are still, by and large, mere artisans.

It is difficult to say what the aesthetic stage of code would look like. It’s hard to imagine a block of code in a museum or hung above a mantle. But this assumes that programs will always be expressed in the terse, symbolic form that they are now. I would argue that we are at a very early stage of code as a medium. The trend in the development of programming languages is toward higher levels of abstraction. Perhaps one day it will be possible to express a program with a chisel or paintbrush. Perhaps even the Venus de Milo – when scanned with some future, aesthetic interpreter – will become a meaningful program.

The major downside is that you lose Active Record. Google, of course, has its own BigTable data layer implementation. I think a rails-like wrapper is inevitable – Ola Bini is already working on one (Bumble) – but that won’t help much for now. BigTable is basically just a massively distributed object hash, so the API mostly revolves around creating and modifying data objects. Not pretty, fairly inelegant, but it works.

I won’t go through the precise steps to set this up, because that’s already been done here. Those steps worked perfectly for me, with one caveat. Make sure you set the following props to false in config/init.rb:
c[:reload_classes] = false,
c[:reload_templates] = false,
Those can be set to true in dev for testing, but you’ll get an unhelpful permissions exception when you deploy to app engine if you don’t first set them to false.

Why Merb? Mostly because that’s what the setup directions used, but also because you can’t use ActiveRecord anyway. I also read that Merb is basically getting taken over/taking over Rails anyhow.

1. Start tomcat in debug mode
./catalina.sh jpda run
This will start tomcat in debug mode and send the log output to the console.

2. Start jpd
jpd is the command line debugger for java. It’s very basic, but it does most things you need. Start it like this:
jdb -attach 8000 -sourcepath "[path-to-your-tomcat-webapp]"

That’s it for getting started. jpd will attach to your tomcat process and wait for you to give it some instructions.

Here are a few examples:

1. Set a break point
stop at com.yourdomain.YourClass:45
This will set a break point at line 45 in YourClass. Go load a page in your browser that hits that code. Once the break point is hit you can do stuff like:
2. Get the value of a variable
print someVar
3. Look at local variables
locals

For a full list of commands, check out this.