Difficulty Parsing XML Child Nodes

[Lou Pelagalli]

Hi,

My code follows my signature.

My XML is parsing correctly except the dependant names are blank.

I know the number of dependants are correct in each instance, but haven't been able to get the names parsed.

Please help with code. I've spun my wheels for days on this, and I have made progress but now I'm stuck here.

See DomParserExample.getEmployee(Element empEl) line 82 for a comment where I think the problem is.

EmployeeList.java is the main class.

Thanks,

Lou

Employees.xml
<?xml version="1.0" encoding="UTF-8"?> <Personnel> <Employee type="permanent" category = "full time"> <Name>Seagull</Name> <Id>3674</Id> <Age>34</Age> <dependant> <name>Seagull Jr.</name> </dependant> </Employee> <Employee type="contract"> <Name>Robin</Name> <Id>3675</Id> <Age>25</Age> <dependant> <name>Robin Jr.</name> </dependant> </Employee> <Employee type="permanent"> <Name>Crow</Name> <Id>3676</Id> <Age>28</Age> <dependant> <name>Crow Jr.</name> </dependant> </Employee> <Employee type="Biggest Rain Maker"> <Name>Lou</Name> <Id>1</Id> <Age>58</Age> <dependant> <name>Lou Jr.</name> <name>Larry</name> </dependant> </Employee> </Personnel>

DomParserExample.java

import java.io.IOException;
import java.util.ListIterator;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import java.util.*;

import org.xml.sax.SAXException;
public class DomParserExample {
	Document dom;
	ArrayList<Employee> myEmpls = new ArrayList<Employee>();
	
	public void parseXmlFile(){
		System.out.println("DomParserExample.parseXmlFile()");
		//get the factory
		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		try {

			//Using factory get an instance of document builder
			DocumentBuilder db = dbf.newDocumentBuilder();

			//parse using builder to get DOM representation of the XML file
			dom = db.parse("employees.xml");
			System.out.println("dom=" + dom);
		}catch(ParserConfigurationException pce) {
			pce.printStackTrace();
		}catch(SAXException se) {
			se.printStackTrace();
		}catch(IOException ioe) {
			ioe.printStackTrace();
		}
	}
	public void parseDocument(){
		System.out.println("parseDocument()");
		//get the root element
		Element documentElement = dom.getDocumentElement();

		//get a nodelist of the Employee elements
		NodeList employeeNodeList = documentElement.getElementsByTagName("Employee");
		if(employeeNodeList != null && employeeNodeList.getLength() > 0) {
			for(int i = 0 ; i < employeeNodeList.getLength();i++) {

				//get the next Employee element
				Element employeeElement = (Element)employeeNodeList.item(i);

				//get the Employee object
				Employee e = getEmployee(employeeElement);

				//add Employee to list
				myEmpls.add(e);
				System.out.println("Employee Added");
			}
		}
	}
	

	/**
	 * I take an employee element and read the values in, create
	 * an Employee object and return it
	 */
	private Employee getEmployee(Element empEl) {

		//for each <employee> element get text or int values of
		//name ,id, age and name
		String name = getTextValue(empEl,"Name");
		int id = getIntValue(empEl,"Id");
		int age = getIntValue(empEl,"Age");
		String type = empEl.getAttribute("type");
		String category = empEl.getAttribute("category");
		
		// ArrayList for dependant names.
		ArrayList<String> dependants = new ArrayList<String>();
		NodeList dependantNodeList = empEl.getElementsByTagName("dependant");
		
		System.out.println("dependantNodeList.getLength() = " + dependantNodeList.getLength());
		
		// I believe the problem is somewhere within this if statement.
		if(dependantNodeList != null && dependantNodeList.getLength() > 0) {
			for(int i = 0 ; i < dependantNodeList.getLength();i++) {

				//get the dependent element
				Element dependantElement = (Element)dependantNodeList.item(i);
				NodeList dependantNameNodeList = dependantElement.getElementsByTagName("name"); 
				if (dependantNameNodeList != null && dependantNameNodeList.getLength() > 0) {
					for (int j = 0; j < dependantNameNodeList.getLength(); j++) {
						//get the dependent object
						Element dependantName = (Element)dependantNameNodeList.item(j);
						String dependant = getDependent(dependantName);
						System.out.println("dependant = " + dependant);
						dependants.add((dependant == null ? "" : dependant));
					}
				}
			}
		}
		
		//Create a new Employee with the value read from the xml nodes
		Employee e = new Employee(name, id, age, type, category, dependants);
		
		return e;
	}
	
