create SOAP Element From XML String

 import java.io.IOException;
import java.io.StringReader;
import java.util.Iterator;
import javax.xml.parsers.*;
import javax.xml.soap.*;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;

public class Test{

public static SOAPElement createSOAPElementFromXMLString(String xmlString)
        throws ParserConfigurationException, IOException, SAXException
    {
        StringReader stringReader = new StringReader(xmlString);
        InputSource inputSource = new InputSource(stringReader);
        SAXParserFactory factory = SAXParserFactory.newInstance();
        factory.setNamespaceAware(true);
        SAXParser parser = factory.newSAXParser();
        SoapElementSaxHandler handler = new SoapElementSaxHandler();
        parser.parse(inputSource, handler);
        return handler.getSOAPElement();
    }

}


SoapElementSaxHandler.java
 ~~~~~~~~~~~~~~~~~~~~~~
import java.util.ArrayList;
import java.util.HashMap;
import javax.xml.soap.*;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

public class SoapElementSaxHandler extends DefaultHandler
{

    public SoapElementSaxHandler()
    {
        prefixURIMapping = new HashMap();
        uris = new ArrayList();
        rootElement = null;
        currentElement = null;
    }

    public SOAPElement getSOAPElement()
    {
        return rootElement;
    }

    public void startDocument()
        throws SAXException
    {
        try
        {
            soapFactory = SOAPFactory.newInstance();
        }
        catch(SOAPException e)
        {
            throw new SAXException("Can't create a SOAPFactory instance", e);
        }
    }

    public void startPrefixMapping(String prefix, String uri)
    {
        prefixURIMapping.put(uri, prefix);
        uris.add(uri);
    }

    public void characters(char ch[], int start, int length)
        throws SAXException
    {
        String str = String.valueOf(ch);
        if(length > 0)
            try
            {
                currentElement.addTextNode(str.substring(start, start + length));
            }
            catch(SOAPException e)
            {
                throw new SAXException("Can't add a text node into SOAPElement from text", e);
            }
    }

    public void endElement(String uri, String localName, String qName)
    {
        if(currentElement != rootElement)
            currentElement = currentElement.getParentElement();
    }

    public void startElement(String namespaceURI, String localName, String qName, Attributes atts)
        throws SAXException
    {
        String prefix = (String)prefixURIMapping.get(namespaceURI);
        try
        {
            if(rootElement == null && currentElement == null)
            {
                rootElement = soapFactory.createElement(localName, prefix, namespaceURI);
                currentElement = rootElement;
            } else
            {
                currentElement = currentElement.addChildElement(localName, prefix, namespaceURI);
            }
            if(uris.size() > 0)
            {
                for(int i = 0; i < uris.size(); i++)
                {
                    String uri = (String)uris.get(i);
                    String pre = (String)prefixURIMapping.get(uri);
                    currentElement.addNamespaceDeclaration(pre, uri);
                }

                uris.clear();
            }
            for(int i = 0; i < atts.getLength(); i++)
            {
                javax.xml.soap.Name attriName;
                if(atts.getURI(i) != null)
                {
                    String attriPre = (String)prefixURIMapping.get(atts.getURI(i));
                    attriName = soapFactory.createName(atts.getLocalName(i), attriPre, atts.getURI(i));
                } else
                {
                    attriName = soapFactory.createName(atts.getLocalName(i));
                }
                currentElement.addAttribute(attriName, atts.getValue(i));
            }

        }
        catch(SOAPException e)
        {
            throw new SAXException(e);
        }
    }

    private HashMap prefixURIMapping;
    private ArrayList uris;
    private SOAPElement rootElement;
    private SOAPElement currentElement;
    private SOAPFactory soapFactory;
}

Create DomElement From XML String

import java.io.StringReader;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.*;
import org.xml.sax.InputSource;

public class DomParser{

 public static Element createDomElementFromXMLString(String xmlString)
    {
        InputSource inputSource;
        StringReader stringReader = new StringReader(xmlString);
        inputSource = new InputSource(stringReader);
        Document document;
        DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory.newInstance();
        DocumentBuilder docBuilder = docBuilderFactory.newDocumentBuilder();
        document = docBuilder.parse(inputSource);
        return document.getDocumentElement();
        JVM INSTR pop ;
        return null;
    }
}

XML Processing using SAX Parser

SAXTest.java
~~~~~~~~~~~~
package com.anil;

import java.io.IOException;

import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

/**
* Simple XML process use SAX method, SAX simple API for XML
*
*/
public class SAXTest extends DefaultHandler {
@Override
public void startDocument() throws SAXException {
   super.startDocument();
}

@Override
public void endDocument() throws SAXException {
   super.endDocument();
}

@Override
public void startElement(String uri, String localName, String name,
    Attributes attributes) throws SAXException {
   System.out.println("uri: " + uri);
   System.out.println("localName: " + localName);
   System.out.println("name: " + name);
   for (int i = 0; i < attributes.getLength(); i++) {
    System.out.println(i + " attributes: " + attributes.getValue(i));
   }
   if ("display".equals(name)) {
    String value = attributes.getValue("size");
    System.out.println(value);
   }
   if ("ram".equals(name)) {
    String value = attributes.getValue("type");
    System.out.println(value);
   }
}

@Override
public void endElement(String uri, String localName, String name)
    throws SAXException {
   super.endElement(uri, localName, name);
}

// SAX simple API for XML
public static void main(String[] args) {
   try {
    /*
    * get SAXParser then parse XML file
    */
    SAXParserFactory parserFactory = SAXParserFactory.newInstance();
    SAXParser parser = parserFactory.newSAXParser();
    parser.parse("anil.xml", new SAXTest());

   } catch (ParserConfigurationException e) {
    e.printStackTrace();
   } catch (SAXException e) {
    e.printStackTrace();
   } catch (IOException e) {
    e.printStackTrace();
   }
}

}
--------------------------------------------------------------------------------------------------------------
anil.xml
~~~~~~~~
 <?xml version="1.0" encoding="utf-8"?>
