Java Document生成和解析XML操作

一）Document介绍

API来源：在JDK中javax.xml.*包下

使用场景：

1、需要知道XML文档所有结构

2、需要把文档一些元素排序

3、文档中的信息被多次使用的情况

优势：由于Document是java中自带的解析器，兼容性强

缺点：由于Document是一次性加载文档信息，如果文档太大，加载耗时长，不太适用

二）Document生成XML

实现步骤：

第一步：初始化一个XML解析工厂

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

第二步：创建一个DocumentBuilder实例

DocumentBuilder builder = factory.newDocumentBuilder();

第三步：构建一个Document实例

Document doc = builder.newDocument();

doc.setXmlStandalone(true);

standalone用来表示该文件是否呼叫其它外部的文件。若值是 ”yes” 表示没有呼叫外部文件

第四步：创建一个根节点，名称为root，并设置一些基本属性

Element element = doc.createElement("root");
element.setAttribute("attr", "root");//设置节点属性
childTwoTwo.setTextContent("root attr");//设置标签之间的内容

第五步：把节点添加到Document中，再创建一些子节点加入

doc.appendChild(element);

第六步：把构造的XML结构，写入到具体的文件中

实现源码：

package com.oysept.xml;
import java.io.File;
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.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;

/**
* Document生成XML
* @author ouyangjun
*/
public class CreateDocument {

public static void main(String[] args) {
// 执行Document生成XML方法
createDocument(new File("E:\\person.xml"));
}

public static void createDocument(File file) {
try {
// 初始化一个XML解析工厂
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

// 创建一个DocumentBuilder实例
DocumentBuilder builder = factory.newDocumentBuilder();

// 构建一个Document实例
Document doc = builder.newDocument();
doc.setXmlStandalone(true);
// standalone用来表示该文件是否呼叫其它外部的文件。若值是 ”yes” 表示没有呼叫外部文件

// 创建一个根节点
// 说明: doc.createElement("元素名")、element.setAttribute("属性名","属性值")、element.setTextContent("标签间内容")
Element element = doc.createElement("root");
element.setAttribute("attr", "root");

// 创建根节点第一个子节点
Element elementChildOne = doc.createElement("person");
elementChildOne.setAttribute("attr", "personOne");
element.appendChild(elementChildOne);

// 第一个子节点的第一个子节点
Element childOneOne = doc.createElement("people");
childOneOne.setAttribute("attr", "peopleOne");
childOneOne.setTextContent("attr peopleOne");
elementChildOne.appendChild(childOneOne);

// 第一个子节点的第二个子节点
Element childOneTwo = doc.createElement("people");
childOneTwo.setAttribute("attr", "peopleTwo");
childOneTwo.setTextContent("attr peopleTwo");
elementChildOne.appendChild(childOneTwo);

// 创建根节点第二个子节点
Element elementChildTwo = doc.createElement("person");
elementChildTwo.setAttribute("attr", "personTwo");
element.appendChild(elementChildTwo);

// 第二个子节点的第一个子节点
Element childTwoOne = doc.createElement("people");
childTwoOne.setAttribute("attr", "peopleOne");
childTwoOne.setTextContent("attr peopleOne");
elementChildTwo.appendChild(childTwoOne);

// 第二个子节点的第二个子节点
Element childTwoTwo = doc.createElement("people");
childTwoTwo.setAttribute("attr", "peopleTwo");
childTwoTwo.setTextContent("attr peopleTwo");
elementChildTwo.appendChild(childTwoTwo);

// 添加根节点
doc.appendChild(element);

// 把构造的XML结构，写入到具体的文件中
TransformerFactory formerFactory=TransformerFactory.newInstance();
Transformer transformer=formerFactory.newTransformer();
// 换行
transformer.setOutputProperty(OutputKeys.INDENT, "YES");
// 文档字符编码
transformer.setOutputProperty(OutputKeys.ENCODING, "utf-8");

// 可随意指定文件的后缀,效果一样,但xml比较好解析,比如: E:\\person.txt等
transformer.transform(new DOMSource(doc),new StreamResult(file));

System.out.println("XML CreateDocument success!");
} catch (ParserConfigurationException e) {
e.printStackTrace();
} catch (TransformerConfigurationException e) {
e.printStackTrace();
} catch (TransformerException e) {
e.printStackTrace();
}
}
}