	private String getDependent(Element dependant) {
		return getTextValue(dependant,"name");
	}

	/**
	 * I take a xml element and the tag name, look for the tag and get
	 * the text content
	 * i.e for <employee><name>John</name></employee> xml snippet if
	 * the Element points to employee node and tagName is 'name' I will return John
	 */
	private String getTextValue(Element ele, String tagName) {
		String textVal = null;
		NodeList nl = ele.getElementsByTagName(tagName);
		if(nl != null && nl.getLength() > 0) {
			Element el = (Element)nl.item(0);
			textVal = el.getFirstChild().getNodeValue();
		}
		return (null == textVal) ? "" : textVal;
	}

	/**
	 * Calls getTextValue and returns a int value
	 */
	private int getIntValue(Element ele, String tagName) {
		//in production application you would catch the exception
		return Integer.parseInt(getTextValue(ele,tagName));
	}

	public void printData(){

		System.out.println("No of Employees '" + myEmpls.size() + "'.");

		ListIterator<Employee> employeeIt = myEmpls.listIterator();
		while(employeeIt.hasNext()) {
			Employee e = (Employee)employeeIt.next();
			System.out.println("Employee name=" + e.getName() + ", id=" + e.getId() + ", age=" + e.getAge() + ", type=" + e.getType() + ", something=" + ", category=" + e.getCategory());
			ArrayList<String> dependants = e.getDependantNames();
			System.out.println("    No of Dependants = " + dependants.size());
			ListIterator<String> dependantsIt = dependants.listIterator();
			while (dependantsIt.hasNext()) {
				System.out.println("    " + dependantsIt.next());
			}
		}
	}
}

Employee.java

import java.util.ArrayList;
public class Employee {
	private String name;
	private int id;
	private int age;
	private String type;
	private ArrayList<String> dependantNames;
	private String category;
    
    private Employee(){
    }
    
    public Employee(String name, int id, int age, String type, String category, ArrayList<String> dependantNames){
    	this.name = name;
    	this.id = id;
    	this.age = age;
    	this.type = type;
    	this.category = category;
    	this.dependantNames = dependantNames;
    }
	
	public ArrayList<String> getDependantNames() {
		return this.dependantNames;
	}

	public void setDependantNames(ArrayList<String> dependantNames) {
		this.dependantNames = dependantNames;
	}

	public String getType() {
		return type;
	}

	public void setType(String type) {
		this.type = type;
	}

	public String getCategory() {
		return category;
	}

	public void setCategory(String category) {
		this.category = category;
	}

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
}

EmployeeList.java

public class EmployeeList {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		System.out.println("Starting EmployeeList");
		DomParserExample dpe = new DomParserExample();
		dpe.parseXmlFile();
		dpe.parseDocument();
		dpe.printData();
	}
}

[Paul Clapham]

Lou Pellegrini wrote:See DomParserExample.getEmployee(Element empEl) line 82 for a comment where I think the problem is.

Yes, I agree. It looks like once you find a "name" element you call a method which looks for a child element called "name" and then extracts the text from it if there is one. But your "name" elements never have such children.

[Lou Pelagalli]

Hi Paul,

Yes, I agree. It looks like once you find a "name" element you call a method which looks for a child element called "name" and then extracts the text from it if there is one. But your "name" elements never have such children.

Are you confusing the Employee Name element with the dependant name element?

