Java xml binding map

JAXB, Custom XML to Java Map using XMLAdapter

In some cases XML structure that is specific to a Java container is very different, e.g. Map. And we want to bind our Java classes with a customized and more readable XML, JAXB XmlJavaTypeAdapter annotation comes very handy in such situations. Such mappings require an adapter class, written as an extension of XmlAdapter, and XmlJavaTypeAdapter annotation suggests JAXB to use the adapter at specified location:

For illustration purpose, we’ll have a custom XML:

And this is our JAXB annotated message class(minimal):

And the profile class with required annotations, note that we have a HashMap of Message where message id is the key and Message object itself as a value. Also note the use of @XmlJavaTypeAdapter which provides mapping between custom XML and HashMap during the process of marshaling/ unmarshaling. Going forward we’ll see how we are going to achieve that.

@XmlRootElement(name="profile") public class Profile < @XmlElement @XmlJavaTypeAdapter(MessageAdapter.class) private HashMapmessages; public Profile()<> public Profile(HashMap b ) < messages = b; >>

To fill the gap we need to provide something that JAXB knows how to handle, we can use a wrapper class which contains Array of objects of type Messagse.

Now you must have got a fair idea that how JAXB is going to read XML messages to Message array back and forth. Let’s write an adapter to map our Array to a HasMap.

public class MessageAdapter extends XmlAdapter> < @Override public Mapunmarshal( Messages value ) < Mapmap = new HashMap(); for( Message msg : value.messages ) map.put( msg.getId(), msg ); return map; > @Override public Messages marshal( Map map ) < Messages msgCont = new Messages(); Collectionmsgs = map.values(); msgCont.messages = msgs.toArray(new Message[msgs.size()]); return msgCont; > >

And here is the test class to assert our assumptions:

public class XmlAdapterTest extends TestCase < public void testAdapter() throws Exception < InputStream is = this.getClass().getClassLoader().getResourceAsStream("profile.xml"); if (is != null) < JAXBContext jc; try < //test unmarshaling jc = JAXBContext.newInstance(Profile.class.getPackage().getName()); Unmarshaller u = jc.createUnmarshaller(); Profile profile = (Profile) u.unmarshal(is); assertNotNull(profile.getMessages()); assertEquals( 2, profile.getMessages().size()); //test marshaling Marshaller marshaller=jc.createMarshaller(); File xmlDocument = new File("output.xml"); marshaller.marshal(profile, new FileOutputStream(xmlDocument)); assertTrue(xmlDocument.length() >0); xmlDocument.delete(); > catch (JAXBException e) < e.printStackTrace(); fail(); >> > >

Still need the source code, find here: jaxb-typeadapter source, Sushant

Источник

Binding Map to XML: Dynamic Tag Names with JAXB

Join the DZone community and get the full member experience.

To convert Map to XML , the usual process is to stick with an element name, while altering its attribute and text content for different map entries. For example, to save this map:

into XML content, we usually save it as:

Yet in some cases (for example, due to some horrible past design choice), we may need to convert the map into the following format:

In this case, we can still use JAXB to achieve this conversion.

I recently came into this problem in a project. After some checks on StackOverflow, I wrote a solution and posted it there. And here is a formatted version. In short, to resolve this kind of problem, we need to:

1. Create a container class that holds a list (or array) of JAXBElement objects, where this list (or array) is annotated with @XmlAnyElement so dynamic element names can be generated.
2. Create an XmlAdapter class that handles marshaling/unmarshaling between Map to/from this container class.
3. Annotate any Map fields of your Java bean with @XmlJavaTypeAdapter, with this XmlAdapter class as its value (or you can simply use the container class directly, as you can see below).

Take the Map data listed above as an example, we need—

1. The Container (for @XmlAnyElement)

A Container to hold the @XmlAnyElement field, where all those elements that got dynamic names will be held as a list (or array).

1. For the JAXB Binding, all you need to pay attention to is this getProperties method, which gets annotated by @XmlAnyElement .
2. Two addEntry methods are introduced here for ease of use. They should be used carefully though, as things may turn out horribly wrong when they are used for a freshly unmarshalled MapWrapper through JAXBContext (instead of created by yourself through a new operator).
3. toMap is introduced here as an info probe, (to help to check map entries stored in this MapWrapper instance).

2. The Adapter (XmlAdapter)

XmlAdapter is used in pair with @XmlJavaTypeAdapter , which in this case is only needed when Map is used as a bean property.

