XML Document Writer

    
/*
 * Copyright (c) 2000 David Flanagan.  All rights reserved.
 * This code is from the book Java Examples in a Nutshell, 2nd Edition.
 * It is provided AS-IS, WITHOUT ANY WARRANTY either expressed or implied.
 * You may study, use, and modify it for any non-commercial purpose.
 * You may distribute it non-commercially as long as you retain this notice.
 * For a commercial use license, or to purchase the book (recommended),
 * visit http://www.davidflanagan.com/javaexamples2.
 */

import java.io.PrintWriter;

import org.w3c.dom.CDATASection;
import org.w3c.dom.Comment;
import org.w3c.dom.Document;
import org.w3c.dom.DocumentType;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.ProcessingInstruction;
import org.w3c.dom.Text;

/**
 * Output a DOM Level 1 Document object to a java.io.PrintWriter as a simple XML
 * document. This class does not handle every type of DOM node, and it doesn't
 * deal with all the details of XML like DTDs, character encodings and preserved
 * and ignored whitespace. However, it does output basic well-formed XML that
 * can be parsed by a non-validating parser.
 */
public class XMLDocumentWriter {
  PrintWriter out; // the stream to send output to

  /** Initialize the output stream */
  public XMLDocumentWriter(PrintWriter out) {
    this.out = out;
  }

  /** Close the output stream. */
  public void close() {
    out.close();
  }

  /** Output a DOM Node (such as a Document) to the output stream */
  public void write(Node node) {
    write(node, "");
  }

  /**
   * Output the specified DOM Node object, printing it using the specified
   * indentation string
   */
  public void write(Node node, String indent) {
    // The output depends on the type of the node
    switch (node.getNodeType()) {
    case Node.DOCUMENT_NODE: { // If its a Document node
      Document doc = (Document) node;
      out.println(indent + "<?xml version='1.0'?>"); // Output header
      Node child = doc.getFirstChild(); // Get the first node
      while (child != null) { // Loop 'till no more nodes
        write(child, indent); // Output node
        child = child.getNextSibling(); // Get next node
      }
      break;
    }
    case Node.DOCUMENT_TYPE_NODE: { // It is a <!DOCTYPE> tag
      DocumentType doctype = (DocumentType) node;
      // Note that the DOM Level 1 does not give us information about
      // the the public or system ids of the doctype, so we can't output
      // a complete <!DOCTYPE> tag here. We can do better with Level 2.
      out.println("<!DOCTYPE " + doctype.getName() + ">");
      break;
    }
    case Node.ELEMENT_NODE: { // Most nodes are Elements
      Element elt = (Element) node;
      out.print(indent + "<" + elt.getTagName()); // Begin start tag
      NamedNodeMap attrs = elt.getAttributes(); // Get attributes
      for (int i = 0; i < attrs.getLength(); i++) { // Loop through them
        Node a = attrs.item(i);
        out.print(" " + a.getNodeName() + "='" + // Print attr. name
            fixup(a.getNodeValue()) + "'"); // Print attr. value
      }
      out.println(">"); // Finish start tag

      String newindent = indent + "    "; // Increase indent
      Node child = elt.getFirstChild(); // Get child
      while (child != null) { // Loop
        write(child, newindent); // Output child
        child = child.getNextSibling(); // Get next child
      }

      out.println(indent + "</" + // Output end tag
          elt.getTagName() + ">");
      break;
    }
    case Node.TEXT_NODE: { // Plain text node
      Text textNode = (Text) node;
      String text = textNode.getData().trim(); // Strip off space
      if ((text != null) && text.length() > 0) // If non-empty
        out.println(indent + fixup(text)); // print text
      break;
    }
    case Node.PROCESSING_INSTRUCTION_NODE: { // Handle PI nodes
      ProcessingInstruction pi = (ProcessingInstruction) node;
      out.println(indent + "<?" + pi.getTarget() + " " + pi.getData()
          + "?>");
      break;
    }
    case Node.ENTITY_REFERENCE_NODE: { // Handle entities
      out.println(indent + "&" + node.getNodeName() + ";");
      break;
    }
    case Node.CDATA_SECTION_NODE: { // Output CDATA sections
      CDATASection cdata = (CDATASection) node;
      // Careful! Don't put a CDATA section in the program itself!
      out.println(indent + "<" + "![CDATA[" + cdata.getData() + "]]"
          + ">");
      break;
    }
    case Node.COMMENT_NODE: { // Comments
      Comment c = (Comment) node;
      out.println(indent + "<!--" + c.getData() + "-->");
      break;
    }
    default: // Hopefully, this won't happen too much!
      System.err.println("Ignoring node: " + node.getClass().getName());
      break;
    }
  }

  // This method replaces reserved characters with entities.
  String fixup(String s) {
    StringBuffer sb = new StringBuffer();
    int len = s.length();
    for (int i = 0; i < len; i++) {
      char c = s.charAt(i);
      switch (c) {
      default:
        sb.append(c);
        break;
      case '<':
        sb.append("&lt;");
        break;
      case '>':
        sb.append("&gt;");
        break;
      case '&':
        sb.append("&amp;");
        break;
      case '"':
        sb.append("&quot;");
        break;
      case '\'':
        sb.append("&apos;");
        break;
      }
    }
    return sb.toString();
  }
}
Related examples in the same category

1.	Writing a DOM Document to an XML File
2.	XML Writer
3.	XMLWriter.java - serialize an XML document
4.	Convenience methods for writing XML
5.	Write DOM out
6.	write Xml DOM Node
7.	XMLWriter helper class
8.	DOM writer
9.	Write Xml (Node n, OutputStream os)
10.	Makes writing XML much much easier
11.	Use DOM L3 DOMBuilder, DOMBuilderFilter DOMWriter and other DOM L3 functionality to preparse, revalidate and safe document.
XML Document Writer : Writer « XML « Java

Related examples in the same category