After I get the Employee Name and other elements of the Employee there may be zero or 1 or many name elements in the dependant node I need to get.

Snippet from Employees.xml
<Employee type="permanent" category = "full time"> <Name>Seagull</Name> <Id>3674</Id> <Age>34</Age> <dependant> <name>Seagull Jr.</name> </dependant> </Employee>

I would greatly appreciate it if someone could show me the code that works.

Thanks,

Lou

[Paul Clapham]

Lou Pellegrini wrote:Are you confusing the Employee Name element with the dependant name element?

No, I'm not doing that. After all they have different names (XML is case-sensitive). After this line of code:

NodeList dependantNameNodeList = dependantElement.getElementsByTagName("name");

where you get the "name" elements which are the children of a dependent, you proceed to pass each of those elements to your getDependent() method which attempts to get all their descendants called "name".

Naturally there aren't any, so the getTextValue() method returns its default value of an empty string. Which is what you are seeing, no?

[Lou Pelagalli]

Hi Paul,

Success!

My code change is posted after my signature.

No, I'm not doing that.

I didn't think so, just checking.

Naturally there aren't any, so the getTextValue() method returns its default value of an empty string. Which is what you are seeing, no?

Which is what I was seeing, yes!

As you have probably guessed I am new to XML.

dependantName.getFirstChild().getNodeValue();

Obtained the dependant values I was looking for.
Then just for grins I added

String dependant1 = dependantName.getNextSibling().getNodeValue();

which returned empty Strings.

That causes me some confusion because I figured all <name> values would be individually in dependantName first child and siblings.

Now it looks like all <name> values would be in the in only the first child, I guess because they have the same tag name?
So would any other dependant values like <age> be in dependantName.getNextSibling().getNodeValue();?

Anything you can do to clairify this for me would be greatly appreciated!

Thanks,

Lou

        if(dependantNodeList != null && dependantNodeList.getLength() > 0) {  
            for(int i = 0 ; i < dependantNodeList.getLength();i++) {  
  
                //get the dependent element  
                Element dependantElement = (Element)dependantNodeList.item(i);  
                NodeList dependantNameNodeList = dependantElement.getElementsByTagName("name");   
                if (dependantNameNodeList != null && dependantNameNodeList.getLength() > 0) {  
                    for (int j = 0; j < dependantNameNodeList.getLength(); j++) {  
                        //get the dependent object  
                        Element dependantName = (Element)dependantNameNodeList.item(j);  
                        
                        // Changed following line
                        // from String dependant = getDependent(dependantName); 
                        // to  
                        String dependant = dependantName.getFirstChild().getNodeValue();
                        
                        System.out.println("dependant = " + dependant);  
                        dependants.add((dependant == null ? "" : dependant));  
                    }  
                }  
            }  
        }

[William Brogden]

dependantName.getFirstChild().getNodeValue();

I really seriously distrust any XML parsing code that does a getFirstChild() without checking to see what kind of node it gets. So many ways to format XML that look right to you but have formatting Nodes of type Text where you don't expect them.

I recommend you spend considerable time with the lovely table in the JavaDocs for the org.w3c.dom package, Node class - this shows what the different types of Node return for nodeName and nodeValue - frequently not what you are expecting.

Bill

[Paul Clapham]

Lou Pellegrini wrote:Now it looks like all <name> values would be in the in only the first child, I guess because they have the same tag name?
So would any other dependant values like <age> be in dependantName.getNextSibling().getNodeValue();?

There aren't any <age> elements anywhere in the XML you posted. There are <Age> elements, but they aren't children of the <dependant> elements so they aren't "dependant values". In any reasonable understanding of the XML, they represent the Age of the Employee and not the Age of any dependant. Likewise there are <Name> elements which are children of <Employee> and <name> elements which are children of <dependant>. Don't get them confused.

And I would reiterate what Bill said -- it's extremely common for DOM beginners to not know that their documents are full of whitespace text nodes.