XML query over a socket

Question

I can't seem to find any thing anywhere about doing this. I was want to be able to send a query:
<?xml version="1.0"?>
<query />
to a remote server (which will return a bunch of results). I've created an in/out socket... but that's about it.

Answer 1

Simple POST xml java client, takes URL and a number of terms as argument, constructs query document, sends it to server and echos response to standard output:import java.io.*;
import java.net.*;
import javax.xml.parsers.*;
import org.w3c.dom.*;
public class PostXml {
  public static void main (String[] args) {
    try {
      final Document queryDocument = XmlUtils.createDocument("", "query");
      final Element root = queryDocument.getDocumentElement();
      for (int index = 1; index < args.length; index++) {
        XmlUtils.addTextElement(root, "", "term", args[index]);
      XmlUtils.echoXml(XmlUtils.parse(postXml(args[0], queryDocument)), System.out);
    } catch (Exception ex) {
      ex.printStackTrace(System.out);
  public static InputStream postXml (String targetURL, Document document ) throws IOException {
    final URLConnection connection = new URL(targetURL).openConnection();
    connection.setDoInput(true);
    connection.setDoOutput(true);
    connection.setRequestProperty("content-type", "application/xml");
    XmlUtils.echoXml(document, connection.getOutputStream());
    return connection.getInputStream();
}Servlet parses xml input and returns xml document based on the content:import java.io.IOException;
import java.io.Writer;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
public class QueryServlet extends HttpServlet {
  public void doPost (final HttpServletRequest request,
                      final HttpServletResponse response) throws IOException, ServletException {
    response.setContentType("application/xml");
    try {
      final Document queryDocument = XmlUtils.parse(request.getInputStream());
      final Element queryElement = queryDocument.getDocumentElement();
      final NodeList terms = queryElement.getElementsByTagName("term");
      final Document responseDocument = XmlUtils.createDocument("", "response");
      final Element responseElement = responseDocument.getDocumentElement();
      for (int index = 0; index < terms.getLength(); index++) {
        XmlUtils.addTextElement(responseElement, "", "recieved", XmlUtils.textValue(terms.item(index)));
      XmlUtils.echoXml(responseDocument, response.getOutputStream());
    } catch (XmlException xe) {
      XmlUtils.echoXml(XmlUtils.errorDocument(xe), response.getOutputStream());
  public void doGet (final HttpServletRequest request,
                     final HttpServletResponse response) throws IOException {
    response.setContentType("text/plain");
    final Writer out = response.getWriter();
    out.write("use POST");
}Utilities to hide much DOM cruft and checked exception proliferation:import java.io.InputStream;
import java.io.IOException;
import java.io.OutputStream;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.xml.sax.SAXException;
import org.w3c.dom.Document;
import org.w3c.dom.DOMImplementation;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
* Some of this removes oddities in DOM; most is wrapping exceptions so
* that the different toolkits throw the same exception for like operations.
public class XmlUtils {
  static final DocumentBuilderFactory documentBuilderFactory;
  static final DOMImplementation domImplementation;
  static {
    DocumentBuilderFactory factory = null;
    DOMImplementation domI = null;
    try {
      factory = DocumentBuilderFactory.newInstance();
      domI = factory.newDocumentBuilder().getDOMImplementation();
    } catch (ParserConfigurationException pce) {
      // log it
    documentBuilderFactory = factory;
    domImplementation = domI;
  private static Transformer nullTransform;
  public static void echoXml (final Document document, final OutputStream out) throws IOException {
    try {
      if (nullTransform == null) {
        final TransformerFactory factory = TransformerFactory.newInstance();
        nullTransform = factory.newTransformer();
      nullTransform.transform(new DOMSource(document), new StreamResult(out));
    } catch (TransformerException te) {
      final IOException ioe = new IOException("failed to write document to stream");
      ioe.initCause(te);
      throw ioe;
  public static Document errorDocument (final Throwable error) {
    try {
      final Document errorDocument = createDocument();
      errorDocument.appendChild(errorElement(errorDocument, error));
      return errorDocument;
    } catch (XmlException xe) {
      // as this is called to provide a document representing an error
      // during error handling, throwing anything could cause a loop
      return null;
  static Element errorElement (final Document document, final Throwable error) {
    final Element errorElement = document.createElementNS("", "error");
    addTextElement(errorElement, "", "class", error.getClass().getName());
    final StackTraceElement[] stack = error.getStackTrace();
    for (int index = 0; index < stack.length; index++) {
      addTextElement(errorElement, "", "stack", stack[index].toString());
    if (error.getCause() != null) {
      final Element causedBy = document.createElementNS("", "caused-by");
      causedBy.appendChild(errorElement(document, error.getCause()));
      errorElement.appendChild(causedBy);
    return errorElement;
  public static Element addTextElement (final Element parent, final String url, final String qname, final String content) {
    final Document document = parent.getOwnerDocument();
    final Element child = document.createElementNS(url, qname);
    child.appendChild(document.createTextNode(content));
    parent.appendChild(child);
    return parent;
  public static String textValue (final Node node) {
    switch (node.getNodeType()) {
      case Node.CDATA_SECTION_NODE:
      case Node.TEXT_NODE : return node.getNodeValue();
      default: return concat(node.getChildNodes(), new StringBuffer()).toString();
  public static StringBuffer concat (final NodeList nodelist, final StringBuffer buffer) {
    for (int index = 0, length = nodelist.getLength(); index < length; index++) {
      final Node node = nodelist.item(index);
      switch (node.getNodeType()) {
        case Node.CDATA_SECTION_NODE:
        case Node.TEXT_NODE : {
          buffer.append(node.getNodeValue());
          break;
        case Node.ELEMENT_NODE: {
          concat(node.getChildNodes(), buffer);
          break;
    return buffer;
  public static Document parse (InputStream stream) throws XmlException, IOException {
    try {
      return documentBuilderFactory.newDocumentBuilder().parse(stream);
    } catch (SAXException saxe) {
      throw new XmlException(saxe);
    } catch (ParserConfigurationException pce) {
      throw new XmlException(pce);
  public static Document createDocument (String url, String qname) {
    return domImplementation.createDocument(url, qname, null);
  public static Document createDocument () throws XmlException {
    try {
      return documentBuilderFactory.newDocumentBuilder().newDocument();
    } catch (ParserConfigurationException pce) {
      throw new XmlException(pce);
}