Your Own XML Reader : DOM Document « XML « Java






Your Own XML Reader

     
/*
 * JavaXmlReader.java
 *
 * Created on March 3, 2008, 9:30 PM
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Vector;

import javax.swing.JFrame;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

/**
 *
 * @author Lairds
 */
public class XMLReader
{
    Vector<ArrayList<ArrayList<String>>> headers;
    Vector<Vector<String>> fromMappings;
    Vector<Vector<String>> toMappings;
    Vector<String> worksheetNames;
    
    JFrame parent;
    
    /** Creates a new instance of JavaXmlReader */
    public XMLReader(String name, JFrame parent)
    {
         this.parent = parent;
        
         // parse XML file -> XML document will be build
         Document doc = parseFile(name);
         
         headers = new Vector<ArrayList<ArrayList<String>>>();
         fromMappings = new Vector<Vector<String>>();
         toMappings = new Vector<Vector<String>>();
         worksheetNames = new Vector<String>();
         
         if (doc != null)
         {
             // get root node of xml tree structure
             Node root = doc.getDocumentElement();

             // write node and its child nodes into System.out
             System.out.println("Statement of XML document...");
             writeDocumentToOutput(root, 0);
             System.out.println("... end of statement");

             parseHeader(root);
             parseWorksheetName(root);
             parseMappings(root);
         }
    }
    
    public Vector<String> getTypes()
    {
        return worksheetNames;
    }
    
    public ArrayList<ArrayList<String>> getHeader(String type)
    {
        int index = -1;
        for (int i = 0 ; i < worksheetNames.size() ; i++)
        {
            if (worksheetNames.elementAt(i).equalsIgnoreCase(type))
            {
                index = i;
            }
        }
        
        if (index != -1)
        {
            return headers.elementAt(index);
        }
        else
        {
            return new ArrayList<ArrayList<String>>();
        }
    }
    
    public String getWorksheetName(String type)
    {
        int index = -1;
        for (int i = 0 ; i < worksheetNames.size() ; i++)
        {
            if (worksheetNames.elementAt(i).equalsIgnoreCase(type))
            {
                index = i;
            }
        }
        
        if (index != -1)
        {
            return worksheetNames.elementAt(index);
        }
        else
        {
            return "worksheet";
        }
    }
    
    public Vector<String> getFromMappings(String type)
    {
        int index = -1;
        for (int i = 0 ; i < worksheetNames.size() ; i++)
        {
            if (worksheetNames.elementAt(i).equalsIgnoreCase(type))
            {
                index = i;
            }
        }
        
        if (index != -1)
        {
            return fromMappings.elementAt(index);
        }
        else
        {
            return new Vector<String>();
        }
    }
    
    public Vector<String> getToMappings(String type)
    {
        int index = -1;
        for (int i = 0 ; i < worksheetNames.size() ; i++)
        {
            if (worksheetNames.elementAt(i).equalsIgnoreCase(type))
            {
                index = i;
            }
        }
        
        if (index != -1)
        {
            return toMappings.elementAt(index);
        }
        else
        {
            return new Vector<String>();
        }
    }
    
    private void parseHeader(Node root)
    {
        System.out.println("Parsing Header...");
        Node document = null;
        ArrayList<String> row = new ArrayList<String>();
        ArrayList<ArrayList<String>> typeHeader = new ArrayList<ArrayList<String>>();
        
        NodeList children = root.getChildNodes();
        for (int i = 0; i < children.getLength(); i++)
        {
             Node child = children.item(i);
             if (child.getNodeType() == Node.ELEMENT_NODE)
             {
                 if (child.getNodeName().equalsIgnoreCase("DOCUMENT"))
                 {
                     document = child;
                     break;
                 }
             }
        }
        
        if (document != null)
        {
            children = document.getChildNodes();
            for (int i = 0; i < children.getLength(); i++)
            {
                 Node child = children.item(i);
                 if (child.getNodeType() == Node.ELEMENT_NODE)
                 {
                    System.out.println(child.getNodeName());
                    NodeList typeChildren = child.getChildNodes();
                    for (int j = 0; j < typeChildren.getLength(); j++)
                    {
                         Node typeChild = typeChildren.item(j);
                         if (typeChild.getNodeType() == Node.ELEMENT_NODE)
                         {
                             if (typeChild.getNodeName().equalsIgnoreCase("HEADER"))
                             {
                                typeHeader = new ArrayList<ArrayList<String>>();
                                NodeList headerChildren = typeChild.getChildNodes();
                                for (int k = 0 ; k < headerChildren.getLength() ; k++)
                                {
                                    Node headerChild = headerChildren.item(k);
                                    if (headerChild.getNodeType() == Node.ELEMENT_NODE)
                                    {
                                        // New row
                                        row = new ArrayList<String>();
                                        System.out.println(headerChild.getNodeName());
                                        NodeList columns = headerChild.getChildNodes();
                                        for (int l = 0 ; l < columns.getLength() ; l++)
                                        {
                                            Node column = columns.item(l);
                                            if (column.getNodeType() == Node.ELEMENT_NODE)
                                            {
                                                // New Column
                                                System.out.println(column.getNodeName());
                                                System.out.println(getElementValue(column).trim());
                                                row.add(getElementValue(column).trim());
                                            }
                                        }
                                        typeHeader.add(row);
                                    }
                                }
                                
                                headers.add(typeHeader);
                            }
                        }
                    }
                }
            }
        }
        else
        {
            System.err.println("XMLReader::parseHeader - No \"document\" tag found when parsing xml");
        }
        
        System.out.println("...Header Parsed");
    }
    
