ApplyXPathJAXP.java Source code

Introduction

Here is the source code for ApplyXPathJAXP.java

Source

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the  "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import java.io.OutputStreamWriter;

import javax.xml.namespace.*;
import javax.xml.transform.*;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import javax.xml.xpath.*;
import org.xml.sax.*;
import org.w3c.dom.*;

/**
 * JAXP 1.3 XPath API sample.
 * 
 * Basic utility for applying an XPath expression to an input xml file and printing
 * the evaluation result, using JAXP 1.3 XPath API.
 * 
 * Takes 3 arguments:
 * (1) an xml file name
 * (2) an XPath expression to apply to the input document
 * (3) the return type, which is one of the following Strings:
 *     num, bool, str, node, nodeset
 * 
 * Examples:
 *    java ApplyXPathJAXP foo.xml /doc/name[1]/@last str
 *    java ApplyXPathJAXP foo.xml /doc/name nodeset
 */
public class ApplyXPathJAXP {
    public static void main(String[] args) {
        QName returnType = null;

        if (args.length != 3) {
            System.err.println("Usage: java ApplyXPathAPI xml_file xpath_expression type");
        }

        InputSource xml = new InputSource(args[0]);
        String expr = args[1];

        // set the return type
        if (args[2].equals("num"))
            returnType = XPathConstants.NUMBER;
        else if (args[2].equals("bool"))
            returnType = XPathConstants.BOOLEAN;
        else if (args[2].equals("str"))
            returnType = XPathConstants.STRING;
        else if (args[2].equals("node"))
            returnType = XPathConstants.NODE;
        else if (args[2].equals("nodeset"))
            returnType = XPathConstants.NODESET;
        else
            System.err.println("Invalid return type: " + args[2]);

        // Create a new XPath
        XPathFactory factory = XPathFactory.newInstance();
        XPath xpath = factory.newXPath();

        Object result = null;
        try {
            // compile the XPath expression
            XPathExpression xpathExpr = xpath.compile(expr);

            // Evaluate the XPath expression against the input document
            result = xpathExpr.evaluate(xml, returnType);

            // Print the result to System.out.
            printResult(result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * Print the type and value of the evaluation result.
     */
    static void printResult(Object result) throws Exception {
        if (result instanceof Double) {
            System.out.println("Result type: double");
            System.out.println("Value: " + result);
        } else if (result instanceof Boolean) {
            System.out.println("Result type: boolean");
            System.out.println("Value: " + ((Boolean) result).booleanValue());
        } else if (result instanceof String) {
            System.out.println("Result type: String");
            System.out.println("Value: " + result);
        } else if (result instanceof Node) {
            Node node = (Node) result;
            System.out.println("Result type: Node");
            System.out.println("<output>");
            printNode(node);
            System.out.println("</output>");
        } else if (result instanceof NodeList) {
            NodeList nodelist = (NodeList) result;
            System.out.println("Result type: NodeList");
            System.out.println("<output>");
            printNodeList(nodelist);
            System.out.println("</output>");
        }
    }

    /** Decide if the node is text, and so must be handled specially */
    static boolean isTextNode(Node n) {
        if (n == null)
            return false;
        short nodeType = n.getNodeType();
        return nodeType == Node.CDATA_SECTION_NODE || nodeType == Node.TEXT_NODE;
    }

    static void printNode(Node node) throws Exception {
        if (isTextNode(node)) {
            System.out.println(node.getNodeValue());
        } else {
            // Set up an identity transformer to use as serializer.
            Transformer serializer = TransformerFactory.newInstance().newTransformer();
            serializer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");
            serializer.transform(new DOMSource(node), new StreamResult(new OutputStreamWriter(System.out)));
        }

    }

    static void printNodeList(NodeList nodelist) throws Exception {
        Node n;

        // Set up an identity transformer to use as serializer.
        Transformer serializer = TransformerFactory.newInstance().newTransformer();
        serializer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");

        for (int i = 0; i < nodelist.getLength(); i++) {
            n = nodelist.item(i);
            if (isTextNode(n)) {
                // DOM may have more than one node corresponding to a 
                // single XPath text node.  Coalesce all contiguous text nodes
                // at this level
                StringBuffer sb = new StringBuffer(n.getNodeValue());
                for (Node nn = n.getNextSibling(); isTextNode(nn); nn = nn.getNextSibling()) {
                    sb.append(nn.getNodeValue());
                }
                System.out.print(sb);
            } else {
                serializer.transform(new DOMSource(n), new StreamResult(new OutputStreamWriter(System.out)));
            }
            System.out.println();
        }
    }
}