XML文件效果图：

三）Document解析XML

实现步骤：

第一步：先获取需要解析的文件，判断文件是否已经存在或有效

第二步：初始化一个XML解析工厂

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

第三步：创建一个DocumentBuilder实例

DocumentBuilder builder = factory.newDocumentBuilder();

第四步：创建一个解析XML的Document实例

Document doc = builder.parse(file);

第五步：先获取根节点的信息，然后根据根节点递归一层层解析XML

实现源码：

package com.oysept.xml;
import java.io.File;
import java.io.IOException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Attr;
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;

/**
* Document解析XML
* @author ouyangjun
*/
public class ParseDocument {

public static void main(String[] args){
File file = new File("E:\\person.xml");
if (!file.exists()) {
System.out.println("xml文件不存在,请确认!");
} else {
parseDocument(file);
}
}

public static void parseDocument(File file) {
try{
// 初始化一个XML解析工厂
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

// 创建一个DocumentBuilder实例
DocumentBuilder builder = factory.newDocumentBuilder();

// 创建一个解析XML的Document实例
Document doc = builder.parse(file);

// 获取根节点名称
String rootName = doc.getDocumentElement().getTagName();
System.out.println("根节点: " + rootName);

System.out.println("递归解析--------------begin------------------");
// 递归解析Element
Element element = doc.getDocumentElement();
parseElement(element);
System.out.println("递归解析--------------end------------------");
} catch (ParserConfigurationException e) {
e.printStackTrace();
} catch (SAXException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}

// 递归方法
public static void parseElement(Element element) {
System.out.print("<" + element.getTagName());
NamedNodeMap attris = element.getAttributes();
for (int i = 0; i < attris.getLength(); i++) {
Attr attr = (Attr) attris.item(i);
System.out.print(" " + attr.getName() + "=\"" + attr.getValue() + "\"");
}
System.out.println(">");

NodeList nodeList = element.getChildNodes();
Node childNode;
for (int temp = 0; temp < nodeList.getLength(); temp++) {
childNode = nodeList.item(temp);

// 判断是否属于节点
if (childNode.getNodeType() == Node.ELEMENT_NODE) {
// 判断是否还有子节点
if(childNode.hasChildNodes()){
 parseElement((Element) childNode);
} else if (childNode.getNodeType() != Node.COMMENT_NODE) {
 System.out.print(childNode.getTextContent());
}
}
}
System.out.println("</" + element.getTagName() + ">");
}
}

XML解析效果图：

补充知识：Java——采用DOM4J+单例模式实现XML文件的读取

大家对XML并不陌生，它是一种可扩展标记语言，常常在项目中作为配置文件被使用。XML具有高度扩展性，只要遵循一定的规则，XML的可扩展性几乎是无限的，而且这种扩展并不以结构混乱或影响基础配置为代价。项目中合理的使用配置文件可以大大提高系统的可扩展性，在不改变核心代码的情况下，只需要改变配置文件就可以实现功能变更，这样也符合编程开闭原则。

但是我们把数据或者信息写到配置文件中，其他类或者模块要怎样读取呢？这时候我们就需要用到XML API。 DOM4Jj就是一个十分优秀的JavaXML API，具有性能优异、功能强大和极其易使用的特点，下面我们就以java程序连接Oracle数据库为例，简单看一下如何使用配置文件提高程序的可扩展性以及DOM4J如何读取配置文件。

未使用配置文件的程序

<span style="font-family:KaiTi_GB2312;font-size:18px;">/*
* 封装数据库常用操作
*/
public class DbUtil {

/*
* 取得connection
*/
public static Connection getConnection(){
Connection conn=null;
try {
Class.forName("oracle.jdbc.driver.OracleDriver");
String url = "jdbc:oracle:thin:@localhost:1525:bjpowernode";
String username = "drp1";
String password = "drp1";

conn=DriverManager.getConnection(url, username, password);
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return conn;
}
}</span>

我们可以看到上面代码中DriverName、url等信息都是都是写死在代码中的，如果数据库信息有变更的话我们必须修改DbUtil类，这样的程序扩展性极低，是不可取的。

我们可以把DriverName、url等信息保存到配置文件中，这样如果修改的话只需要修改配置文件就可以了，程序代码根本不需要修改。

<span style="font-family:KaiTi_GB2312;font-size:18px;"><?xml version="1.0" encoding="UTF-8"?>
<config>
<db-info>
<driver-name>oracle.jdbc.driver.OracleDriver</driver-name>
<url>jdbc:oracle:thin:@localhost:1525:bjpowernode</url>
<user-name>drp1</user-name>
<password>drp1</password>
</db-info>
</config>
</span>

然后我们还需要建立一个配置信息类来用来存取我们的属性值

<span style="font-family:KaiTi_GB2312;font-size:18px;">/*
* jdbc配置信息
*/
public class JdbcConfig {

private String driverName;
private String url;
private String userName;
private String password;

public String getDriverName() {
return driverName;
}
public void setDriverName(String driverName) {
this.driverName = driverName;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}

@Override
public String toString() {
// TODO Auto-generated method stub
return this.getClass().getName()+"{driverName:" + driverName + ",url:" + url + ",userName:" + userName + "}";
}
}</span>

接下来就是用DOM4J读取XML信息，并把相应的属性值保存到JdbcConfig中

<span style="font-family:KaiTi_GB2312;font-size:18px;">/*
* DOM4J+单例模式解析sys-config.xml文件
*/
public class XmlConfigReader {

//懒汉式（延迟加载lazy）
private static XmlConfigReader instance=null;

//保存jdbc相关配置信息
private JdbcConfig jdbcConfig=new JdbcConfig();

private XmlConfigReader(){
SAXReader reader=new SAXReader();
InputStream in=Thread.currentThread().getContextClassLoader().getResourceAsStream("sys-config.xml");
try {
Document doc=reader.read(in);

//取得jdbc相关配置信息
Element driverNameElt=(Element)doc.selectObject("/config/db-info/driver-name");
Element urlElt=(Element)doc.selectObject("/config/db-info/url");
Element userNameElt=(Element)doc.selectObject("/config/db-info/user-name");
Element passwordElt=(Element)doc.selectObject("/config/db-info/password");

//设置jdbc相关配置信息
jdbcConfig.setDriverName(driverNameElt.getStringValue());
jdbcConfig.setUrl(urlElt.getStringValue());
jdbcConfig.setUserName(userNameElt.getStringValue());
jdbcConfig.setPassword(passwordElt.getStringValue());

} catch (DocumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

public static synchronized XmlConfigReader getInstance(){
if (instance==null){
instance=new XmlConfigReader();
}
return instance;
}

/*
* 返回jdbc相关配置
*/
public JdbcConfig getJdbcConfig(){
return jdbcConfig;
}

public static void main(String[] args){
JdbcConfig jdbcConfig=XmlConfigReader.getInstance().getJdbcConfig();
System.out.println(jdbcConfig);
}

}</span>

然后我们的数据库操作类就可以使用XML文件中的属性值了

<span style="font-family:KaiTi_GB2312;font-size:18px;">/*
* 封装数据库常用操作
*/
public class DbUtil {

/*
* 取得connection
*/
public static Connection getConnection(){

Connection conn=null;
try {
JdbcConfig jdbcConfig=XmlConfigReader.getInstance().getJdbcConfig();
Class.forName(jdbcConfig.getDriverName());

conn=DriverManager.getConnection(jdbcConfig.getUrl(), jdbcConfig.getUserName(), jdbcConfig.getPassword());
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return conn;
}
} </span>

现在我们可以看出来DriverName、url等信息都是通过jdbcConfig直接获得的，而jdbcConfig中的数据是通过DOM4J读取的XML，这样数据库信息有变动我们只需要通过记事本修改XML文件整个系统就可以继续运行，真正做到了程序的可扩展，以不变应万变。

来源：https://blog.csdn.net/p812438109/article/details/81807440