Merge branch 'master' of https://github.com/JonCook/tutorials

xml/src/main/java/com/baeldung/sax/SaxParserMain.java

@@ -0,0 +1,109 @@
+package com.baeldung.sax;
+
+import org.xml.sax.Attributes;
+import org.xml.sax.SAXException;
+import org.xml.sax.helpers.DefaultHandler;
+
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.parsers.SAXParser;
+import javax.xml.parsers.SAXParserFactory;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+public class SaxParserMain {
+    public static void main(String[] args) throws ParserConfigurationException, SAXException, IOException {
+        SAXParserFactory factory = SAXParserFactory.newInstance();
+        SAXParser saxParser = factory.newSAXParser();
+
+        BaeldungHandler baeldungHandler = new BaeldungHandler();
+        saxParser.parse("xml/src/main/resources/sax/baeldung.xml", baeldungHandler);
+        System.out.println(baeldungHandler.getWebsite());
+    }
+
+    public static class BaeldungHandler extends DefaultHandler {
+        private static final String ARTICLES = "articles";
+        private static final String ARTICLE = "article";
+        private static final String TITLE = "title";
+        private static final String CONTENT = "content";
+
+        private Baeldung website;
+        private String elementValue;
+
+        @Override
+        public void characters(char[] ch, int start, int length) throws SAXException {
+            elementValue = new String(ch, start, length);
+        }
+
+        @Override
+        public void startDocument() throws SAXException {
+            website = new Baeldung();
+        }
+
+        @Override
+        public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
+            switch (qName) {
+                case ARTICLES:
+                    website.setArticleList(new ArrayList<>());
+                    break;
+                case ARTICLE:
+                    website.getArticleList().add(new BaeldungArticle());
+            }
+        }
+
+        @Override
+        public void endElement(String uri, String localName, String qName) throws SAXException {
+            switch (qName) {
+                case TITLE:
+                    latestArticle().setTitle(elementValue);
+                    break;
+                case CONTENT:
+                    latestArticle().setContent(elementValue);
+                    break;
+            }
+        }
+
+        private BaeldungArticle latestArticle() {
+            List<BaeldungArticle> articleList = website.getArticleList();
+            int latestArticleIndex = articleList.size() - 1;
+            return articleList.get(latestArticleIndex);
+        }
+
+        public Baeldung getWebsite() {
+            return website;
+        }
+    }
+
+    public static class Baeldung {
+        private List<BaeldungArticle> articleList;
+
+        public void setArticleList(List<BaeldungArticle> articleList) {
+            this.articleList = articleList;
+        }
+
+        public List<BaeldungArticle> getArticleList() {
+            return this.articleList;
+        }
+    }
+
+    public static class BaeldungArticle {
+        private String title;
+        private String content;
+
+        public void setTitle(String title) {
+            this.title = title;
+        }
+
+        public String getTitle() {
+            return this.title;
+        }
+
+        public void setContent(String content) {
+            this.content = content;
+        }
+
+        public String getContent() {
+            return this.content;
+        }
+    }
+}

xml/src/main/java/com/baeldung/xml/DefaultParser.java

@@ -0,0 +1,193 @@
+package com.baeldung.xml;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.Iterator;
+
+import javax.xml.namespace.NamespaceContext;
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.xpath.XPath;
+import javax.xml.xpath.XPathConstants;
+import javax.xml.xpath.XPathExpressionException;
+import javax.xml.xpath.XPathFactory;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+import org.xml.sax.SAXException;
+
+public class DefaultParser {
+
+    private File file;
+
+    public DefaultParser(File file) {
+        this.file = file;
+    }
+
+    public NodeList getFirstLevelNodeList() {
+        NodeList nodeList = null;
+        try {
+            FileInputStream fileIS = new FileInputStream(this.getFile());
+            DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
+
+            DocumentBuilder builder = builderFactory.newDocumentBuilder();
+
+            Document xmlDocument = builder.parse(fileIS);
+
+            XPath xPath = XPathFactory.newInstance().newXPath();
+
+            String expression = "/tutorials/tutorial";
+
+            nodeList = (NodeList) xPath.compile(expression).evaluate(xmlDocument, XPathConstants.NODESET);
+
+        } catch (SAXException | IOException | ParserConfigurationException | XPathExpressionException e) {
+            e.printStackTrace();
+        }
+        return nodeList;
+    }
+
+    public Node getNodeById(String id) {
+        Node node = null;
+        try {
+            DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
+
+            DocumentBuilder builder = builderFactory.newDocumentBuilder();
+
+            Document xmlDocument = builder.parse(this.getFile());
+
+            XPath xPath = XPathFactory.newInstance().newXPath();
+
+            String expression = "/tutorials/tutorial[@tutId=" + "'" + id + "'" + "]";
+
+            node = (Node) xPath.compile(expression).evaluate(xmlDocument, XPathConstants.NODE);
+
+        } catch (SAXException | IOException | ParserConfigurationException | XPathExpressionException e) {
+            e.printStackTrace();
+        }
+        return node;
+    }
+
+    public NodeList getNodeListByTitle(String name) {
+        NodeList nodeList = null;
+        try {
+            DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
+
+            DocumentBuilder builder = builderFactory.newDocumentBuilder();
+
+            Document xmlDocument = builder.parse(this.getFile());
+
+            this.clean(xmlDocument);
+
+            XPath xPath = XPathFactory.newInstance().newXPath();
+
+            String expression = "//tutorial[descendant::title[text()=" + "'" + name + "'" + "]]";
+
+            nodeList = (NodeList) xPath.compile(expression).evaluate(xmlDocument, XPathConstants.NODESET);
+
+        } catch (SAXException | IOException | ParserConfigurationException | XPathExpressionException e) {
+            e.printStackTrace();
+        }
+        return nodeList;
+    }
+
+    public NodeList getElementsByDate(String date) {
+        NodeList nodeList = null;
+
+        try {
+            DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
+
+            DocumentBuilder builder = builderFactory.newDocumentBuilder();
+
+            Document xmlDocument = builder.parse(this.getFile());
+
+            this.clean(xmlDocument);
+
+            XPath xPath = XPathFactory.newInstance().newXPath();
+
+            String expression = "//tutorial[number(translate(date, '/', '')) > " + date + "]";
+
+            nodeList = (NodeList) xPath.compile(expression).evaluate(xmlDocument, XPathConstants.NODESET);
+
+        } catch (SAXException | IOException | ParserConfigurationException | XPathExpressionException e) {
+            e.printStackTrace();
+        }
+        return nodeList;
+    }
+
+    public NodeList getAllTutorials() {
+        NodeList nodeList = null;
+        try {
+            DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
+            builderFactory.setNamespaceAware(true);
+            DocumentBuilder builder = builderFactory.newDocumentBuilder();
+
+            Document xmlDocument = builder.parse(this.getFile());
+
+            this.clean(xmlDocument);
+
+            XPath xPath = XPathFactory.newInstance().newXPath();
+
+            xPath.setNamespaceContext(new NamespaceContext() {
+
+                @Override
+                public Iterator getPrefixes(String arg0) {
+                    return null;
+                }
+
+                @Override
+                public String getPrefix(String arg0) {
+                    return null;
+                }
+
+                @Override
+                public String getNamespaceURI(String arg0) {
+                    if ("bdn".equals(arg0)) {
+                        return "http://www.baeldung.com/full_archive";
+                    }
+                    return null;
+                }
+            });
+
+            String expression = "/bdn:tutorials/bdn:tutorial";
+
+            nodeList = (NodeList) xPath.compile(expression).evaluate(xmlDocument, XPathConstants.NODESET);
+
+        } catch (SAXException | IOException | ParserConfigurationException | XPathExpressionException e) {
+            e.printStackTrace();
+        }
+        return nodeList;
+    }
+
+    private void clean(Node node) {
+
+        NodeList childs = node.getChildNodes();
+
+        for (int n = childs.getLength() - 1; n >= 0; n--) {
+            Node child = childs.item(n);
+            short nodeType = child.getNodeType();
+
+            if (nodeType == Node.ELEMENT_NODE)
+                clean(child);
+            else if (nodeType == Node.TEXT_NODE) {
+                String trimmedNodeVal = child.getNodeValue().trim();
+                if (trimmedNodeVal.length() == 0)
+                    node.removeChild(child);
+                else
+                    child.setNodeValue(trimmedNodeVal);
+            } else if (nodeType == Node.COMMENT_NODE)
+                node.removeChild(child);
+        }
+    }
+
+    public File getFile() {
+        return file;
+    }
+
+    public void setFile(File file) {
+        this.file = file;
+    }
+
+}

