Parse XML TO JAVA POJO in efficient way

Question

How to parse and create java pojo for below xml in an efficient way? Kindly suggest any efficient parser.

XML format is

Answer 1

For those looking for JAXB code to convert xml to java object:

//Convert xml to String first
Element partyLoaderRequest; // your xml data
String xmlString = new XMLOutputter().outputString(partyLoaderRequest);   
InputStream is = new ByteArrayInputStream(xmlString.getBytes());
DocumentBuilder docBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
Document document = docBuilder.parse(is);
org.w3c.dom.Element varElement = document.getDocumentElement();
JAXBContext context = JAXBContext.newInstance(Person.class);
Unmarshaller unmarshaller = context.createUnmarshaller();
JAXBElement<Person> loader = unmarshaller.unmarshal(varElement, Person.class);
Person inputFromXml = loader.getValue();

whereas Person has proper XML annotations:

@XmlRootElement(name="Person")
public class CimbWlAdminUserAmendInput {
    @XmlElement(name="companyName",required=true,nillable=false) 
    private String companyName;
    ...
    //setters getters
    @XmlTransient
    public String getCompanyName() {
        return companyName;
    }

    public void setCompanyName(String companyName) {
        this.companyName = companyName;
    }
}

Answer 2

You can use JAXB to convert XML into Java POJOs. But before you finalize the solution check this site for performance comparison.

Answer 3

public class XmlConvertUtil {

    public static void main(String[] args) {
        ResultDataSet resultDataSet = new ResultDataSet(new DtInformation("0", "Success"), new DtData("980000001"));
        //Method which uses JAXB to convert object to XML
        System.out.println(JaxbObjToXML(resultDataSet));
    }

    public static Object JaxbXmlToObj(String xmlString, Object obj) {

        JAXBContext jaxbContext;
        try {
            jaxbContext = JAXBContext.newInstance(obj.getClass());

            Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();

            Object resultDataSet = (Object) jaxbUnmarshaller.unmarshal(new StringReader(xmlString));

            //System.out.println(resultDataSet);
        }
        catch (JAXBException e) {
            e.printStackTrace();
        }
        return obj;
    }

    public static String JaxbObjToXML(Object object) {
        String xmlContent = null;
        try {
            //Create JAXB Context
            JAXBContext jaxbContext = JAXBContext.newInstance(object.getClass());

            //Create Marshaller
            Marshaller jaxbMarshaller = jaxbContext.createMarshaller();

            //Required formatting??
            jaxbMarshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
            jaxbMarshaller.setProperty(Marshaller.JAXB_FRAGMENT, Boolean.TRUE);

            //Print XML String to Console
            StringWriter sw = new StringWriter();

            //Write XML to StringWriter
            jaxbMarshaller.marshal(object, sw);

            //Verify XML Content
            xmlContent = sw.toString();
            //System.out.println(xmlContent);
        }
        catch (JAXBException e) {
            e.printStackTrace();
        }
        return xmlContent;
    }
}

Answer 4

Serialization and Deserialization can be handle by JacksonXmlModule.

// Item.class - use lombok or create g/setters
@JsonPropertyOrder({"name", "description", "note"})
public class Item { 
   private String name;
   private String description;
   private String note;
}


// Test.class
package hello.service;

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.dataformat.xml.JacksonXmlModule;
import com.fasterxml.jackson.dataformat.xml.XmlMapper;

import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement;
import hello.entity.Item;
import org.junit.Before;

import org.junit.Test;

import java.util.ArrayList;
import java.util.List;

import static org.junit.Assert.*;

public class NameServiceImplTest {

    ObjectMapper objectMapper;

    @Before
    public void setup() {
        JacksonXmlModule xmlModule = new JacksonXmlModule();
        xmlModule.setDefaultUseWrapper(false);
        this.objectMapper = new XmlMapper(xmlModule);
        this.objectMapper.enable(SerializationFeature.INDENT_OUTPUT);
    }

    @Test
    public void serializeTest() {

        // Wrapper
        @JacksonXmlRootElement(localName = "names")
        class Names {
            public List<Item> item = new ArrayList<>();
        }

        Item item = new Item();
        item.setName("Vladimir");
        item.setDescription("Desc");
        item.setNote("Note");

        Item item2 = new Item();
        item2.setName("Iva");
        item2.setDescription("Desc2");
        item2.setNote("Note2");

        Names names = new Names();
        names.item.add(item);
        names.item.add(item2);

        try {
            String xml = objectMapper.writeValueAsString(names);
            assertNotNull(xml);
            System.out.println(xml);
        } catch (Exception e) { // IOException
            System.out.println(e.getMessage());
            fail();
        }
    }

    @Test
    public void deserializeTest() {
        String xml = "<names>" +
                "<item><name>name</name><description>desc</description><note>note</note></item>" +
                "<item><name>name</name><description>desc</description><note>note</note></item>" +
                "</names>";

        try {
            List<Item> names = objectMapper.readValue(xml, new TypeReference<List<Item>>() {});
            names.forEach(item -> {

                assertEquals("name", item.getName());
                assertEquals("desc", item.getDescription());
                assertEquals("note", item.getNote());

            } );
        } catch (Exception e) { // IOException

        }


    }
}