写入和解析 XML 文档

版权声明：如果喜欢的话，可以撩我哟，此处没有联系方式，想要就自己找哈。 https://blog.csdn.net/qq_39384184/article/details/84940054

待测试的 Java 对象

• RootElement：

import javax.xml.bind.annotation.XmlRootElement;

/**
 * Unmarshaller的文档根元素
 */
@XmlRootElement
public class RootElement {
    private long val1;
    private double val2;
    private SubElement val3;

    public RootElement() {
        super();
    }

    public long getVal1() {
        return val1;
    }

    public void setVal1(long val1) {
        this.val1 = val1;
    }

    public double getVal2() {
        return val2;
    }

    public void setVal2(double val2) {
        this.val2 = val2;
    }

    public SubElement getVal3() {
        return val3;
    }

    public void setVal3(SubElement val3) {
        this.val3 = val3;
    }
}

• SubElement:

public class SubElement {
    private int subval1;
    private String subval2;

    public SubElement() {
        super();
    }

    public int getSubval1() {
        return subval1;
    }

    public void setSubval1(int subval1) {
        this.subval1 = subval1;
    }

    public String getSubval2() {
        return subval2;
    }

    public void setSubval2(String subval2) {
        this.subval2 = subval2;
    }
}

JDK 自带的 Marshaller 和 Unmarshaller

使用 JAXBContext 创建 Marshaller 对象和 Unmarshaller 对象。

• 使用 Marshaller 对象完成 JavaBean 到 XML 文档的转换，会写入空行。

• 使用 Unmarshaller 对象完成 XML 文档到 JavaBean 的转换，空行无影响。

• Marshaller+Unmarshaller：

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;
import java.io.*;

/**
 * 使用jdk自带类Marshaller Unmarshaller 类使客户端应用程序能够将 XML 数据转换为 Java
 * 内容对象树。 Marshaller 类使客户端应用程序能够将 Java 内容树转换回 XML 数据。
 */
