hashmaps to xml and back

[colin mcculloch]

ok the title says it all really; what i need is a method/class that will write a hashmap to an xml file in the form

<entry key="key">value</entry> or
<entry key="key" value="value" />

(im not that bothered about doctypes etc, as long as i can load the data to the hashmap when the program starts and then save the hashmap back to the file once the program has run)

i really dont have any experience with using xml in java, so any help you could give would be much appreciated

[Christophe Verré]

You could use betwixt (http://jakarta.apache.org/commons/betwixt/):

A map like:

Map map = new HashMap();
map.put("name", "bob");
map.put("car", "toyota");

will produce:

<person>
  <entry>
    <key>car</key>
    <value>toyota</value>
  </entry>
  <entry>
    <key>name</key>
    <value>bob</value>
  </entry>
</person>

Here is a sample (I used one from Jakarta and used a map instead of a bean):

import java.io.StringWriter;
import java.util.*;
 
import org.apache.commons.betwixt.io.BeanWriter;
 
public class Betz {
 
    /** 
     * Create an example bean and then convert it to xml.
     */
    public static final void main(String [] args) throws Exception {
        
        // Start by preparing the writer
        // We'll write to a string 
        StringWriter outputWriter = new StringWriter(); 
        
        // Betwixt just writes out the bean as a fragment
        // So if we want well-formed xml, we need to add the prolog
        outputWriter.write("<?xml version='1.0' ?>\n");
        
        // Create a BeanWriter which writes to our prepared stream
        BeanWriter beanWriter = new BeanWriter(outputWriter);
        
        // Configure betwixt
        // For more details see java docs or later in the main documentation
        beanWriter.getXMLIntrospector().getConfiguration().setAttributesForPrimitives(false);
        beanWriter.getBindingConfiguration().setMapIDs(false);
        beanWriter.enablePrettyPrint();
 
        // If the base element is not passed in, Betwixt will guess 
        // But let's write example bean as base element 'person'
        Map map = new HashMap();
        map.put("name", "bob");
        map.put("car", "toyota");
        beanWriter.write("person", map);
        
        // Write to System.out
        // (We could have used the empty constructor for BeanWriter 
        // but this way is more instructive)
        System.out.println(outputWriter.toString());
        
        // Betwixt writes fragments not documents so does not automatically close 
        // writers or streams.
        // This example will do no more writing so close the writer now.
        outputWriter.close();
    }
}

You'll need at least:
- commons-betwixt
- commons-collections
- commons-digester
- commons-logging
- commons-beanutils

[William Brogden]

In Java 1.5 the java.util.Properties class got a loadFromXML and a storeToXML method. Properties is an extension of Hashtable and implements Map.
Perhaps that will handle your problem without going to another library.
Bill

[colin mcculloch]

Originally posted by William Brogden:
In Java 1.5 the java.util.Properties class got a loadFromXML and a storeToXML method. Properties is an extension of Hashtable and implements Map.
Perhaps that will handle your problem without going to another library.
Bill

i did try this already but i had a few problems, first properties only stores String, String. my map is String, integer. id rather not have to go through converting the integers to srtings and vice versa

the second problem i had (im guessing) is with the way i implemented the code, my xml always turned out like this

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
<entry key=" cheese"> 126000000</entry>
</properties>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
<entry key=" cheese"> 126000000</entry>
<entry key=" Bob_the_Bot "> 48</entry>
</properties>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
<entry key=" cheese"> 126000000</entry>
<entry key=" Bob_the_Bot "> 48</entry>
<entry key="cheesewheels"> 996</entry>
</properties>

Satou: i had a look at your example too, but in my code i define the hashmap:

HashMap<String, Integer> map = new HashMap<String, Integer>():

i take it this wont make any difference to the example you posted?

[Edwin Dalorzo]

Well, I would do it this way, to keep it simple:

1. Create a DOM document

DocumentBuilder builder = null;
builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
Document document = builder.newDocument();

2. Visit every element in the map and convert it to a node:

Element root = document.createElement("person");
for(String key : map.keySet()){

Integer value = map.get(key);

Element newNode = document.createElement("entry");
Element newKey = document.createElement("key");
Element newValue = document.createElement("value");

newKey.setTextContent(key);
newValue.setTextContent(value.toString());

newNode.appendChild(newKey);
newNode.appendChild(newValue);

root.appendChild(newNode);

}
document.appendChild(root);
 

3. Write the DOM structure to a file:

Transformer transformer = TransformerFactory.newInstance().newTransformer();
Source source = new DOMSource(document);
File file = new File("persons.xml");
Result result = new StreamResult(file);
transformer.transform(source,result);

I hope this helps!

[colin mcculloch]

id say Edwins suggestion looks best, but could you please tell me which parts of the API i have to import to use this?

[Edwin Dalorzo]

With JDK 1.5. I think it should work on JDK 1.4 too.

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.TransformerFactoryConfigurationError;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
 
import org.w3c.dom.Document;
import org.w3c.dom.Element;

[colin mcculloch]

had an ulber post here before, but luckily (all be it after several hours,) i got the problem fixed. i do however have a few more questions on the subject,

first, how do i load the xml file back into a hashmap, and
second, the xml file generated by this example comes out all in one long line rather than being nicely spaced and indented, will this affect the functionality of the program, and is it possible to correct this?
[ June 09, 2006: Message edited by: colin mcculloch ]

[Edwin Dalorzo]

The appearance of the text will be an issue only if you pretend to read it in a text editor. If you open the XML with your browser it will be properly displayed. There are XML beautifiers which could solve this issue, for instance, in my Eclipse editor I could reformat the text to look human-readable.

As for reading the text back from the file, you could:

DocumentBuilder parser = DocumentBuilderFactory.newInstance().newDocumentBuilder();
Document document = parser.parse(new File("persons.xml"));

And you do the DOM structure parsing.

Good luck.
[ June 09, 2006: Message edited by: Edwin Dalorzo ]

[colin mcculloch]

thanks to everyone who posted here hopefully i'll be able to figure the rest out for myself. will post back again if not

[Edwin Dalorzo]

Good for you, buddy!