Populating hashmap from xml(java)

Question

my xml looks like:

<?xml version="1.0"?>
<Grid id = 1>
    <Setup id = "1">
        <Group name = "DrawingRoom">
            <Light id = "1">
                <name>Light1</name>
                <type>ben</type>
                <index>1</index>
            </Light>
            <Light id = "2">
                <name>Light2</name>
                <type>crux</type>
                <index>2</index>
            </Light>
            <Light id = "3">
                <name>Light3</name>
                <type>let</type>
                <index>3</index>
            </Light>
        </Group>
        <Group name = "BedRoom">
            <Light id = "1">
                <name>Light1</name>
                <type>let</type>
                <index>4</index>
            </Light>
        </Group>
    </Setup>
    <Setup id = "2">
        <Group name = "ClubRoom">
            <Light id = "1">
                <name>Light1</name>
                <type>let</type>
                <index>1</index>
           </Light>
       </Group>
   </Setup>
</Grid>

Issue appears when I try to populate hashmap while parsing the xml. I am using four hashmap each for holding different level of information. So the final hashmap consists of hashmap from lower level like setup, group and light with attributes of each level are the keys of respective maps of that level.

    public HashMap<String,String> lightContent = new HashMap<String,String>();
    public HashMap<String, HashMap<String,String>> groupContent = new HashMap<String, HashMap<String,String>>();
    public HashMap<String, HashMap<String, HashMap<String,String>>>  setupContent = new HashMap<String, HashMap<String, HashMap<String,String>>>();
    public HashMap<String, HashMap<String, HashMap<String, HashMap<String,String>>>> gridContent = new HashMap<String, HashMap<String, HashMap<String, HashMap<String,String>>>>();

During parsing, the problem comes that as hashmap gets updated so is the automatically the hashmap containing those hashmap. So, previous entries are lost when hashmap at lower levels are overwritten.

I understand that "key" in hashmap points to location of value(here it is another hashmap). Hence, m confused, what next could be done to retrieve all the xml data to hashmap. Appreciate your help in this regard !!

I am afraid, cant use any external library for this purpose. Here is the function:

    public void getSetupConfiguration()
    {
        try {

            File fXmlFile = new File("D:\\SetupConfig.xml");
            DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
            Document doc = dBuilder.parse(fXmlFile);
            NodeList nodeList = doc.getChildNodes();


            if (doc.hasChildNodes())
                {
                for (int count1 = 0; count1 < nodeList.getLength(); count1++) 
                    {
                    System.out.println(nodeList.getLength());
                Node gridNode = nodeList.item(count1);
                if (gridNode.getNodeType() == Node.ELEMENT_NODE) 
                    {
                    String presentNodeName = gridNode.getNodeName();
                    // get node name and value
    //                  System.out.println("\nNode Name =" + presentNodeName);

                    if (presentNodeName.equalsIgnoreCase("Grid"))
                        {
                        if (gridNode.hasChildNodes())
                            {
                            Node setupNode = gridNode.getFirstChild();
                            while (setupNode != null)
                                {
                                if (setupNode.getNodeType() == Node.ELEMENT_NODE) 
                                    {
                                    System.out.println(setupNode.getNodeName());
                                    //Getting group
                                    Node groupNode = setupNode.getFirstChild();
                                    while (groupNode != null)
                                        {
                                        if (groupNode.getNodeType() == Node.ELEMENT_NODE) 
                                            {
                                                System.out.println(groupNode.getNodeName());
                                            // Getting lights
                                            Node lightNode = groupNode.getFirstChild();
                                            while (lightNode != null)
                                                {
                                                if (lightNode.getNodeType() == Node.ELEMENT_NODE)
                                                    {
                                                    System.out.println(lightNode.getNodeName());
                                                    // Getting individual lights
                                                    Node lights = lightNode.getFirstChild();
                                                    while (lights != null)
                                                        {
                                                        if (lights.getNodeType() == Node.ELEMENT_NODE)
                                                            {
                                                            lightContent.put(lights.getNodeName(), lights.getTextContent());
                                                            System.out.println("aaa");
                                                            }
                                                            lights = lights.getNextSibling();


                                                        }
                                                    NamedNodeMap lightMap = lightNode.getAttributes();
                                                    String lightId = "";
                                                    // To get id of Light element
                                                    for (int i = 0; i < lightMap.getLength(); i++ )
                                                    {                                       
                                                        Node lightItem = lightMap.item(i);
                                                        lightId = lightItem.getNodeValue(); 
                                                    }

                                                    groupContent.put(lightId, lightContent);
                                                    System.out.println(groupContent);

                                                    }

                                                    lightNode = lightNode.getNextSibling();

                                                }// Populating Light Node Ends
                                            NamedNodeMap groupMap = groupNode.getAttributes();
                                            String groupName = "";

                                            for (int i = 0; i < groupMap.getLength(); i++ )
                                            {                                       
                                                Node lightItem = groupMap.item(i);
                                                groupName = lightItem.getNodeValue();   
                                            }
                                            setupContent.put(groupName, groupContent);
                                            System.out.println(setupContent);
                                            }
                                            lightContent.clear();
                                            groupContent.clear();
                                            System.out.println(lightContent);
                                            groupNode = groupNode.getNextSibling();
                                        }
                                    }
                                if (setupNode.getNodeType() == Node.ELEMENT_NODE) 
                                {
                                    NamedNodeMap setupMap = setupNode.getAttributes();
                                    String setUpId = "";

                                    for (int i = 0; i < setupMap.getLength(); i++ )
                                    {                                       
                                        Node lightItem = setupMap.item(i);
                                        setUpId = lightItem.getNodeValue(); 
                                    }
                                    gridContent.put(setUpId, setupContent);
                                    System.out.println(gridContent);
                                    setupContent.clear();
                                }

                                setupNode = setupNode.getNextSibling();
                                }

                            }
//                          gridNode = gridNode.getNextSibling();

                            }
                    }
                }
            }
            System.out.println(gridContent);
            }
            catch (Exception e) 
            {
            e.printStackTrace();
            }



        System.out.println("Wow");
    }
    }

Thanks is advance !!

Answer 1

I think you are going down the wrong path. If you spend the time to really parse that data into objects, then I would create a real model; instead of using Maps of strings. You see, your current approach is extremely clumsy. Those Maps of Maps of Maps are not only hard to populate; they would also be hard to use later on. Although it is not directly "visible" - your XML data is structured . And by pushing that "blindly" into Maps, you are making a lot of that structure harder to acquire.

What I mean is: on the lowest level, you are dealing with Lights . So why don't you create a Light class that contains the corresponding attributes? But not as raw strings, but already converted into their more specific types. And then you would not push Lights into a Map, but into a List - as they are already coming in that order.

And then you should use existing technologies such as JAXB to turn your XML data into "real" objects - see here for guidance.