    private void parseWorksheetName(Node root)
    {
        System.out.println("Parsing Worksheet...");
        Node document = null;
        
        NodeList children = root.getChildNodes();
        for (int i = 0; i < children.getLength(); i++)
        {
             Node child = children.item(i);
             if (child.getNodeType() == Node.ELEMENT_NODE)
             {
                 if (child.getNodeName().equalsIgnoreCase("DOCUMENT"))
                 {
                     document = child;
                     break;
                 }
             }
        }
        
        if (document != null)
        {
            children = document.getChildNodes();
            for (int i = 0; i < children.getLength(); i++)
            {
                 Node child = children.item(i);
                 if (child.getNodeType() == Node.ELEMENT_NODE)
                 {
                    System.out.println(child.getNodeName());
                    NodeList typeChildren = child.getChildNodes();
                    for (int j = 0; j < typeChildren.getLength(); j++)
                    {
                         Node typeChild = typeChildren.item(j);
                         if (typeChild.getNodeType() == Node.ELEMENT_NODE)
                         {
                            if (typeChild.getNodeName().equalsIgnoreCase("WORKSHEET_NAME"))
                            {
                                worksheetNames.add(getElementValue(typeChild).trim());
                            }
                        }
                    }
                }
            }
        }
        else
        {
            System.err.println("XMLReader::parseWorksheetName - No \"document\" tag found when parsing xml");
        }
        
        System.out.println("...Worksheet Parsed");
    }
    
    private void parseMappings(Node root)
    {
        System.out.println("Parsing Mappings...");
        Node document = null;
        Vector<String> fromMapping = new Vector<String>();
        Vector<String> toMapping = new Vector<String>();
        
        NodeList children = root.getChildNodes();
        for (int i = 0; i < children.getLength(); i++)
        {
             Node child = children.item(i);
             if (child.getNodeType() == Node.ELEMENT_NODE)
             {
                 if (child.getNodeName().equalsIgnoreCase("DOCUMENT"))
                 {
                     document = child;
                     break;
                 }
             }
        }
        
        if (document != null)
        {
            children = document.getChildNodes();
            for (int i = 0; i < children.getLength(); i++)
            {
                 Node child = children.item(i);
                 if (child.getNodeType() == Node.ELEMENT_NODE)
                 {
                     System.out.println(child.getNodeName());
                     NodeList typeChildren = child.getChildNodes();
                    for (int j = 0; j < typeChildren.getLength(); j++)
                    {
                         Node typeChild = typeChildren.item(j);
                         if (typeChild.getNodeType() == Node.ELEMENT_NODE)
                         {
                             if (typeChild.getNodeName().equalsIgnoreCase("MAPPINGS"))
                             {
                                fromMapping = new Vector<String>();
                                toMapping = new Vector<String>();
                                NodeList mappingsChildren = typeChild.getChildNodes();
                                for (int k = 0 ; k < mappingsChildren.getLength() ; k++)
                                {
                                    Node mappingChild = mappingsChildren.item(k);
                                    if (mappingChild.getNodeType() == Node.ELEMENT_NODE)
                                    {
                                        NodeList fromToChildren = mappingChild.getChildNodes();
                                        for (int l = 0 ; l < fromToChildren.getLength() ; l++)
                                        {
                                            Node fromToChild = fromToChildren.item(l);
                                            if (fromToChild.getNodeType() == Node.ELEMENT_NODE)
                                            {
                                                System.out.println(fromToChild.getNodeName());
                                                System.out.println(getElementValue(fromToChild).trim());
                                                
                                                if (fromToChild.getNodeName().equalsIgnoreCase("FROM"))
                                                {
                                                    fromMapping.add(getElementValue(fromToChild).trim());
                                                }
                                                else if(fromToChild.getNodeName().equalsIgnoreCase("TO"))
                                                {
                                                    toMapping.add(getElementValue(fromToChild).trim());
                                                }
                                                else
                                                {
                                                    System.out.println("Unknown from to type in mappings");
                                                }
                                            }
                                        }
                                    }
                                }
                                fromMappings.add(fromMapping);
                                toMappings.add(toMapping);
                            }
                        }
                    }
                }
            }
        }
        else
        {
            System.err.println("XMLReader::parseMappings - No \"document\" tag found when parsing xml");
        }
        
        System.out.println("...Mappings Parsed");
    }
    
