A WebAppConfig object is a wrapper around a DOM tree for a web.xml file : Web INF XML « Servlets « Java

A WebAppConfig object is a wrapper around a DOM tree for a web.xml file

 * Copyright (c) 2004 David Flanagan.  All rights reserved.
 * This code is from the book Java Examples in a Nutshell, 3nd 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,
 * including teaching and use in open-source projects.
 * You may distribute it non-commercially as long as you retain this notice.
 * For a commercial use license, or to purchase the book, 
 * please visit http://www.davidflanagan.com/javaexamples3.

import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;

import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;

import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import org.w3c.dom.Text;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;

 * A WebAppConfig object is a wrapper around a DOM tree for a web.xml file. The
 * methods of the class use the DOM API to work with the tree in various ways.
public class WebAppConfig {
  /** The main method creates and demonstrates a WebAppConfig object */
  public static void main(String[] args) throws IOException, SAXException,
      ParserConfigurationException, TransformerConfigurationException, TransformerException {
    // Create a new WebAppConfig object that represents the web.xml
    // file specified by the first command-line argument
    WebAppConfig config = new WebAppConfig(new File(args[0]));
    // Query the tree for the class name associated with the specified
    // servlet name
    System.out.println("Class for servlet " + args[1] + " is " + config.getServletClass(args[1]));
    // Add a new servlet name-to-class mapping to the DOM tree
    config.addServlet("foo", "bar");
    // And write out an XML version of the DOM tree to standard out
    config.output(new PrintWriter(System.out));

  org.w3c.dom.Document document; // This field holds the parsed DOM tree

   * This constructor method is passed an XML file. It uses the JAXP API to
   * obtain a DOM parser, and to parse the file into a DOM Document object,
   * which is used by the remaining methods of the class.
  public WebAppConfig(File configfile) throws IOException, SAXException,
      ParserConfigurationException {
    // Get a JAXP parser factory object
    javax.xml.parsers.DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
    // Tell the factory what kind of parser we want
    // Use the factory to get a JAXP parser object
    javax.xml.parsers.DocumentBuilder parser = dbf.newDocumentBuilder();

    // Tell the parser how to handle errors. Note that in the JAXP API,
    // DOM parsers rely on the SAX API for error handling
    parser.setErrorHandler(new org.xml.sax.ErrorHandler() {
      public void warning(SAXParseException e) {
        System.err.println("WARNING: " + e.getMessage());

      public void error(SAXParseException e) {
        System.err.println("ERROR: " + e.getMessage());

      public void fatalError(SAXParseException e) throws SAXException {
        System.err.println("FATAL: " + e.getMessage());
        throw e; // re-throw the error

    // Finally, use the JAXP parser to parse the file. This call returns
    // A Document object. Now that we have this object, the rest of this
    // class uses the DOM API to work with it; JAXP is no longer required.
    document = parser.parse(configfile);

   * This method looks for specific Element nodes in the DOM tree in order to
   * figure out the classname associated with the specified servlet name
  public String getServletClass(String servletName) {
    // Find all <servlet> elements and loop through them.
    NodeList servletnodes = document.getElementsByTagName("servlet");
    int numservlets = servletnodes.getLength();
    for (int i = 0; i < numservlets; i++) {
      Element servletTag = (Element) servletnodes.item(i);
      // Get the first <servlet-name> tag within the <servlet> tag
      Element nameTag = (Element) servletTag.getElementsByTagName("servlet-name").item(0);
      if (nameTag == null)

      // The <servlet-name> tag should have a single child of type
      // Text. Get that child, and extract its text. Use trim()
      // to strip whitespace from the beginning and end of it.
      String name = ((Text) nameTag.getFirstChild()).getData().trim();

      // If this <servlet-name> tag has the right name
      if (servletName.equals(name)) {
        // Get the matching <servlet-class> tag
        Element classTag = (Element) servletTag.getElementsByTagName("servlet-class").item(0);
        if (classTag != null) {
          // Extract the tag's text as above, and return it
          Text classTagContent = (Text) classTag.getFirstChild();
          return classTagContent.getNodeValue().trim();

    // If we get here, no matching servlet name was found
    return null;

   * This method adds a new name-to-class mapping in in the form of a <servlet>
   * sub-tree to the document.
  public void addServlet(String servletName, String className) {
    // Create the <servlet> tag
    Element newNode = document.createElement("servlet");
    // Create the <servlet-name> and <servlet-class> tags
    Element nameNode = document.createElement("servlet-name");
    Element classNode = document.createElement("servlet-class");
    // Add the name and classname text to those tags
    // And add those tags to the servlet tag

    // Now that we've created the new sub-tree, figure out where to put
    // it. This code looks for another servlet tag and inserts the new
    // one right before it. Note that this code will fail if the document
    // does not already contain at least one <servlet> tag.
    NodeList servletnodes = document.getElementsByTagName("servlet");
    Element firstServlet = (Element) servletnodes.item(0);

    // Insert the new node before the first servlet node
    firstServlet.getParentNode().insertBefore(newNode, firstServlet);

   * Output the DOM tree to the specified stream as an XML document. See the
   * XMLDocumentWriter example for the details.
  public void output(PrintWriter out) throws TransformerConfigurationException,
      TransformerException {
    TransformerFactory factory = TransformerFactory.newInstance();
    Transformer transformer = factory.newTransformer();

    transformer.transform(new javax.xml.transform.dom.DOMSource(document),
        new javax.xml.transform.stream.StreamResult(out));


Related examples in the same category

1.Using Initialization Parameters Servlet
2.Init Param Servlet
3.Servlet Mapping In Web XML
4.Define welcome files for web application
5.Parse a web.xml file using the SAX2 API
6.War Util