Overview
One of the problems you run into when you're writing communicative applications like these is that you need to know that you're sending and receiving proper data. Most of the projects I've worked on recently are just these types of applications - and I quickly found that I needed to determine two things: (1) the validity of the data being returned, and (2) whether the server was handling the incoming data properly.

The first - determining that the server is returning proper data - is very simple in its purest form: a request can be made via the GET method and most current browsers will render the XML that the server responds with. Although testing the validity of the response data is easy using a GET request, it is more important to know that it is responding that way as a result of being invoked with an actual request containing XML.

Which leads me to the next point, testing to make sure your server application is handling the incoming XML documents properly. What this really means is that you want to know that your application will handle an incoming XML document, and that it will perform properly. By invoking your application with XML, you can test whether, given good input, your application will respond properly and, given bad data, whether it will behave in the manner you anticipate.

I knew this wouldn't be the last application to require my testing the sending and receiving of XML, so I decided to write a generic tool to facilitate the process.

The Tool
The tool itself is simple, and I've oversimplified it by putting almost all of the client code in one class. First let's have a look at the user interface, shown in Figure 1.

As you can tell, it's a very simple application - a button to allow you to choose an XML document, a place to type in a URL, a text box to display the results from the server, and a button to initiate the POST. A look at the code in Listing 1 gives you the following methods:

private void getXMLFile() & private void postData()

The postData method is what actually does the most work - too much work for an individual method, but, for simplicity, all the really important code is in one place. We start by getting an instance of a DOMBuilder and calling the build() method, passing in the File object for our XML file. We then make a connection to the server identified in the URL text field of the user interface. This is accomplished with the HttpURLConnection class in the java.net package.

After establishing our connection, we get to use a nice class provided by the JDOM API, the XMLOutputter class! First we instantiate an OutputStreamWriter, passing the HttpURLConnections getOutputStream() as a parameter to the constructor of the OutputStreamWriter. We then create an instance of the XMLOutputter class with a string representing the indent we want to use, in this case a "\t" for tabs and a boolean indicating that we'd like to use new line characters.

Now that we have that stuff set up, we need to associate our XML document object with our outputter. The method to do this is output(Document theDocYouWantToWriteOut, OutputStreamtheActualOutputStream). After calling the output() method and a quick call to flush(), we're ready to start getting input back from the server.

The code for this is nothing new, so I'll only touch on it by saying that we're getting the input stream from HttpURLConnection and that you can examine all this code by downloading the source.

What we've accomplished here is an easy way to post an XML file to a server and display the results in a text box. For testing purposes I've written a servlet that pretty much echoes the content of the XML document submitted by the client. The servlet adds a node to the document named SERVER_TIME, which contains a date-time stamp as the text of that node.

The code for the doPost() method is shown in Listing 2. The code for the servlet is simple and can also be examined in Listing 2 or by downloading the source code from this article.

Authenticating the Use of the Authenticator Class
One problem with these applications is that they're generally password protected - in order to access them you need to be authenticated. Thankfully, Java makes it easy to do this. In the java.net package is an Authenticator abstract class that you can subclass to create a graphical interface that allows users to provide their credentials for authentication. The code to do this same thing can be found in Chapter 7, "Retrieving Data with URLs," of Java Network Programming, 2nd Edition, by Elliotte Rusty Harold (O'Reilly). A simple overview of this class, right from the JavaDoc, is as follows:

The class Authenticator represents an object that knows how to obtain authentication for a network connection. Usually, it will do this by prompting the user for information.

Applications use this class by creating a subclass, and registering an instance of that subclass with the system with setDefault(). When authentication is required, the system will invoke a method on the subclass (like getPasswordAuthentication). The subclass's method can query about the authentication being requested with a number of inherited methods (getRequestingXXX()), and form an appropriate message for the user.

private void show() public PasswordAuthentication getPasswordAuthentication()

Extending the Tool
As I mentioned, the tool itself is very basic, and is useful for testing XML-based applications. And there are quite a few ways that you can turn this application into a more effective testing tool. For example :

The JDOM API
This tool was written using the JDOM (www.jdom.org) beta 6. However, none of the methods used in this application were deprecated in the beta 7 release of the JDOM API. That said, let's look at some of the classes and methods being used.

For starters, we're using the org.jdom.Document class, which defines the methods for manipulating an XML document. I make more use of this class in the sample servlet that I've included. The method I'm using is getRootElement().

The next class I use, the Element class, is analogous to a node in an XML document or an "element" in the document. The method addContent() is used in the Element class to add text to an element; those elements can then be added to other elements through the addContent() method, or to a document object.

As already mentioned, I'm using two other classes, a DOMBuilder and an XMLOutputter. Together these classes allow you to (1) create a Document object from various types of inputs and (2) write a Document object out, respectively.

Overall, the JDOM API is extremely easy to use; I may have made it seem more difficult than it truly is. The authors of JDOM have done a great job of creating a simple and effective API for working with XML.

Conclusion
As you can see, testing an XML-based server-side application is fairly straightforward and can be accomplished rather easily. The basic tool, combined with one or more of the suggestions for extending the tool, should help speed up the process of building and debugging server-based XML applications.