/** * 
* ref: http://stackoverflow.com/questions/21382202/use-jaxb-xmlanyelement-type-of-style-to-return-dynamic-element-names *
 * @author MEC * */ public static class MapAdapter extends XmlAdapter> < @Override public Mapunmarshal(MapWrapper v) throws Exception < Mapmap = v.toMap(); return map; > @Override public MapWrapper marshal(Map m) throws Exception < MapWrapper wrapper = new MapWrapper(); for(Map.Entryentry : m.entrySet())< wrapper.addEntry(new JAXBElement(new QName(entry.getKey()), String.class, entry.getValue())); > return wrapper; > >

And that’s all. Now it’s time to play with this container and adapter.

3. Examples

Here are two examples showing usage of the container and adapter.

3.1 Example 1

You can use the following class:

@XmlRootElement(name="root") public class CustomMap extends MapWrapper < public CustomMap()< >>

CustomMap map = new CustomMap(); map.addEntry("key1", "value1"); map.addEntry("key1", "value2"); StringWriter sb = new StringWriter(); JAXBContext.newInstance(CustomMap.class).createMarshaller().marshal(map, sb); out.println(sb.toString());

Note that no @XmlJavaTypeAdapter is used here.

3.2 Example 2

   other content 

You can use the following class:

@XmlRootElement(name="root") @XmlType(propOrder=) public class YetAnotherBean < private Mapmap = new HashMap<>(); private String other; public YetAnotherBean() < >public void putEntry(String key, String value) < map.put(key, value); >@XmlElement(name="map") @XmlJavaTypeAdapter(MapAdapter.class) public Map getMap() < return map; >public void setMap(Map map) < this.map = map; >@XmlElement(name="other") public String getOther() < return other; >public void setOther(String other) < this.other = other; >>

YetAnotherBean yab = new YetAnotherBean(); yab.putEntry("key1", "value1"); yab.putEntry("key2", "value2"); yab.setOther("other content"); StringWriter sb = new StringWriter(); JAXBContext.newInstance(YetAnotherBean.class).createMarshaller().marshal(yab, sb); out.println(sb.toString());

Note that @XmlJavaTypeAdapter is applied onto the Map field with MapAdapter as its value.

3.3 Example 3

Now let’s add add some attributes to these elements. Due to some mysterious reasons, I have in my hand this kind of XML structure to map:

As you can see, system parameter names are all set to be the element’s name instead of as its attribute. To resolve this problem we can use a little help from JAXBElement again:

*
• When this SysParamEntriesWrapper is created by yourself, objects * stored in this entries list is of type SystemParamEntry *
• Yet during the unmarshalling process, this SysParamEntriesWrapper is * created by the JAXBContext, thus objects stored in the entries is * of type Element actually. *

//Marshal SysParamConfigXDO xdo = new SysParamConfigXDO(); xdo.addSysParam("ACCESSLOG_FILE_BY", "SYSTEM", "C", "AccessLog file desc"); xdo.addSysParam("ACCESSLOG_WRITE_MODE", "DB", "D", ""); xdo.addSysParam("CHANEG_BUTTON_IMAGES", "FALSE", "E", "Button Image URL, eh, boolean value. . Wait, what?"); JAXBContext jaxbCtx = JAXBContext.newInstance(SysParamConfigXDO.class, SysParamEntries.class); jaxbCtx.createMarshaller().marshal(xdo, System.out); //Unmarshal Path xmlFile = Paths.get("path_to_the_saved_xml_file.xml"); JAXBContext jaxbCtx = JAXBContext.newInstance(SysParamConfigXDO.class, SysParamEntries.class); SysParamConfigXDO xdo = (SysParamConfigXDO) jaxbCtx.createUnmarshaller().unmarshal(xmlFile.toFile()); System.out.println(xdo.toString());

Note that SysParamXDO is not used in the test code, yet it could be your choice when the wrapper element «sys-config» is not needed at all.

4. Summary

As I mentioned in the beginning, it’s not recommended to use dynamic element names for keys of Map. But in case you do need to, you can still achieve it by some @XmlAnyElement and XmlAdapter/@XmlJavaTypeAdapter.

Published at DZone with permission of Wenfei Tang . See the original article here.

Opinions expressed by DZone contributors are their own.

Источник

Java xml binding map

JAXB is a very efficient framework to covert XML to Object and Object to XML in Java. In this tutorial, we are going to see how to convert Java Map to XML using JAXB.