     /** Parses XML file and returns XML document.
      * @param fileName XML file to parse
      * @return XML document or <B>null</B> if error occured
      */
     private Document parseFile(String fileName) {
         System.out.println("Parsing XML file... " + fileName);
         DocumentBuilder docBuilder;
         Document doc = null;
         DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory.newInstance();
         docBuilderFactory.setIgnoringElementContentWhitespace(true);
         
         boolean success = true;
         
         try
         {
             docBuilder = docBuilderFactory.newDocumentBuilder();
         }
         catch (ParserConfigurationException e) {
             System.err.println("XMLReader::parseFile - Wrong parser configuration: " + e.getMessage());
             success = false;
             return null;
         }
         File sourceFile = new File(fileName);
         try {
             doc = docBuilder.parse(sourceFile);
         }
         catch (SAXException e) {
             System.err.println("XMLReader::parseFile - Wrong XML file structure: " + e.getMessage());
             success = false;
             return null;
         }
        catch(FileNotFoundException catcher)
        {
            System.err.println("AgencyTable::initNames - AgencyInfo.skc not Found: " + catcher.getMessage());
            System.out.println("Expected XML file to be in following location: " + System.getProperty("user.dir") + "\\" + fileName + ".");
        }
         catch (IOException e) {
             System.err.println("XMLReader::parseFile - Could not read source file: " + e.getMessage());
             success = false;
         }
         System.out.println("XML file parsed" + (success ? "" : " - but with errors"));
         
         if (!success)
         {
            System.out.println("Error reading XML file.  Refer to the log file for more information.");
         }
         
         return doc;
     }
    
     /** Writes node and all child nodes into System.out
      * @param node XML node from from XML tree wrom which will output statement start
      * @param indent number of spaces used to indent output
      */
     private void writeDocumentToOutput(Node node,int indent) {
         // get element name
         String nodeName = node.getNodeName();
         // get element value
         String nodeValue = getElementValue(node);
         // get attributes of element
         NamedNodeMap attributes = node.getAttributes();
         System.out.println(getIndentSpaces(indent) + "NodeName: " + nodeName + ", NodeValue: " + nodeValue);
         for (int i = 0; i < attributes.getLength(); i++) {
             Node attribute = attributes.item(i);
             System.out.println(getIndentSpaces(indent + 2) + "AttributeName: " + attribute.getNodeName() + ", attributeValue: " + attribute.getNodeValue());
         }
         // write all child nodes recursively
         NodeList children = node.getChildNodes();
         for (int i = 0; i < children.getLength(); i++) {
             Node child = children.item(i);
             if (child.getNodeType() == Node.ELEMENT_NODE) {
                 writeDocumentToOutput(child,indent + 2);
             }
         }
     }
     
     /** Returns element value
      * @param elem element (it is XML tag)
      * @return Element value otherwise empty String
      */
     private final static String getElementValue( Node elem ) {
         Node kid;
         if( elem != null){
             if (elem.hasChildNodes()){
                 for( kid = elem.getFirstChild(); kid != null; kid = kid.getNextSibling() ){
                     if( kid.getNodeType() == Node.TEXT_NODE  ){
                         return kid.getNodeValue();
                     }
                 }
             }
         }
         return "";
     }
     
     private String getIndentSpaces(int indent) {
         StringBuffer buffer = new StringBuffer();
         for (int i = 0; i < indent; i++) {
             buffer.append(" ");
         }
         return buffer.toString();
     }
}

   
    
    
    
    
  








Related examples in the same category

1.Copy an XML document
2.Create DOM Document out of string
3.Create Document with root QName
4.Create Empty DOM Document
5.Displays a DOM document in a tree control.
6.New Document From InputStream
7.New Document From String
8.load Document by element
9.load Document from InputStream
10.get Document Element from a file
11.Start a new XML Document
12.Document To String
13.Utility class to print out DOM
14.Return a new document, ready to populate
15.Read Xml from InputStream and return Document
16.Read Xml from Reader and return Document
17.Gets the owner document of a node.
18.Creates an element on the given document.
19.Loads a W3C XML document from a file.