<computer>
<display size="17">Samsung</display>
<box>
   <motherboard>
    <cpu>E8300</cpu>
    <ram type="DDR2">2G</ram>
    <displaycard>nVidia</displaycard>
   </motherboard>
   <harddisk>320G</harddisk>
   <dvdrom>16X</dvdrom>
</box>
</computer>

XML Processing by DOM parser

DOMTest.java
~~~~~~~~~~~~
package com.anil;

import java.io.IOException;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.soap.Text;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

/**
 * Simple XML process use DOM Method, DOM document object model
 *
 */
public class DOMTest {
    public static void main(String[] args) {

        // DOM document object model
        try {
            /*
             * get documentBuilder and parse XML file
             */
            DocumentBuilderFactory factory = DocumentBuilderFactory
                    .newInstance();
            DocumentBuilder documentBuilder = factory.newDocumentBuilder();
            Document document = documentBuilder.parse("anil.xml");

            /*
             * get first element in XML file, this were root element
             */
            Element element = document.getDocumentElement();
            String tagName = element.getTagName();
            System.out.println("root element: " + tagName);

            /*
             * add new element to XML and save it to new file
             */
            Element power = document.createElement("Power");
            element.appendChild(power);

            try {
                TransformerFactory transformerFactory = TransformerFactory.newInstance();
                Transformer transformer = transformerFactory.newTransformer();
                transformer.transform(new DOMSource(document),new StreamResult("newAnil.xml"));
                System.out.println("Create new XML file success!");
                System.out.println("----------------------------");
            } catch (TransformerConfigurationException e1) {
                e1.printStackTrace();
            } catch (TransformerException e) {
                e.printStackTrace();
            }

            /*
             * search for special element item, and print item value
             */
            NodeList nodeList = element.getElementsByTagName("display");
            for (int i = 0; i < nodeList.getLength(); i++) {
                Element item = (Element) nodeList.item(i);
                String size = item.getAttribute("size");
                System.out.println("Display size: " + size);
                System.out.println("-----------------------------");
            }

            /*
             * get sub nodes of element
             */
            NodeList childNodes = element.getChildNodes();
            System.out.println("childNodes size: " + childNodes.getLength());

            /*
             * iterator sub element in XML file
             */
            for (int i = 0; i < childNodes.getLength(); i++) {
                Node item = childNodes.item(i);
                // System.out.println(item);

                /*
                 * access Text in XML file
                 */
                if (item instanceof Text) {
                    Text text = (Text) item;
                    String data = text.getData();
                    System.out.println("text: " + data);
                }

                /*
                 * access element in XML file
                 */
                if (item instanceof Element) {
                    Element e = (Element) item;
                    String tagName2 = e.getTagName();
                    System.out.println("sub tag name: " + tagName2);

                    /*
                     * get attributes of element
                     */
                    NamedNodeMap attributes = e.getAttributes();
                    for (int j = 0; j < attributes.getLength(); j++) {
                        Node item2 = attributes.item(j);
                        System.out.println("sub item: " + item2);
                    }
                }
            }

            System.out.println("----------End------------");

        } catch (ParserConfigurationException e) {
            e.printStackTrace();
        } catch (SAXException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

--------------------------------------------------------------------------------------------------------------
anil.xml
~~~~~~
<?xml version="1.0" encoding="utf-8"?>
<computer>
<display size="17">Samsung</display>
<box>
   <motherboard>
    <cpu>E8300</cpu>
    <ram type="DDR2">2G</ram>
    <displaycard>nVidia</displaycard>
   </motherboard>
   <harddisk>320G</harddisk>
   <dvdrom>16X</dvdrom>
</box>
</computer>

String to formatted XML conversion

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringWriter;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import org.w3c.dom.Document;
import org.xml.sax.SAXException;

public class StringToXML {
 public static String strT0XML(String xmlString) {
  try {
   DocumentBuilder documentBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
   InputStream inputStream = new ByteArrayInputStream(xmlString.getBytes());
   Document document = documentBuilder.parse(inputStream);
   TransformerFactory tfactory = TransformerFactory.newInstance();
   DOMSource xmlSource = new DOMSource(document);
   java.io.StringWriter writer = new StringWriter();
   javax.xml.transform.Result result = new javax.xml.transform.stream.StreamResult(writer);
   Transformer serializer = tfactory.newTransformer();
   serializer.setOutputProperty(OutputKeys.INDENT, "yes");
   serializer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
   serializer.transform(xmlSource, result);
   return writer.toString();
  } catch (TransformerException e) {
   e.printStackTrace();
   throw new RuntimeException(e);
  } catch (ParserConfigurationException e) {
   e.printStackTrace();
  } catch (SAXException e) {
   e.printStackTrace();
  } catch (IOException e) {
   e.printStackTrace();
  }
  return "";
 }
}