XMLUtils.java
上传用户:quxuerui
上传日期:2018-01-08
资源大小:41811k
文件大小:7k
源码类别:

网格计算

开发平台:

Java

  1. /**
  2.  * Licensed to the Apache Software Foundation (ASF) under one
  3.  * or more contributor license agreements.  See the NOTICE file
  4.  * distributed with this work for additional information
  5.  * regarding copyright ownership.  The ASF licenses this file
  6.  * to you under the Apache License, Version 2.0 (the
  7.  * "License"); you may not use this file except in compliance
  8.  * with the License.  You may obtain a copy of the License at
  9.  *
  10.  *     http://www.apache.org/licenses/LICENSE-2.0
  11.  *
  12.  * Unless required by applicable law or agreed to in writing, software
  13.  * distributed under the License is distributed on an "AS IS" BASIS,
  14.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15.  * See the License for the specific language governing permissions and
  16.  * limitations under the License.
  17.  */
  18. package org.apache.hadoop.vaidya.util;
  19. import java.io.IOException;
  20. import java.io.File;
  21. import java.io.InputStream;
  22. import javax.xml.parsers.DocumentBuilderFactory;
  23. import javax.xml.parsers.ParserConfigurationException;
  24. import javax.xml.parsers.DocumentBuilder;
  25. import javax.xml.transform.TransformerConfigurationException;
  26. import javax.xml.transform.TransformerException;
  27. import javax.xml.transform.Source;
  28. import javax.xml.transform.dom.DOMSource;
  29. import javax.xml.transform.Result;
  30. import javax.xml.transform.stream.StreamResult;
  31. import javax.xml.transform.Transformer;
  32. import javax.xml.transform.TransformerFactory;
  33. import org.xml.sax.SAXParseException;
  34. import org.xml.sax.SAXException;
  35. import org.w3c.dom.Document;
  36. import org.w3c.dom.Element;
  37. import org.w3c.dom.NamedNodeMap;
  38. import org.w3c.dom.Node;
  39. import org.w3c.dom.NodeList;
  40. /**
  41.  * Sample Utility class to work with DOM document
  42.  */
  43. public class XMLUtils {
  44.   /** Prints the specified node, then prints all of its children. */
  45.   public static void printDOM(Node node) {
  46.     int type = node.getNodeType();
  47.     switch (type) {
  48.       // print the document element
  49.       case Node.DOCUMENT_NODE: {
  50.         System.out.print("<?xml version="1.0" ?>");
  51.         printDOM(((Document)node).getDocumentElement());
  52.         break;
  53.       }
  54.       // print element with attributes
  55.       case Node.ELEMENT_NODE: {
  56.       System.out.println();
  57.         System.out.print("<");
  58.         System.out.print(node.getNodeName());
  59.         NamedNodeMap attrs = node.getAttributes();
  60.         for (int i = 0; i < attrs.getLength(); i++) {
  61.           Node attr = attrs.item(i);
  62.           System.out.print(" " + attr.getNodeName().trim() +
  63.                            "="" + attr.getNodeValue().trim() +
  64.                            """);
  65.         }
  66.         System.out.print(">");
  67.         NodeList children = node.getChildNodes();
  68.         if (children != null) {
  69.           int len = children.getLength();
  70.           for (int i = 0; i < len; i++)
  71.             printDOM(children.item(i));
  72.         }
  73.         break;
  74.       }
  75.       // handle entity reference nodes
  76.       case Node.ENTITY_REFERENCE_NODE: {
  77.         System.out.print("&");
  78.         System.out.print(node.getNodeName().trim());
  79.         System.out.print(";");
  80.         break;
  81.       }
  82.       // print cdata sections
  83.       case Node.CDATA_SECTION_NODE: {
  84.         System.out.print("<![CDATA[");
  85.         System.out.print(node.getNodeValue().trim());
  86.         System.out.print("]]>");
  87.         break;
  88.       }
  89.       // print text
  90.       case Node.TEXT_NODE: {
  91.       System.out.println();
  92.         System.out.print(node.getNodeValue().trim());
  93.         break;
  94.       }
  95.       // print processing instruction
  96.     case Node.PROCESSING_INSTRUCTION_NODE: {
  97.       System.out.print("<?");
  98.       System.out.print(node.getNodeName().trim());
  99.       String data = node.getNodeValue().trim(); {
  100.         System.out.print(" ");
  101.         System.out.print(data);
  102.       }
  103.         System.out.print("?>");
  104.         break;
  105.       }
  106.     }
  107.     if (type == Node.ELEMENT_NODE) {
  108.       System.out.println();
  109.       System.out.print("</");
  110.       System.out.print(node.getNodeName().trim());
  111.       System.out.print('>');
  112.     }
  113.   }
  114.   /*
  115.    * Get the value of the first (or only) element given its node name
  116.    */
  117.   public static String getElementValue(String elementName, Element element) throws Exception {
  118.     String value = null;
  119.     NodeList childNodes = element.getElementsByTagName(elementName);
  120.     Element cn = (Element)childNodes.item(0);
  121.     value = cn.getFirstChild().getNodeValue().trim();
  122.     //value = childNodes.item(0).getNodeValue().trim();
  123.     if (value == null) { 
  124.       throw new Exception ("No element found with given name:"+elementName);
  125.     }
  126.     return value;
  127.   }
  128.   /**
  129.    * Parse the XML file and create Document
  130.    * @param fileName
  131.    * @return Document
  132.    */
  133.   public static Document parse(InputStream fs) {
  134.     Document document = null;
  135.     // Initiate DocumentBuilderFactory
  136.     DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
  137.     // To get a validating parser
  138.     factory.setValidating(false);
  139.     // To get one that understands namespaces
  140.     factory.setNamespaceAware(true);
  141.     try {
  142.       // Get DocumentBuilder
  143.       DocumentBuilder builder = factory.newDocumentBuilder();
  144.       // Parse and load into memory the Document
  145.       //document = builder.parse( new File(fileName));
  146.       document = builder.parse(fs);
  147.       return document;
  148.     } catch (SAXParseException spe) {
  149.       // Error generated by the parser
  150.       System.out.println("n** Parsing error , line " + spe.getLineNumber()
  151.                          + ", uri " + spe.getSystemId());
  152.       System.out.println(" " + spe.getMessage() );
  153.       // Use the contained exception, if any
  154.       Exception x = spe;
  155.       if (spe.getException() != null)
  156.         x = spe.getException();
  157.       x.printStackTrace();
  158.     } catch (SAXException sxe) {
  159.       // Error generated during parsing
  160.       Exception x = sxe;
  161.       if (sxe.getException() != null)
  162.         x = sxe.getException();
  163.       x.printStackTrace();
  164.     } catch (ParserConfigurationException pce) {
  165.       // Parser with specified options can't be built
  166.       pce.printStackTrace();
  167.     } catch (IOException ioe) {
  168.       // I/O error
  169.       ioe.printStackTrace();
  170.     }
  171.     
  172.     return null;
  173.   }
  174.   /**
  175.    * This method writes a DOM document to a file
  176.    * @param filename
  177.    * @param document
  178.    */
  179.   public static void writeXmlToFile(String filename, Document document) {
  180.     try {
  181.       // Prepare the DOM document for writing
  182.       Source source = new DOMSource(document);
  183.       
  184.       // Prepare the output file
  185.       File file = new File(filename);
  186.       Result result = new StreamResult(file);
  187.       // Write the DOM document to the file
  188.       // Get Transformer
  189.       Transformer xformer = TransformerFactory.newInstance().newTransformer();
  190.       // Write to a file
  191.       xformer.transform(source, result);
  192.     } catch (TransformerConfigurationException e) {
  193.       System.out.println("TransformerConfigurationException: " + e);
  194.     } catch (TransformerException e) {
  195.       System.out.println("TransformerException: " + e);
  196.     }
  197.   }
  198.   /**
  199.    * Count Elements in Document by Tag Name
  200.    * @param tag
  201.    * @param document
  202.    * @return number elements by Tag Name
  203.    */
  204.   public static int countByTagName(String tag, Document document){
  205.     NodeList list = document.getElementsByTagName(tag);
  206.     return list.getLength();
  207.   }
  208. }