JAXB Map to XML Conversion:

Add the below jaxb-api dependency in pom.xml

Note: Java 1.9+ users have to use the below dependencies to get the jaxb-api, you can follow this StackOverflow thread for complete details.

  jakarta.xml.bind jakarta.xml.bind-api 2.3.2   org.glassfish.jaxb jaxb-runtime 2.3.2 

We can not convert the Java Map directly to XML because JAXB expects a @XmlRootElement annotation on top of the entity class to convert into XML. If you try to convert the Map object you would get the below exception.

Exception in thread “main” javax.xml.bind.JAXBException: class java.util.HashMap nor any of its super class is known to this context.
at com.sun.xml.bind.v2.runtime.JAXBContextImpl.getBeanInfo(JAXBContextImpl.java:563)
at com.sun.xml.bind.v2.runtime.XMLSerializer.childAsRoot(XMLSerializer.java:452)
at com.sun.xml.bind.v2.runtime.MarshallerImpl.write(MarshallerImpl.java:298)
at com.sun.xml.bind.v2.runtime.MarshallerImpl.marshal(MarshallerImpl.java:226)
at javax.xml.bind.helpers.AbstractMarshallerImpl.marshal(AbstractMarshallerImpl.java:80)

The Exception clearly saying @XmlRootElement is mandatory for JAXBContext.

So to fix the issue we can create a Wrapper for the HashMap class by defining the @XmlRootElement annotation on top of the Wrapper class. Let’s see in practice.

Java Map to XML Conversion Example:

In this example, I am going to create a map with a list of items, where a category is a key and the list of items are value.

So basically I need two wrapper classes to define my use-case: one is for List and another is for Map.

Creating ItemsList wrapper class to hold the items.

import javax.xml.bind.annotation.XmlAccessType; import javax.xml.bind.annotation.XmlAccessorType; import javax.xml.bind.annotation.XmlRootElement; import java.util.ArrayList; import java.util.List; @XmlRootElement(name = "item") @XmlAccessorType(XmlAccessType.FIELD) public class ItemsList < private Listitem = new ArrayList<>(); public List getItem() < return item; >public void setItem(List itemsList) < this.item = item; >> 

Create an ItemsMap class to hold the list of items by category.

import javax.xml.bind.annotation.XmlAccessType; import javax.xml.bind.annotation.XmlAccessorType; import javax.xml.bind.annotation.XmlRootElement; import java.util.HashMap; import java.util.Map; @XmlRootElement(name = "items") @XmlAccessorType(XmlAccessType.FIELD) public class ItemsMap < private MapitemsMap = new HashMap<>(); public Map getItemsMap() < return itemsMap; >public void setItemsMap(Map itemsMap) < this.itemsMap = itemsMap; >> 

Now the wrapper classes are ready to use. Now let’s prepare the list of items, make it as a map and convert the map into XML.

import javax.xml.bind.JAXBContext; import javax.xml.bind.JAXBException; import javax.xml.bind.Marshaller; import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; public class MapToXML < public static void main(String[] args) throws JAXBException < // Creating HashMap to hold ItemsList (Wrapper for List) HashMapmap = new HashMap<>(); map.put("electronics",getElecrtonics()); map.put("books",getBooks()); // Setting map to ItemsMap (Wrapper for HashMap) ItemsMap iMap = new ItemsMap(); iMap.setItemsMap(map); JAXBContext jaxbContext = JAXBContext.newInstance(ItemsMap.class); Marshaller jaxbMarshaller = jaxbContext.createMarshaller(); jaxbMarshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true); // marshalling ItemsMap. jaxbMarshaller.marshal(iMap, System.out); > // Building the Electronic items public static ItemsList getElecrtonics() < ArrayListlist = new ArrayList(Arrays.asList(new Item(100,"Samsung",15000.00), new Item(200,"iPhone10",110000.00))); ItemsList itemsList = new ItemsList(); itemsList.getItem().addAll(list); return itemsList; > // Building the Book items public static ItemsList getBooks() < ArrayListlist = new ArrayList(Arrays.asList(new Item(2000,"Core Java",500.00), new Item(3000,"Spring in Action",750.00))); ItemsList itemsList = new ItemsList(); itemsList.getItem().addAll(list); return itemsList; > > 

    electronics  100 Samsung 15000.0  200 iPhone10 110000.0    books  2000 Core Java 500.0  3000 Spring in Action 750.0     

References:

Источник