xml/src/main/java/com/baeldung/xml/Dom4JParser.java

@@ -0,0 +1,130 @@
+package com.baeldung.xml;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.Iterator;
+import java.util.List;
+
+import org.dom4j.Document;
+import org.dom4j.DocumentException;
+import org.dom4j.DocumentHelper;
+import org.dom4j.Element;
+import org.dom4j.Node;
+import org.dom4j.io.OutputFormat;
+import org.dom4j.io.SAXReader;
+import org.dom4j.io.XMLWriter;
+
+public class Dom4JParser {
+
+    private File file;
+
+    public Dom4JParser(File file) {
+        this.file = file;
+    }
+
+    public Element getRootElement() {
+        try {
+            SAXReader reader = new SAXReader();
+            Document document = reader.read(file);
+            return document.getRootElement();
+        } catch (DocumentException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    public List<Element> getFirstElementList() {
+        try {
+            SAXReader reader = new SAXReader();
+            Document document = reader.read(file);
+            return document.getRootElement().elements();
+        } catch (DocumentException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    public Node getNodeById(String id) {
+        try {
+            SAXReader reader = new SAXReader();
+            Document document = reader.read(file);
+            List<Node> elements = document.selectNodes("//*[@tutId='" + id + "']");
+            return elements.get(0);
+        } catch (DocumentException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    public Node getElementsListByTitle(String name) {
+        try {
+            SAXReader reader = new SAXReader();
+            Document document = reader.read(file);
+            List<Node> elements = document.selectNodes("//tutorial[descendant::title[text()=" + "'" + name + "'" + "]]");
+            return elements.get(0);
+        } catch (DocumentException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    public void generateModifiedDocument() {
+        try {
+            SAXReader reader = new SAXReader();
+            Document document = reader.read(file);
+            List<Node> nodes = document.selectNodes("/tutorials/tutorial");
+            for (Node node : nodes) {
+                Element element = (Element) node;
+                Iterator<Element> iterator = element.elementIterator("title");
+                while (iterator.hasNext()) {
+                    Element title = (Element) iterator.next();
+                    title.setText(title.getText() + " updated");
+                }
+            }
+            XMLWriter writer = new XMLWriter(new FileWriter(new File("src/test/resources/example_dom4j_updated.xml")));
+            writer.write(document);
+            writer.close();
+        } catch (DocumentException e) {
+            e.printStackTrace();
+
+        } catch (IOException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+        }
+    }
+
+    public void generateNewDocument() {
+        try {
+            Document document = DocumentHelper.createDocument();
+            Element root = document.addElement("XMLTutorials");
+            Element tutorialElement = root.addElement("tutorial").addAttribute("tutId", "01");
+            tutorialElement.addAttribute("type", "xml");
+
+            tutorialElement.addElement("title").addText("XML with Dom4J");
+
+            tutorialElement.addElement("description").addText("XML handling with Dom4J");
+
+            tutorialElement.addElement("date").addText("14/06/2016");
+
+            tutorialElement.addElement("author").addText("Dom4J tech writer");
+
+            OutputFormat format = OutputFormat.createPrettyPrint();
+            XMLWriter writer = new XMLWriter(new FileWriter(new File("src/test/resources/example_dom4j_new.xml")), format);
+            writer.write(document);
+            writer.close();
+        } catch (IOException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+        }
+    }
+
+    public File getFile() {
+        return file;
+    }
+
+    public void setFile(File file) {
+        this.file = file;
+    }
+
+}

xml/src/main/java/com/baeldung/xml/JDomParser.java

@@ -0,0 +1,61 @@
+package com.baeldung.xml;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.List;
+
+import org.jdom2.Document;
+import org.jdom2.Element;
+import org.jdom2.JDOMException;
+import org.jdom2.filter.Filters;
+import org.jdom2.input.SAXBuilder;
+import org.jdom2.xpath.XPathExpression;
+import org.jdom2.xpath.XPathFactory;
+
+public class JDomParser {
+
+    private File file;
+
+    public JDomParser(File file) {
+        this.file = file;
+    }
+
+    public List<Element> getAllTitles() {
+        try {
+            SAXBuilder builder = new SAXBuilder();
+            Document doc = builder.build(this.getFile());
+            Element tutorials = doc.getRootElement();
+            List<Element> titles = tutorials.getChildren("tutorial");
+            return titles;
+        } catch (JDOMException | IOException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    public Element getNodeById(String id) {
+        try {
+            SAXBuilder builder = new SAXBuilder();
+            Document document = (Document) builder.build(file);
+            String filter = "//*[@tutId='" + id + "']";
+            XPathFactory xFactory = XPathFactory.instance();
+            XPathExpression<Element> expr = xFactory.compile(filter, Filters.element());
+            List<Element> node = expr.evaluate(document);
+
+            return node.get(0);
+        } catch (JDOMException | IOException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    public File getFile() {
+        return file;
+    }
+
+    public void setFile(File file) {
+        this.file = file;
+    }
+
+}

xml/src/main/java/com/baeldung/xml/JaxbParser.java

@@ -0,0 +1,68 @@
+package com.baeldung.xml;
+
+import java.io.File;
+import java.util.ArrayList;
+
+import javax.xml.bind.JAXBContext;
+import javax.xml.bind.JAXBException;
+import javax.xml.bind.Marshaller;
+import javax.xml.bind.Unmarshaller;
+
+import com.baeldung.xml.binding.Tutorial;
+import com.baeldung.xml.binding.Tutorials;
+
+public class JaxbParser {
+
+    private File file;
+
+    public JaxbParser(File file) {
+        this.file = file;
+    }
+
+    public Tutorials getFullDocument() {
+        try {
+            JAXBContext jaxbContext = JAXBContext.newInstance(Tutorials.class);
+            Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();
+            Tutorials tutorials = (Tutorials) jaxbUnmarshaller.unmarshal(this.getFile());
+            return tutorials;
+        } catch (JAXBException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    public void createNewDocument() {
+        Tutorials tutorials = new Tutorials();
+        tutorials.setTutorial(new ArrayList<Tutorial>());
+        Tutorial tut = new Tutorial();
+        tut.setTutId("01");
+        tut.setType("XML");
+        tut.setTitle("XML with Jaxb");
+        tut.setDescription("XML Binding with Jaxb");
+        tut.setDate("04/02/2015");
+        tut.setAuthor("Jaxb author");
+        tutorials.getTutorial().add(tut);
+
+        try {
+            JAXBContext jaxbContext = JAXBContext.newInstance(Tutorials.class);
+            Marshaller jaxbMarshaller = jaxbContext.createMarshaller();
+
+            jaxbMarshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
+
+            jaxbMarshaller.marshal(tutorials, file);
+
+        } catch (JAXBException e) {
+            e.printStackTrace();
+        }
+
+    }
+
+    public File getFile() {
+        return file;
+    }
+
+    public void setFile(File file) {
+        this.file = file;
+    }
+
+}

xml/src/main/java/com/baeldung/xml/JaxenDemo.java

@@ -0,0 +1,56 @@
+package com.baeldung.xml;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.List;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+
+import org.jaxen.JaxenException;
+import org.jaxen.XPath;
+import org.jaxen.dom.DOMXPath;
+import org.w3c.dom.Document;
+import org.xml.sax.SAXException;
+
+public class JaxenDemo {
+
+    private File file;
+
+    public JaxenDemo(File file) {
+        this.file = file;
+    }
+
+    public List getAllTutorial() {
+        try {
+            FileInputStream fileIS = new FileInputStream(this.getFile());
+            DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
+
+            DocumentBuilder builder = builderFactory.newDocumentBuilder();
+
+            Document xmlDocument = builder.parse(fileIS);
+
+            String expression = "/tutorials/tutorial";
+
+            XPath path = new DOMXPath(expression);
+            List result = path.selectNodes(xmlDocument);
+            return result;
+
+        } catch (SAXException | IOException | ParserConfigurationException | JaxenException e) {
+            e.printStackTrace();
+            return null;
+        }
+
+    }
+
+    public File getFile() {
+        return file;
+    }
+
+    public void setFile(File file) {
+        this.file = file;
+    }
+
+}

xml/src/main/java/com/baeldung/xml/StaxParser.java

@@ -0,0 +1,120 @@
+package com.baeldung.xml;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import javax.xml.stream.XMLEventReader;
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamConstants;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.events.Attribute;
+import javax.xml.stream.events.Characters;
+import javax.xml.stream.events.EndElement;
+import javax.xml.stream.events.StartElement;
+import javax.xml.stream.events.XMLEvent;
+
+import com.baeldung.xml.binding.Tutorial;
+
+public class StaxParser {
+
+    private File file;
+
+    public StaxParser(File file) {
+        this.file = file;
+    }
+
+    public List<Tutorial> getAllTutorial() {
+        boolean bTitle = false;
+        boolean bDescription = false;
+        boolean bDate = false;
+        boolean bAuthor = false;
+        List<Tutorial> tutorials = new ArrayList<Tutorial>();
+        try {
+            XMLInputFactory factory = XMLInputFactory.newInstance();
+            XMLEventReader eventReader = factory.createXMLEventReader(new FileReader(this.getFile()));
+            Tutorial current = null;
+            while (eventReader.hasNext()) {
+                XMLEvent event = eventReader.nextEvent();
+                switch (event.getEventType()) {
+                case XMLStreamConstants.START_ELEMENT:
+                    StartElement startElement = event.asStartElement();
+                    String qName = startElement.getName().getLocalPart();
+                    if (qName.equalsIgnoreCase("tutorial")) {
+                        current = new Tutorial();
+                        Iterator<Attribute> attributes = startElement.getAttributes();
+                        while (attributes.hasNext()) {
+                            Attribute currentAt = attributes.next();
+                            if (currentAt.getName().toString().equalsIgnoreCase("tutId")) {
+                                current.setTutId(currentAt.getValue());
+                            } else if (currentAt.getName().toString().equalsIgnoreCase("type")) {
+                                current.setType(currentAt.getValue());
+                            }
+                        }
+                    } else if (qName.equalsIgnoreCase("title")) {
+                        bTitle = true;
+                    } else if (qName.equalsIgnoreCase("description")) {
+                        bDescription = true;
+                    } else if (qName.equalsIgnoreCase("date")) {
+                        bDate = true;
+                    } else if (qName.equalsIgnoreCase("author")) {
+                        bAuthor = true;
+                    }
+                    break;
+                case XMLStreamConstants.CHARACTERS:
+                    Characters characters = event.asCharacters();
+                    if (bTitle) {
+                        if (current != null) {
+                            current.setTitle(characters.getData());
+                        }
+                        bTitle = false;
+                    }
+                    if (bDescription) {
+                        if (current != null) {
+                            current.setDescription(characters.getData());
+                        }
+                        bDescription = false;
+                    }
+                    if (bDate) {
+                        if (current != null) {
+                            current.setDate(characters.getData());
+                        }
+                        bDate = false;
+                    }
+                    if (bAuthor) {
+                        if (current != null) {
+                            current.setAuthor(characters.getData());
+                        }
+                        bAuthor = false;
+                    }
+                    break;
+                case XMLStreamConstants.END_ELEMENT:
+                    EndElement endElement = event.asEndElement();
+                    if (endElement.getName().getLocalPart().equalsIgnoreCase("tutorial")) {
+                        if (current != null) {
+                            tutorials.add(current);
+                        }
+                    }
+                    break;
+                }
+            }
+
+        } catch (FileNotFoundException | XMLStreamException e) {
+            e.printStackTrace();
+        }
+
+        return tutorials;
+    }
+
+    public File getFile() {
+        return file;
+    }
+
+    public void setFile(File file) {
+        this.file = file;
+    }
+
+}

xml/src/main/java/com/baeldung/xml/XMLDocumentWriter.java

@@ -0,0 +1,41 @@
+package com.baeldung.xml;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+
+import javax.xml.transform.OutputKeys;
+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;
+
+public class XMLDocumentWriter {
+    
+    public void write(Document document, String fileName, boolean excludeDeclaration, boolean prettyPrint) {
+        try(FileWriter writer = new FileWriter(new File(fileName))) {
+            TransformerFactory transformerFactory = TransformerFactory.newInstance();
+            Transformer transformer = transformerFactory.newTransformer();
+            if(excludeDeclaration) {
+                transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");
+            }
+            if(prettyPrint) {
+                transformer.setOutputProperty(OutputKeys.INDENT, "yes");
+                transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
+            }
+            DOMSource source = new DOMSource(document);
+            StreamResult result = new StreamResult(writer);
+            transformer.transform(source, result);
+        } catch (IOException e) {
+            throw new IllegalArgumentException(e);
+        } catch (TransformerConfigurationException e) {
+            throw new IllegalStateException(e);
+        } catch (TransformerException e) {
+            throw new IllegalArgumentException(e);
+        }
+    }
+}

xml/src/main/java/com/baeldung/xml/attribute/Dom4jTransformer.java

@@ -0,0 +1,49 @@
+package com.baeldung.xml.attribute;
+
+import org.dom4j.*;
+import org.dom4j.io.DocumentSource;
+import org.dom4j.io.SAXReader;
+import org.xml.sax.SAXException;
+
+import javax.xml.XMLConstants;
+import javax.xml.transform.OutputKeys;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.stream.StreamResult;
+import java.io.StringWriter;
+import java.io.Writer;
+import java.util.List;
+
+public class Dom4jTransformer {
+    private final Document input;
+
+    public Dom4jTransformer(String resourcePath) throws DocumentException, SAXException {
+        // 1- Build the doc from the XML file
+        SAXReader xmlReader = new SAXReader();
+        xmlReader.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+        xmlReader.setFeature("http://xml.org/sax/features/external-general-entities", false);
+        xmlReader.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
+        this.input = xmlReader.read(resourcePath);
+    }
+
+    public String modifyAttribute(String attribute, String oldValue, String newValue) throws TransformerException {
+        // 2- Locate the node(s) with xpath, we can use index and iterator too.
+        String expr = String.format("//*[contains(@%s, '%s')]", attribute, oldValue);
+        XPath xpath = DocumentHelper.createXPath(expr);
+        List<Node> nodes = xpath.selectNodes(input);
+        // 3- Make the change on the selected nodes
+        for (int i = 0; i < nodes.size(); i++) {
+            Element element = (Element) nodes.get(i);
+            element.addAttribute(attribute, newValue);
+        }
+        // 4- Save the result to a new XML doc
+        TransformerFactory factory = TransformerFactory.newInstance();
+        factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
+        Transformer xformer = factory.newTransformer();
+        xformer.setOutputProperty(OutputKeys.INDENT, "yes");
+        Writer output = new StringWriter();
+        xformer.transform(new DocumentSource(input), new StreamResult(output));
+        return output.toString();
+    }
+}

xml/src/main/java/com/baeldung/xml/attribute/JaxpTransformer.java

@@ -0,0 +1,64 @@
+package com.baeldung.xml.attribute;
+
+import java.io.IOException;
+import java.io.StringWriter;
+import java.io.Writer;
+
+import javax.xml.XMLConstants;
+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.TransformerFactoryConfigurationError;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+import javax.xml.xpath.XPath;
+import javax.xml.xpath.XPathConstants;
+import javax.xml.xpath.XPathExpressionException;
+import javax.xml.xpath.XPathFactory;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.NodeList;
+import org.xml.sax.SAXException;
+
+public class JaxpTransformer {
+
+    private Document input;
+
+    public JaxpTransformer(String resourcePath) throws SAXException, IOException, ParserConfigurationException {
+        // 1- Build the doc from the XML file
+        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
+        factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
+        factory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+        this.input = factory.newDocumentBuilder()
+            .parse(resourcePath);
+    }
+
+    public String modifyAttribute(String attribute, String oldValue, String newValue) throws XPathExpressionException, TransformerFactoryConfigurationError, TransformerException {
+        // 2- Locate the node(s) with xpath
+        XPath xpath = XPathFactory.newInstance()
+            .newXPath();
+        NodeList nodes = (NodeList) xpath.evaluate(String.format("//*[contains(@%s, '%s')]", attribute, oldValue), this.input, XPathConstants.NODESET);
+        // 3- Make the change on the selected nodes
+        for (int i = 0; i < nodes.getLength(); i++) {
+            Element value = (Element) nodes.item(i);
+            value.setAttribute(attribute, newValue);
+        }
+        // Stream api syntax
+        // IntStream
+        // .range(0, nodes.getLength())
+        // .mapToObj(i -> (Element) nodes.item(i))
+        // .forEach(value -> value.setAttribute(attribute, newValue));
+        // 4- Save the result to a new XML doc
+        TransformerFactory factory = TransformerFactory.newInstance();
+        factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
+        Transformer xformer = factory.newTransformer();
+        xformer.setOutputProperty(OutputKeys.INDENT, "yes");
+        Writer output = new StringWriter();
+        xformer.transform(new DOMSource(this.input), new StreamResult(output));
+        return output.toString();
+    }
+}

xml/src/main/java/com/baeldung/xml/attribute/JooxTransformer.java

@@ -0,0 +1,38 @@
+package com.baeldung.xml.attribute;
+
+import org.joox.JOOX;
+import org.joox.Match;
+import org.w3c.dom.Document;
+import org.xml.sax.SAXException;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.transform.TransformerFactoryConfigurationError;
+import java.io.IOException;
+
+import static org.joox.JOOX.$;
+
+public class JooxTransformer {
+
+    private final Document input;
+
+    public JooxTransformer(String resourcePath) throws SAXException, IOException {
+        // 1- Build the doc from the XML file
+        DocumentBuilder builder = JOOX.builder();
+        input = builder.parse(resourcePath);
+    }
+
+    public String modifyAttribute(String attribute, String oldValue, String newValue) throws TransformerFactoryConfigurationError {
+        // 2- Select the document
+        Match $ = $(input);
+        // 3 - Find node to modify
+        String expr = String.format("//*[contains(@%s, '%s')]", attribute, oldValue);
+        $
+            // .find("to") or with xpath
+            .xpath(expr)
+            .get()
+            .stream()
+            .forEach(e -> e.setAttribute(attribute, newValue));
+        // 4- Return result as String
+        return $.toString();
+    }
+}

xml/src/main/java/com/baeldung/xml/attribute/jmh/AttributeBenchMark.java

@@ -0,0 +1,77 @@
+package com.baeldung.xml.attribute.jmh;
+
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.transform.TransformerException;
+import javax.xml.xpath.XPathExpressionException;
+
+import org.dom4j.DocumentException;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.runner.Runner;
+import org.openjdk.jmh.runner.RunnerException;
+import org.openjdk.jmh.runner.options.Options;
+import org.openjdk.jmh.runner.options.OptionsBuilder;
+import org.xml.sax.SAXException;
+
+import com.baeldung.xml.attribute.Dom4jTransformer;
+import com.baeldung.xml.attribute.JaxpTransformer;
+import com.baeldung.xml.attribute.JooxTransformer;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@State(Scope.Benchmark)
+public class AttributeBenchMark {
+
+    public static void main(String[] args) throws RunnerException {
+        Options opt = new OptionsBuilder().include(AttributeBenchMark.class.getSimpleName())
+            .forks(1)
+            .build();
+        new Runner(opt).run();
+    }
+
+    @Benchmark
+    public String dom4jBenchmark() throws DocumentException, TransformerException, SAXException {
+        String path = this.getClass()
+            .getResource("/xml/attribute.xml")
+            .toString();
+        Dom4jTransformer transformer = new Dom4jTransformer(path);
+        String attribute = "customer";
+        String oldValue = "true";
+        String newValue = "false";
+
+        return transformer.modifyAttribute(attribute, oldValue, newValue);
+    }
+
+    @Benchmark
+    public String jooxBenchmark() throws IOException, SAXException {
+        String path = this.getClass()
+            .getResource("/xml/attribute.xml")
+            .toString();
+        JooxTransformer transformer = new JooxTransformer(path);
+        String attribute = "customer";
+        String oldValue = "true";
+        String newValue = "false";
+
+        return transformer.modifyAttribute(attribute, oldValue, newValue);
+    }
+
+    @Benchmark
+    public String jaxpBenchmark() throws TransformerException, ParserConfigurationException, SAXException, IOException, XPathExpressionException {
+        String path = this.getClass()
+            .getResource("/xml/attribute.xml")
+            .toString();
+        JaxpTransformer transformer = new JaxpTransformer(path);
+        String attribute = "customer";
+        String oldValue = "true";
+        String newValue = "false";
+
+        return transformer.modifyAttribute(attribute, oldValue, newValue);
+    }
+}

xml/src/main/java/com/baeldung/xml/binding/Tutorial.java

@@ -0,0 +1,68 @@
+package com.baeldung.xml.binding;
+
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlElement;
+
+public class Tutorial {
+
+    private String tutId;
+    private String type;
+    private String title;
+    private String description;
+    private String date;
+    private String author;
+
+    public String getTutId() {
+        return tutId;
+    }
+
+    @XmlAttribute
+    public void setTutId(String tutId) {
+        this.tutId = tutId;
+    }
+
+    public String getType() {
+        return type;
+    }
+
+    @XmlAttribute
+    public void setType(String type) {
+        this.type = type;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    @XmlElement
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    @XmlElement
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    public String getDate() {
+        return date;
+    }
+
+    @XmlElement
+    public void setDate(String date) {
+        this.date = date;
+    }
+
+    public String getAuthor() {
+        return author;
+    }
+
+    @XmlElement
+    public void setAuthor(String author) {
+        this.author = author;
+    }
+}

xml/src/main/java/com/baeldung/xml/binding/Tutorials.java

@@ -0,0 +1,22 @@
+package com.baeldung.xml.binding;
+
+import java.util.List;
+
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlRootElement;
+
+@XmlRootElement
+public class Tutorials {
+
+    private List<Tutorial> tutorial;
+
+    public List<Tutorial> getTutorial() {
+        return tutorial;
+    }
+
+    @XmlElement
+    public void setTutorial(List<Tutorial> tutorial) {
+        this.tutorial = tutorial;
+    }
+
+}

xml/src/main/java/com/baeldung/xml/jibx/Customer.java

@@ -0,0 +1,53 @@
+/*
+ * Customer.java     06.06.2008
+ *
+ * Copyright 2008 Stefan Jäger
+ *
+ */
+package com.baeldung.xml.jibx;
+
+import org.apache.commons.lang.builder.ToStringBuilder;
+
+public class Customer {
+	private Person person;
+	private String city;
+
+	private Phone homePhone;
+	private Phone officePhone;
+
+	public Person getPerson() {
+		return person;
+	}
+
+	public void setPerson(Person person) {
+		this.person = person;
+	}
+
+	public String getCity() {
+		return city;
+	}
+
+	public void setCity(String city) {
+		this.city = city;
+	}
+
+	public Phone getHomePhone() {
+		return homePhone;
+	}
+
+	public void setHomePhone(Phone homePhone) {
+		this.homePhone = homePhone;
+	}
+
+	public Phone getOfficePhone() {
+		return officePhone;
+	}
+
+	public void setOfficePhone(Phone officePhone) {
+		this.officePhone = officePhone;
+	}
+
+	public String toString() {
+		return ToStringBuilder.reflectionToString(this);
+	}
+}

xml/src/main/java/com/baeldung/xml/jibx/Identity.java

@@ -0,0 +1,14 @@
+package com.baeldung.xml.jibx;
+
+public class Identity {
+
+	long customerId;
+
+	public long getCustomerId() {
+		return customerId;
+	}
+
+	public void setCustomerId(long customerId) {
+		this.customerId = customerId;
+	}
+}

xml/src/main/java/com/baeldung/xml/jibx/Person.java

@@ -0,0 +1,25 @@
+/*
+ * Person.java     06.06.2008
+ *
+ * Copyright 2008 Stefan Jäger
+ *
+ */
+package com.baeldung.xml.jibx;
+
+import org.apache.commons.lang.builder.ToStringBuilder;
+
+public class Person extends Identity {
+	private String name;
+
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	public String toString() {
+		return ToStringBuilder.reflectionToString(this);
+	}
+}

xml/src/main/java/com/baeldung/xml/jibx/Phone.java

@@ -0,0 +1,14 @@
+package com.baeldung.xml.jibx;
+
+public class Phone {
+
+	private String number;
+
+	public String getNumber() {
+		return number;
+	}
+
+	public void setNumber(String number) {
+		this.number = number;
+	}
+}

xml/src/main/java/com/baeldung/xml/stax/StaxParser.java

@@ -0,0 +1,74 @@
+package com.baeldung.xml.stax;
+
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.util.List;
+import java.util.ArrayList;
+
+import javax.xml.stream.events.XMLEvent;
+import javax.xml.stream.XMLEventReader;
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.events.Attribute;
+import javax.xml.stream.events.EndElement;
+import javax.xml.stream.events.StartElement;
+import javax.xml.namespace.QName;
+
+public class StaxParser {
+
+    public static List<WebSite> parse(String path) {
+        List<WebSite> websites = new ArrayList<WebSite>();
+        WebSite website = null;
+        XMLInputFactory xmlInputFactory = XMLInputFactory.newInstance();
+        try {
+            XMLEventReader reader = xmlInputFactory.createXMLEventReader(new FileInputStream(path));
+            while (reader.hasNext()) {
+                XMLEvent nextEvent = reader.nextEvent();
+                if (nextEvent.isStartElement()) {
+                    StartElement startElement = nextEvent.asStartElement();
+                    switch (startElement.getName()
+                        .getLocalPart()) {
+                    case "website":
+                        website = new WebSite();
+                        Attribute url = startElement.getAttributeByName(new QName("url"));
+                        if (url != null) {
+                            website.setUrl(url.getValue());
+                        }
+                        break;
+                    case "name":
+                        nextEvent = reader.nextEvent();
+                        website.setName(nextEvent.asCharacters()
+                            .getData());
+                        break;
+                    case "category":
+                        nextEvent = reader.nextEvent();
+                        website.setCategory(nextEvent.asCharacters()
+                            .getData());
+                        break;
+                    case "status":
+                        nextEvent = reader.nextEvent();
+                        website.setStatus(nextEvent.asCharacters()
+                            .getData());
+                        break;
+                    }
+                }
+                if (nextEvent.isEndElement()) {
+                    EndElement endElement = nextEvent.asEndElement();
+                    if (endElement.getName()
+                        .getLocalPart()
+                        .equals("website")) {
+                        websites.add(website);
+                    }
+                }
+            }
+        } catch (XMLStreamException xse) {
+            System.out.println("XMLStreamException");
+            xse.printStackTrace();
+        } catch (FileNotFoundException fnfe) {
+            System.out.println("FileNotFoundException");
+            fnfe.printStackTrace();
+        }
+        return websites;
+    }
+
+}

xml/src/main/java/com/baeldung/xml/stax/WebSite.java

@@ -0,0 +1,40 @@
+package com.baeldung.xml.stax;
+public class WebSite {
+
+    private String url;
+    private String name;
+    private String category;
+    private String status;
+
+    public String getUrl() {
+        return url;
+    }
+
+    public void setUrl(String url) {
+        this.url = url;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getCategory() {
+        return category;
+    }
+
+    public void setCategory(String category) {
+        this.category = category;
+    }
+
+    public String getStatus() {
+        return status;
+    }
+
+    public void setStatus(String status) {
+        this.status = status;
+    }
+}

xml/src/main/java/com/baeldung/xmlhtml/Application.java

@@ -0,0 +1,10 @@
+package com.baeldung.xmlhtml;
+
+import com.baeldung.xmlhtml.helpers.XMLRunner;
+
+public class Application {
+
+    public static void main(String[] args) {
+        XMLRunner.doWork();
+    }
+}

xml/src/main/java/com/baeldung/xmlhtml/Constants.java

@@ -0,0 +1,22 @@
+package com.baeldung.xmlhtml;
+
+public class Constants {
+
+    public static final String XML_FILE_IN = "src/main/resources/xml/in.xml";
+    public static final String JAXB_FILE_OUT = "src/main/resources/xml/jaxb.html";
+    public static final String JAXP_FILE_OUT = "src/main/resources/xml/jaxp.html";
+    public static final String STAX_FILE_OUT = "src/main/resources/xml/stax.html";
+
+    public static final String EXCEPTION_ENCOUNTERED = "Generic exception! Error: ";
+
+    public static final String LINE_BREAK = System.getProperty("line.separator");
+    public static final String WHITE_SPACE = " ";
+
+    public static final String DOCUMENT_START = "Document parsing has begun!";
+    public static final String DOCUMENT_END = "Document parsing has ended!";
+    public static final String ELEMENT_START = "Element parsing has begun!";
+    public static final String ELEMENT_END = "Element parsing has ended!";
+
+    public static final String BREAK = "\n";
+    public static final String TAB = "\t";
+}

xml/src/main/java/com/baeldung/xmlhtml/freemarker/FreemarkerTransformer.java

@@ -0,0 +1,41 @@
+package com.baeldung.xmlhtml.freemarker;
+
+import com.baeldung.xmlhtml.stax.StaxTransformer;
+import freemarker.template.Configuration;
+import freemarker.template.Template;
+import freemarker.template.TemplateException;
+import freemarker.template.TemplateExceptionHandler;
+
+import javax.xml.stream.XMLStreamException;
+import java.io.File;
+import java.io.IOException;
+import java.io.StringWriter;
+import java.io.Writer;
+import java.nio.charset.StandardCharsets;
+
+public class FreemarkerTransformer {
+    private StaxTransformer staxTransformer;
+    private String templateDirectory;
+    private String templateFile;
+
+    public FreemarkerTransformer(StaxTransformer staxTransformer, String templateDirectory, String templateFile) {
+        this.staxTransformer = staxTransformer;
+        this.templateDirectory = templateDirectory;
+        this.templateFile = templateFile;
+    }
+
+    public String html() throws IOException, TemplateException {
+        Configuration cfg = new Configuration(Configuration.VERSION_2_3_29);
+        cfg.setDirectoryForTemplateLoading(new File(templateDirectory));
+        cfg.setDefaultEncoding(StandardCharsets.UTF_8.toString());
+        cfg.setTemplateExceptionHandler(TemplateExceptionHandler.RETHROW_HANDLER);
+        cfg.setLogTemplateExceptions(false);
+        cfg.setWrapUncheckedExceptions(true);
+        cfg.setFallbackOnNullLoopVariable(false);
+        Template temp = cfg.getTemplate(templateFile);
+        try (Writer output = new StringWriter()) {
+            temp.process(staxTransformer.getMap(), output);
+            return output.toString();
+        }
+    }
+}

xml/src/main/java/com/baeldung/xmlhtml/helpers/XMLRunner.java

@@ -0,0 +1,12 @@
+package com.baeldung.xmlhtml.helpers;
+
+
+import com.baeldung.xmlhtml.helpers.jaxb.JAXBHelper;
+import com.baeldung.xmlhtml.stax.StaxTransformer;
+
+public class XMLRunner {
+
+    public static void doWork() {
+        JAXBHelper.example();
+    }
+}

xml/src/main/java/com/baeldung/xmlhtml/helpers/jaxb/JAXBHelper.java

@@ -0,0 +1,77 @@
+package com.baeldung.xmlhtml.helpers.jaxb;
+
+import com.baeldung.xmlhtml.pojo.jaxb.html.ExampleHTML;
+import com.baeldung.xmlhtml.pojo.jaxb.html.elements.Body;
+import com.baeldung.xmlhtml.pojo.jaxb.html.elements.CustomElement;
+import com.baeldung.xmlhtml.pojo.jaxb.html.elements.Meta;
+import com.baeldung.xmlhtml.pojo.jaxb.html.elements.NestedElement;
+import com.baeldung.xmlhtml.pojo.jaxb.xml.XMLExample;
+
+import javax.xml.bind.JAXBContext;
+import javax.xml.bind.Marshaller;
+import javax.xml.bind.Unmarshaller;
+
+import java.io.File;
+
+import static com.baeldung.xmlhtml.Constants.*;
+
+public class JAXBHelper {
+
+    private static void print(String xmlContent) {
+        System.out.println(xmlContent);
+    }
+
+    private static Unmarshaller getContextUnmarshaller(Class clazz) {
+        Unmarshaller unmarshaller = null;
+        try {
+            JAXBContext context = JAXBContext.newInstance(clazz);
+            unmarshaller = context.createUnmarshaller();
+        } catch (Exception ex) {
+            System.out.println(EXCEPTION_ENCOUNTERED + ex);
+        }
+        return unmarshaller;
+    }
+
+    private static Marshaller getContextMarshaller(Class clazz) {
+        Marshaller marshaller = null;
+        try {
+            JAXBContext context = JAXBContext.newInstance(clazz);
+            marshaller = context.createMarshaller();
+            marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
+            marshaller.setProperty("jaxb.fragment", Boolean.TRUE);
+        } catch (Exception ex) {
+            System.out.println(EXCEPTION_ENCOUNTERED + ex);
+        }
+        return marshaller;
+    }
+
+    public static void example() {
+        try {
+            XMLExample xml = (XMLExample) JAXBHelper.getContextUnmarshaller(XMLExample.class).unmarshal(new File(XML_FILE_IN));
+            JAXBHelper.print(xml.toString());
+            ExampleHTML html = new ExampleHTML();
+
+            Body body = new Body();
+            CustomElement customElement = new CustomElement();
+            NestedElement nested = new NestedElement();
+            CustomElement child = new CustomElement();
+
+            customElement.setValue("descendantOne: " + xml.getAncestor().getDescendantOne().getValue());
+            child.setValue("descendantThree: " + xml.getAncestor().getDescendantTwo().getDescendantThree().getValue());
+            nested.setCustomElement(child);
+
+            body.setCustomElement(customElement);
+            body.setNestedElement(nested);
+
+            Meta meta = new Meta();
+            meta.setTitle("example");
+            html.getHead().add(meta);
+            html.setBody(body);
+
+            JAXBHelper.getContextMarshaller(ExampleHTML.class).marshal(html, new File(JAXB_FILE_OUT));
+
+        } catch (Exception ex) {
+            System.out.println(EXCEPTION_ENCOUNTERED + ex);
+        }
+    }
+}

xml/src/main/java/com/baeldung/xmlhtml/jaxp/JaxpTransformer.java

@@ -0,0 +1,103 @@
+package com.baeldung.xmlhtml.jaxp;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.xml.sax.SAXException;
+
+import javax.xml.XMLConstants;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+import java.io.IOException;
+import java.io.StringWriter;
+import java.io.Writer;
+import java.util.HashMap;
+import java.util.Map;
+
+public class JaxpTransformer {
+
+    private Document input;
+    private DocumentBuilderFactory factory;
+
+    public JaxpTransformer(String resourcePath) throws ParserConfigurationException, IOException, SAXException {
+        // 1- Build the doc from the XML file
+        factory = DocumentBuilderFactory.newInstance();
+        factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
+        factory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+        input = factory
+          .newDocumentBuilder()
+          .parse(resourcePath);
+    }
+
+    public String html() throws ParserConfigurationException, TransformerException, IOException {
+        Element xml = input.getDocumentElement();
+        Document doc = factory
+          .newDocumentBuilder()
+          .newDocument();
+        //Build Map
+        Map<String, String> map = buildMap(xml);
+        //Head
+        Element html = doc.createElement("html");
+        html.setAttribute("lang", "en");
+        Element head = buildHead(map, doc);
+        html.appendChild(head);
+        //Body
+        Element body = buildBody(map, doc);
+        html.appendChild(body);
+        doc.appendChild(html);
+        return String.format("<!DOCTYPE html>%n%s", applyTransformation(doc));
+    }
+
+    private String applyTransformation(Document doc) throws TransformerException, IOException {
+        TransformerFactory transformerFactory = TransformerFactory.newInstance();
+        transformerFactory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
+        transformerFactory.setAttribute(XMLConstants.ACCESS_EXTERNAL_DTD, "");
+        transformerFactory.setAttribute(XMLConstants.ACCESS_EXTERNAL_STYLESHEET, "");
+        try (Writer output = new StringWriter()) {
+            Transformer transformer = transformerFactory.newTransformer();
+            transformer.transform(new DOMSource(doc), new StreamResult(output));
+            return output.toString();
+        }
+    }
+
+    private Map<String, String> buildMap(Element xml) {
+        Map<String, String> map = new HashMap<>();
+        map.put("heading", xml
+          .getElementsByTagName("heading")
+          .item(0)
+          .getTextContent());
+        map.put("from", String.format("from: %s", xml
+          .getElementsByTagName("from")
+          .item(0)
+          .getTextContent()));
+        map.put("content", xml
+          .getElementsByTagName("content")
+          .item(0)
+          .getTextContent());
+        return map;
+    }
+
+    private Element buildHead(Map<String, String> map, Document doc) {
+        Element head = doc.createElement("head");
+        Element title = doc.createElement("title");
+        title.setTextContent(map.get("heading"));
+        head.appendChild(title);
+        return head;
+    }
+
+    private Element buildBody(Map<String, String> map, Document doc) {
+        Element body = doc.createElement("body");
+        Element from = doc.createElement("p");
+        from.setTextContent(map.get("from"));
+        Element success = doc.createElement("p");
+        success.setTextContent(map.get("content"));
+        body.appendChild(from);
+        body.appendChild(success);
+        return body;
+    }
+
+}

xml/src/main/java/com/baeldung/xmlhtml/mustache/MustacheTransformer.java

@@ -0,0 +1,31 @@
+package com.baeldung.xmlhtml.mustache;
+
+import com.baeldung.xmlhtml.stax.StaxTransformer;
+import com.github.mustachejava.DefaultMustacheFactory;
+import com.github.mustachejava.Mustache;
+import com.github.mustachejava.MustacheFactory;
+
+import javax.xml.stream.XMLStreamException;
+import java.io.IOException;
+import java.io.StringWriter;
+import java.io.Writer;
+
+public class MustacheTransformer {
+    private StaxTransformer staxTransformer;
+    private String templateFile;
+
+    public MustacheTransformer(StaxTransformer staxTransformer, String templateFile) {
+        this.staxTransformer = staxTransformer;
+        this.templateFile = templateFile;
+    }
+
+    public String html() throws IOException {
+        MustacheFactory mf = new DefaultMustacheFactory();
+        Mustache mustache = mf.compile(templateFile);
+        try (Writer output = new StringWriter()) {
+            mustache.execute(output, staxTransformer.getMap());
+            output.flush();
+            return output.toString();
+        }
+    }
+}

xml/src/main/java/com/baeldung/xmlhtml/pojo/jaxb/html/ExampleHTML.java

@@ -0,0 +1,38 @@
+package com.baeldung.xmlhtml.pojo.jaxb.html;
+
+import com.baeldung.xmlhtml.pojo.jaxb.html.elements.Body;
+import com.baeldung.xmlhtml.pojo.jaxb.html.elements.Meta;
+
+import javax.xml.bind.annotation.*;
+import java.util.ArrayList;
+import java.util.List;
+
+@XmlType(propOrder = {"head", "body"})
+@XmlRootElement(name = "html")
+public class ExampleHTML {
+
+    private List<Meta> head = new ArrayList<>();
+
+    private Body body;
+
+    public ExampleHTML() { }
+
+    public List<Meta> getHead() {
+        return head;
+    }
+
+    @XmlElementWrapper(name = "head")
+    @XmlElement(name = "meta")
+    public void setHead(List<Meta> head) {
+        this.head = head;
+    }
+
+    public Body getBody() {
+        return body;
+    }
+
+    @XmlElement(name = "body")
+    public void setBody(Body body) {
+        this.body = body;
+    }
+}

xml/src/main/java/com/baeldung/xmlhtml/pojo/jaxb/html/elements/Body.java

@@ -0,0 +1,29 @@
+package com.baeldung.xmlhtml.pojo.jaxb.html.elements;
+
+import javax.xml.bind.annotation.XmlElement;
+
+public class Body {
+
+    private CustomElement customElement;
+
+    public CustomElement getCustomElement() {
+        return customElement;
+    }
+
+    @XmlElement(name = "p")
+    public void setCustomElement(CustomElement customElement) {
+        this.customElement = customElement;
+    }
+
+    private NestedElement nestedElement;
+
+    public NestedElement getNestedElement() {
+        return nestedElement;
+    }
+
+    @XmlElement(name = "div")
+    public void setNestedElement(NestedElement nestedElement) {
+        this.nestedElement = nestedElement;
+    }
+
+}

xml/src/main/java/com/baeldung/xmlhtml/pojo/jaxb/html/elements/CustomElement.java

@@ -0,0 +1,18 @@
+package com.baeldung.xmlhtml.pojo.jaxb.html.elements;
+
+import javax.xml.bind.annotation.XmlValue;
+
+public class CustomElement {
+
+    private String value;
+
+    @XmlValue
+    public String getValue() {
+        return value;
+    }
+
+    public void setValue(String value) {
+        this.value = value;
+    }
+
+}

xml/src/main/java/com/baeldung/xmlhtml/pojo/jaxb/html/elements/Meta.java

@@ -0,0 +1,30 @@
+package com.baeldung.xmlhtml.pojo.jaxb.html.elements;
+
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlValue;
+
+public class Meta {
+
+    private String title;
+
+    public String getTitle() {
+        return title;
+    }
+
+    @XmlAttribute(name = "title")
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+    private String value;
+
+    @XmlValue
+    public String getValue() {
+        return value;
+    }
+
+    public void setValue(String value) {
+        this.value = value;
+    }
+
+}

xml/src/main/java/com/baeldung/xmlhtml/pojo/jaxb/html/elements/NestedElement.java

@@ -0,0 +1,17 @@
+package com.baeldung.xmlhtml.pojo.jaxb.html.elements;
+
+import javax.xml.bind.annotation.XmlElement;
+
+public class NestedElement {
+
+    private CustomElement customElement;
+
+    public CustomElement getCustomElement() {
+        return customElement;
+    }
+
+    @XmlElement(name = "p")
+    public void setCustomElement(CustomElement customElement) {
+        this.customElement = customElement;
+    }
+}

xml/src/main/java/com/baeldung/xmlhtml/pojo/jaxb/xml/XMLExample.java

@@ -0,0 +1,21 @@
+package com.baeldung.xmlhtml.pojo.jaxb.xml;
+
+import com.baeldung.xmlhtml.pojo.jaxb.xml.elements.Ancestor;
+
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlRootElement;
+
+@XmlRootElement(name = "xmlexample")
+public class XMLExample {
+
+    private Ancestor ancestor;
+
+    @XmlElement(name = "ancestor")
+    public void setAncestor(Ancestor ancestor) {
+        this.ancestor = ancestor;
+    }
+
+    public Ancestor getAncestor() {
+        return ancestor;
+    }
+}

xml/src/main/java/com/baeldung/xmlhtml/pojo/jaxb/xml/elements/Ancestor.java

@@ -0,0 +1,28 @@
+package com.baeldung.xmlhtml.pojo.jaxb.xml.elements;
+
+import javax.xml.bind.annotation.XmlElement;
+
+public class Ancestor {
+
+    private DescendantOne descendantOne;
+    private DescendantTwo descendantTwo;
+
+    public DescendantOne getDescendantOne() {
+        return descendantOne;
+    }
+
+    @XmlElement(name = "descendantOne")
+    public void setDescendantOne(DescendantOne descendantOne) {
+        this.descendantOne = descendantOne;
+    }
+
+    public DescendantTwo getDescendantTwo() {
+        return descendantTwo;
+    }
+
+    @XmlElement(name = "descendantTwo")
+    public void setDescendantTwo(DescendantTwo descendantTwo) {
+        this.descendantTwo = descendantTwo;
+    }
+}
+

xml/src/main/java/com/baeldung/xmlhtml/pojo/jaxb/xml/elements/DescendantOne.java

@@ -0,0 +1,19 @@
+package com.baeldung.xmlhtml.pojo.jaxb.xml.elements;
+
+import javax.xml.bind.annotation.XmlValue;
+
+public class DescendantOne {
+
+    private String value;
+
+    @XmlValue
+    public String getValue() {
+        return value;
+    }
+
+    public void setValue(String value) {
+        this.value = value;
+    }
+
+}
+

xml/src/main/java/com/baeldung/xmlhtml/pojo/jaxb/xml/elements/DescendantThree.java

@@ -0,0 +1,18 @@
+package com.baeldung.xmlhtml.pojo.jaxb.xml.elements;
+
+import javax.xml.bind.annotation.XmlValue;
+
+public class DescendantThree {
+
+    private String value;
+
+    @XmlValue
+    public String getValue() {
+        return value;
+    }
+
+    public void setValue(String value) {
+        this.value = value;
+    }
+
+}

xml/src/main/java/com/baeldung/xmlhtml/pojo/jaxb/xml/elements/DescendantTwo.java

@@ -0,0 +1,17 @@
+package com.baeldung.xmlhtml.pojo.jaxb.xml.elements;
+
+import javax.xml.bind.annotation.XmlElement;
+
+public class DescendantTwo {
+
+    private DescendantThree descendantThree;
+
+    public DescendantThree getDescendantThree() {
+        return descendantThree;
+    }
+
+    @XmlElement(name = "descendantThree")
+    public void setDescendant(DescendantThree descendantThree) {
+        this.descendantThree = descendantThree;
+    }
+}

xml/src/main/java/com/baeldung/xmlhtml/stax/StaxTransformer.java

@@ -0,0 +1,99 @@
+package com.baeldung.xmlhtml.stax;
+
+import javax.xml.stream.*;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.StringWriter;
+import java.io.Writer;
+import java.util.HashMap;
+import java.util.Map;
+
+public class StaxTransformer {
+
+    private Map<String, String> map;
+
+    public StaxTransformer(String resourcePath) throws IOException, XMLStreamException {
+        XMLInputFactory factory = XMLInputFactory.newInstance();
+        factory.setProperty(XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES, Boolean.FALSE);
+        factory.setProperty(XMLInputFactory.SUPPORT_DTD, Boolean.FALSE);
+        XMLStreamReader input = null;
+        try (FileInputStream file = new FileInputStream(resourcePath)) {
+            input = factory.createXMLStreamReader(file);
+            map = buildMap(input);
+        } finally {
+            if (input != null) {
+                input.close();
+            }
+        }
+    }
+
+    public String html() throws XMLStreamException, IOException {
+        try (Writer output = new StringWriter()) {
+            XMLStreamWriter writer = XMLOutputFactory
+              .newInstance()
+              .createXMLStreamWriter(output);
+            //Head
+            writer.writeDTD("<!DOCTYPE html>");
+            writer.writeCharacters(String.format("%n"));
+            writer.writeStartElement("html");
+            writer.writeAttribute("lang", "en");
+            writer.writeCharacters(String.format("%n"));
+            writer.writeStartElement("head");
+            writer.writeCharacters(String.format("%n"));
+            writer.writeDTD("<META http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\">");
+            writer.writeCharacters(String.format("%n"));
+            writer.writeStartElement("title");
+            writer.writeCharacters(map.get("heading"));
+            writer.writeEndElement();
+            writer.writeCharacters(String.format("%n"));
+            writer.writeEndElement();
+            writer.writeCharacters(String.format("%n"));
+            //Body
+            writer.writeStartElement("body");
+            writer.writeCharacters(String.format("%n"));
+            writer.writeStartElement("p");
+            writer.writeCharacters(map.get("from"));
+            writer.writeEndElement();
+            writer.writeCharacters(String.format("%n"));
+            writer.writeStartElement("p");
+            writer.writeCharacters(map.get("content"));
+            writer.writeEndElement();
+            writer.writeCharacters(String.format("%n"));
+            writer.writeEndElement();
+            writer.writeCharacters(String.format("%n"));
+            writer.writeEndDocument();
+            writer.writeCharacters(String.format("%n"));
+            writer.flush();
+            return output.toString();
+        }
+    }
+
+    private Map<String, String> buildMap(XMLStreamReader input) throws XMLStreamException {
+        Map<String, String> tempMap = new HashMap<>();
+        while (input.hasNext()) {
+            input.next();
+            if (input.isStartElement()) {
+                if (input
+                  .getLocalName()
+                  .equals("heading")) {
+                    tempMap.put("heading", input.getElementText());
+                }
+                if (input
+                  .getLocalName()
+                  .equals("from")) {
+                    tempMap.put("from", String.format("from: %s", input.getElementText()));
+                }
+                if (input
+                  .getLocalName()
+                  .equals("content")) {
+                    tempMap.put("content", input.getElementText());
+                }
+            }
+        }
+        return tempMap;
+    }
+
+    public Map<String, String> getMap() {
+        return map;
+    }
+}

xml/src/main/resources/Order.xsd

@@ -0,0 +1,21 @@
+<xs:schema attributeFormDefault="unqualified"
+	elementFormDefault="qualified" targetNamespace="http://www.jibx.xml.baeldung.com/"
+	xmlns:xs="http://www.w3.org/2001/XMLSchema">
+	<xs:element name="Order">
+		<xs:complexType>
+			<xs:sequence>
+				<xs:element name="Address" maxOccurs="unbounded"
+					minOccurs="0">
+					<xs:complexType>
+						<xs:sequence>
+							<xs:element type="xs:string" name="Name" />
+						</xs:sequence>
+						<xs:attribute type="xs:string" name="Type" use="optional" />
+					</xs:complexType>
+				</xs:element>
+			</xs:sequence>
+			<xs:attribute type="xs:int" name="OrderNumber" />
+			<xs:attribute type="xs:date" name="OrderDate" />
+		</xs:complexType>
+	</xs:element>
+</xs:schema>

xml/src/main/resources/customer-binding.xml

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<binding>
+	<mapping class="com.baeldung.xml.jibx.Identity" abstract="true">
+		<value name="customer-id" field="customerId" />
+	</mapping>
+
+	<mapping name="customer" class="com.baeldung.xml.jibx.Customer">
+		<structure field="person" />
+		<structure name="home-phone" field="homePhone" usage="optional" />
+		<structure name="office-phone" field="officePhone" usage="optional" />
+		<value name="city" field="city" />
+	</mapping>
+
+	<mapping name="person" class="com.baeldung.xml.jibx.Person"
+		extends="com.baeldung.xml.jibx.Identity">
+		<structure map-as="com.baeldung.xml.jibx.Identity" />
+		<value name="name" field="name" />
+
+	</mapping>
+
+	<mapping class="com.baeldung.xml.jibx.Phone" abstract="true">
+		<value name="number" field="number" />
+	</mapping>
+
+
+</binding>

xml/src/main/resources/logback.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
+            </pattern>
+        </encoder>
+    </appender>
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+</configuration>

xml/src/main/resources/sax/baeldung.xml

@@ -0,0 +1,16 @@
+<baeldung>
+    <articles>
+        <article>
+            <title>Parsing an XML File Using SAX Parser</title>
+            <content>SAX Parser's Lorem ipsum...</content>
+        </article>
+        <article>
+            <title>Parsing an XML File Using DOM Parser</title>
+            <content>DOM Parser's Lorem ipsum...</content>
+        </article>
+        <article>
+            <title>Parsing an XML File Using StAX Parser</title>
+            <content>StAX Parser's Lorem ipsum...</content>
+        </article>
+    </articles>
+</baeldung>

xml/src/main/resources/xml/attribute.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<notification id="5">
+    <to customer="true">john@email.com</to>
+    <from>mary@email.com</from>
+</notification>

xml/src/main/resources/xml/attribute_expected.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<notification id="5">
+    <to customer="false">john@email.com</to>
+    <from>mary@email.com</from>
+</notification>

xml/src/main/resources/xml/in.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<xmlexample>
+<ancestor>
+    <descendantOne>Yo</descendantOne>
+    <descendantTwo>
+        <descendantThree>
+            DustyOrb
+        </descendantThree>
+    </descendantTwo>
+</ancestor>
+</xmlexample>

xml/src/main/resources/xml/jaxb.html

@@ -0,0 +1,14 @@
+
+<html>
+    <head>
+        <meta title="example"/>
+    </head>
+    <body>
+        <p>descendantOne: Yo</p>
+        <div>
+            <p>descendantThree: 
+            DustyOrb
+        </p>
+        </div>
+    </body>
+</html>

xml/src/main/resources/xml/jaxp.html

@@ -0,0 +1,13 @@
+<html>
+<head>
+<META http-equiv="Content-Type" content="text/html; charset=UTF-8">
+</head>
+<body>
+<p>descendantOne: Yo</p>
+<div>
+<p>descendantThree: 
+            DustyOrb
+        </p>
+</div>
+</body>
+</html>

xml/src/main/resources/xml/stax.html

@@ -0,0 +1,15 @@
+<html>
+	<head>
+		<meta></meta>
+	</head>
+	<body>
+		<p>descendantOne: Yo</p>
+		<div>
+			<p>
+				descendantThree: 
+            DustyOrb
+        
+			</p>
+		</div>
+	</body>
+</html>