public class XmlJDKDemo {
    public static void main(String[] args) {
        XmlJDKDemo demo = new XmlJDKDemo();
        try {
            demo.run();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void run() throws IOException {
        StringBuffer xmlBuffer = new StringBuffer();
        // Javabean to Xml
        try {
            RootElement root = new RootElement();
            root.setVal1(1000000000000000000l);
            root.setVal2(1.00000000000000001d);
            SubElement sub = new SubElement();
            sub.setSubval1(1000);
            sub.setSubval2("aaaaaaaaaaa");
            root.setVal3(sub);

//            JavaBean 转 XML
            JAXBContext context = JAXBContext.newInstance(RootElement.class);
            Marshaller marshaller = context.createMarshaller();
            File xmlFile = new File("XML/src/marshaller.xml");
            marshaller.marshal(root, xmlFile);

            BufferedReader reader = new BufferedReader(new InputStreamReader(
                    new FileInputStream(xmlFile)));
            String line;
            while ((line = reader.readLine()) != null) {
                xmlBuffer.append(line);
            }
            reader.close();
            System.out.println(xmlBuffer.toString());
        } catch (JAXBException e) {
            e.printStackTrace();
        }
        System.out.println("=================================");
        try {
//            XML to JavaBean
            JAXBContext context = JAXBContext.newInstance(RootElement.class);
            Unmarshaller unmarshaller = context.createUnmarshaller();
            RootElement root = (RootElement) unmarshaller
                    .unmarshal(new StringReader(xmlBuffer.toString()));
            System.out.println(root.getVal1());
            System.out.println(root.getVal2());
            System.out.println(root.getVal3().getSubval1());
            System.out.println(root.getVal3().getSubval2());
        } catch (JAXBException e) {
            e.printStackTrace();
        }
    }
}

DOM （基于 XML 文档树结构的解析）

使用 org.w3c.dom.Document 对象完成 XML 文档的写入和解析。

• 写入 XML 文档：创建 Document 对象，由 Transformer 将 DOMSource 转化为 StreamResult，会写入空行。

• 解析 XML 文档：DocumentBuilderFactory 创建 DocumentBuilder，DocumentBuilder.parse(filename)，会解析空行。

• DOM：

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

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.*;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintWriter;

/**
 * dom解析xml文件
 */
public class DomDemo {
    public Document document;
    public String fileName;

    public static void main(String[] args) {
        DomDemo demo = new DomDemo();
        demo.init();
        demo.fileName = "XML/src/dom.xml";
        demo.createXml(demo.fileName);
        demo.parserXml(demo.fileName);
    }

    public void init() {
        try {
            DocumentBuilderFactory factory = DocumentBuilderFactory
                    .newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();
            this.document = builder.newDocument();
        } catch (ParserConfigurationException e) {
            System.out.println(e.getMessage());
        }
    }

    public void createXml(String fileName) {
        Element root = this.document.createElement("RootElement");
        this.document.appendChild(root);
        Element val1 = this.document.createElement("val1");
        val1.appendChild(this.document.createTextNode("100000000000000"));
        root.appendChild(val1);
        Element val2 = this.document.createElement("val2");
        val2.appendChild(this.document.createTextNode("1.0000001"));
        root.appendChild(val2);
        Element subElement = this.document.createElement("SubElement");
        Element subval1 = this.document.createElement("subval1");
        subval1.appendChild(this.document.createTextNode("1000"));
        subElement.appendChild(subval1);
        Element subval2 = this.document.createElement("subval2");
        subval2.appendChild(this.document.createTextNode("aaaaaaaa"));
        subElement.appendChild(subval2);
        Element val3 = this.document.createElement("val3");
        val3.appendChild(subElement);
        root.appendChild(val3);

        TransformerFactory tf = TransformerFactory.newInstance();
        try {
            Transformer transformer = tf.newTransformer();
            DOMSource source = new DOMSource(document);
            transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
            transformer.setOutputProperty(OutputKeys.INDENT, "yes");
            PrintWriter pw = new PrintWriter(new FileOutputStream(fileName));
            StreamResult result = new StreamResult(pw);
            transformer.transform(source, result);
            System.out.println("生成XML文件成功!");
        } catch (TransformerConfigurationException e) {
            System.out.println(e.getMessage());
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());
        } catch (FileNotFoundException e) {
            System.out.println(e.getMessage());
        } catch (TransformerException e) {
            System.out.println(e.getMessage());
        }
    }

    public void parserXml(String fileName) {
        try {
            DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
            DocumentBuilder db = dbf.newDocumentBuilder();
            Document document = db.parse(fileName);
            NodeList employees = document.getChildNodes();
            for (int i = 0; i < employees.getLength(); i++) {
                Node employee = employees.item(i);
                NodeList employeeInfo = employee.getChildNodes();
                for (int j = 0; j < employeeInfo.getLength(); j++) {
                    Node node = employeeInfo.item(j);
                    NodeList employeeMeta = node.getChildNodes();
                    for (int k = 0; k < employeeMeta.getLength(); k++) {
                        System.out.println(employeeMeta.item(k).getNodeName()
                                + ":" + employeeMeta.item(k).getTextContent());
                    }
                }
            }
            System.out.println("解析完毕");
        } catch (FileNotFoundException e) {
            System.out.println(e.getMessage());
        } catch (ParserConfigurationException e) {
            System.out.println(e.getMessage());
        } catch (SAXException e) {
            System.out.println(e.getMessage());
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
    }
}

SAX（基于事件流的解析）

使用 SAXParser 和 DefaultHandler 基于事件流完成对 XML 文档的解析，会解析空行。

• 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.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

public class SaxDemo {
    public static void main(String[] args) {
        SaxDemo demo = new SaxDemo();
        demo.parserXml("XML/src/dom.xml");
    }

    public void parserXml(String fileName) {
        SAXParserFactory sax = SAXParserFactory.newInstance();
        try {
            SAXParser saxparser = sax.newSAXParser();
            InputStream is = new FileInputStream(fileName);
            saxparser.parse(is, new MySAXHandler());
        } catch (ParserConfigurationException e) {
            e.printStackTrace();
        } catch (SAXException e) {
            e.printStackTrace();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

class MySAXHandler extends DefaultHandler {
    boolean hasAttribute = false;
    Attributes attributes = null;

    public void startDocument() throws SAXException {
        System.out.println("文档开始打印了");
    }

    public void endDocument() throws SAXException {
        System.out.println("文档打印结束了");
    }

    public void startElement(String uri, String localName, String qName,
                             Attributes attributes) throws SAXException {
        System.out.println(qName + ":");
        if (attributes.getLength() > 0) {
            this.attributes = attributes;
            this.hasAttribute = true;
        }
    }

    public void endElement(String uri, String localName, String qName)
            throws SAXException {
    }

    public void characters(char[] ch, int start, int length)
            throws SAXException {
        if (length > 1) {
            System.out.println(new String(ch, start, length));
        }
    }
}

DOM4J

基于 Document 写入 XML 文档，基于 SAX 完成对 XML 文档的解析，不会写入空行，会解析空行。

• DOM4j：

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.Iterator;

public class Dom4jDemo {
	public static void main(String[] args) {
		Dom4jDemo demo = new Dom4jDemo();
		demo.createXml("XML/src/dom4j.xml");
		demo.parserXml("XML/src/dom4j.xml");
	}

	public void createXml(String fileName) {
		Document document = DocumentHelper.createDocument();
		Element rootElement = document.addElement("rootElement");
		Element val1 = rootElement.addElement("val1");
		val1.setText("10000000000000");
		Element val2 = rootElement.addElement("val2");
		val2.setText("1.00000000000001");
		Element subElement = rootElement.addElement("subElement");
		Element subval1 = subElement.addElement("subval1");
		subval1.setText("1000");
		Element subval2 = subElement.addElement("subval2");
		subval2.setText("aaaaaaaaa");
		try {
			Writer fileWriter = new FileWriter(fileName);
			XMLWriter xmlWriter = new XMLWriter(fileWriter);
			xmlWriter.write(document);
			xmlWriter.close();
		} catch (IOException e) {
			System.out.println(e.getMessage());
		}
	}

	public void parserXml(String fileName) {
		File inputXml = new File(fileName);
		SAXReader saxReader = new SAXReader();
		try {
			Document document = saxReader.read(inputXml);
			Element root = document.getRootElement();
			System.out.println(root.getName() + ":" + root.getText());
			for (Iterator i = root.elementIterator(); i.hasNext();) {
				Element val = (Element) i.next();
				System.out.println(val.getName() + ":" + val.getText());
				for (Iterator j = val.elementIterator(); j.hasNext();) {
					Element node = (Element) j.next();
					System.out.println("---："+node.getName() + ":" + node.getText());
				}
			}
		} catch (DocumentException e) {
			System.out.println(e.getMessage());
		}
		System.out.println("dom4j parserXml");
	}
}

JDOM

基于 Document 写入 XML 文档，基于 SAX 完成对 XML 文档的解析，不会写入空行，不会解析空行。

• JDOM

import org.jdom.Document;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;
import org.jdom.output.XMLOutputter;
import org.jdom.Element;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.List;

/**
 * 
 * JDOM 生成与解析XML文档
 * 
 */
public class JDomDemo {

	public static void main(String[] args) {
		JDomDemo demo = new JDomDemo();
		demo.createXml("XML/src/jdom.xml");
		demo.parserXml("XML/src/jdom.xml");
	}

	public void createXml(String fileName) {
		Element root = new Element("rootElements");
		Document document = new Document(root);
		Element val1 = new Element("val1");
		val1.setText("10000000000000");
		root.addContent(val1);
		Element val2 = new Element("val2");
		val2.setText("1.00000000000001");
		root.addContent(val2);
		Element subElement = new Element("subElement");
		Element subval1 = new Element("subval1");
		subval1.setText("1000");
		subElement.addContent(subval1);
		Element subval2 = new Element("subval2");
		subval2.setText("aaaaaaaaaa");
		subElement.addContent(subval2);
		root.addContent(subElement);
		XMLOutputter XMLOut = new XMLOutputter();
		try {
			XMLOut.output(document, new FileOutputStream(fileName));
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public void parserXml(String fileName) {
		SAXBuilder builder = new SAXBuilder(false);
		try {
			Document document = builder.build(fileName);
			Element root = document.getRootElement();
			List vals = root.getChildren();
			System.out.println((root).getName());
			for (int i = 0; i < vals.size(); i++) {
				Element val = (Element) vals.get(i);
				List subval = val.getChildren();
				if (subval.size() == 0) {
					System.out.println((val).getName() + ":" + val.getValue());
				}
				for (int j = 0; j < subval.size(); j++) {
					System.out.println(((Element) subval.get(j)).getName()
							+ ":" + ((Element) subval.get(j)).getValue());
				}
			}
		} catch (JDOMException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}