Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
com.github.zhangxd1989.basetool.util.XmlUtil Maven / Gradle / Ivy
package com.github.zhangxd1989.basetool.util;
import com.github.zhangxd1989.basetool.exceptions.UtilException;
import com.github.zhangxd1989.basetool.io.FileUtil;
import com.github.zhangxd1989.basetool.io.IoUtil;
import com.github.zhangxd1989.basetool.lang.Assert;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;
import javax.xml.namespace.QName;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
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 java.beans.XMLDecoder;
import java.beans.XMLEncoder;
import java.io.BufferedInputStream;
import java.io.BufferedWriter;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.StringWriter;
import java.io.Writer;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
/**
* XML工具类 对象类型
* @param source XML文件
* @return 对象
* @throws IOException IO异常
*/
public static T readObjectFromXml(File source) throws IOException {
return readObjectFromXml(new InputSource(FileUtil.getInputStream(source)));
}
/**
* 从XML中读取对象 Reads serialized object from the XML file.
*
* @param 对象类型
* @param xmlStr XML内容
* @return 对象
* @throws IOException IO异常
*/
public static T readObjectFromXml(String xmlStr) throws IOException {
return readObjectFromXml(new InputSource(StrUtil.getReader(xmlStr)));
}
/**
* 从XML中读取对象 Reads serialized object from the XML file.
*
* @param 对象类型
* @param source {@link InputSource}
* @return 对象
* @throws IOException IO异常
*/
@SuppressWarnings("unchecked")
public static T readObjectFromXml(InputSource source) throws IOException {
Object result;
XMLDecoder xmldec = null;
try {
xmldec = new XMLDecoder(source);
result = xmldec.readObject();
} finally {
IoUtil.close(xmldec);
}
return (T) result;
}
/**
* 将XML文档转换为String getElements(Element element, String tagName) {
final NodeList nodeList = StrUtil.isBlank(tagName) ? element.getChildNodes() : element.getElementsByTagName(tagName);
return transElements(element, nodeList);
}
/**
* 根据节点名获得第一个子节点
*
* @param element 节点
* @param tagName 节点名
* @return 节点
*/
public static Element getElement(Element element, String tagName) {
final NodeList nodeList = element.getElementsByTagName(tagName);
if (nodeList == null || nodeList.getLength() < 1) {
return null;
}
int length = nodeList.getLength();
for (int i = 0; i < length; i++) {
Element childEle = (Element) nodeList.item(i);
if (childEle == null || childEle.getParentNode() == element) {
return childEle;
}
}
return null;
}
/**
* 根据节点名获得第一个子节点
*
* @param element 节点
* @param tagName 节点名
* @return 节点中的值
*/
public static String elementText(Element element, String tagName) {
Element child = getElement(element, tagName);
return child == null ? null : child.getTextContent();
}
/**
* 根据节点名获得第一个子节点
*
* @param element 节点
* @param tagName 节点名
* @param defaultValue 默认值
* @return 节点中的值
*/
public static String elementText(Element element, String tagName, String defaultValue) {
Element child = getElement(element, tagName);
return child == null ? defaultValue : child.getTextContent();
}
/**
* 将NodeList转换为Element列表
*
* @param nodeList NodeList
* @return Element列表
*/
public static List transElements(NodeList nodeList) {
return transElements(null, nodeList);
}
/**
* 将NodeList转换为Element列表 transElements(Element parentEle, NodeList nodeList) {
int length = nodeList.getLength();
final ArrayList elements = new ArrayList(length);
Node node;
Element element;
for (int i = 0; i < length; i++) {
node = nodeList.item(i);
if (Node.ELEMENT_NODE == node.getNodeType()) {
element = (Element) nodeList.item(i);
if (parentEle == null || element.getParentNode() == parentEle) {
elements.add(element);
}
}
}
return elements;
}
/**
* 将可序列化的对象转换为XML写入文件，已经存在的文件将被覆盖
* & (ampersand) 替换为 &
* < (小于) 替换为 <
* > (大于) 替换为 >
* " (双引号) 替换为 "
*
*
* @param string 被替换的字符串
* @return 替换后的字符串
*/
public static String escape(String string) {
final StringBuilder sb = new StringBuilder(string.length());
for (int i = 0, length = string.length(); i < length; i++) {
char c = string.charAt(i);
switch (c) {
case '&':
sb.append("&");
break;
case '<':
sb.append("<");
break;
case '>':
sb.append(">");
break;
case '"':
sb.append(""");
break;
case '\'':
sb.append("'");
break;
default:
sb.append(c);
}
}
return sb.toString();
}
/**
* XML格式字符串转换为Map
*
* @param xmlStr XML字符串
* @return XML数据转换后的Map
*/
public static Map xmlToMap(String xmlStr) {
return xmlToMap(xmlStr, new HashMap());
}
/**
* XML格式字符串转换为Map
*
* @param node XML节点
* @return XML数据转换后的Map
*/
public static Map xmlToMap(Node node) {
return xmlToMap(node, new HashMap());
}
/**
* XML格式字符串转换为Map xmlToMap(String xmlStr, Map result) {
final Document doc = parseXml(xmlStr);
final Element root = getRootElement(doc);
root.normalize();
return xmlToMap(root, result);
}
/**
* XML节点转换为Map
*
* @param node XML节点
* @param result 结果Map类型
* @return XML数据转换后的Map
*/
public static Map xmlToMap(Node node, Map result) {
if (null == result) {
result = new HashMap<>();
}
final NodeList nodeList = node.getChildNodes();
final int length = nodeList.getLength();
Node childNode;
Element childEle;
for (int i = 0; i < length; ++i) {
childNode = nodeList.item(i);
if (isElement(childNode)) {
childEle = (Element) childNode;
result.put(childEle.getNodeName(), childEle.getTextContent());
}
}
return result;
}
/**
* 将Map转换为XML格式的字符串
*
* @param data Map类型数据
* @param rootName 跟标签名
* @return XML格式的字符串
*/
public static String mapToXmlStr(Map data, String rootName) {
return toStr(mapToXml(data, rootName));
}
/**
* 将Map转换为XML
*
* @param data Map类型数据
* @param rootName 跟标签名
* @return XML
*/
public static Document mapToXml(Map data, String rootName) {
final Document doc = createXml();
final Element root = appendChild(doc, rootName);
mapToXml(doc, root, data);
return doc;
}
/**
* 给定节点是否为{@link Element} 类型节点
*
* @param node 节点
* @return 是否为{@link Element} 类型节点
*/
public static boolean isElement(Node node) {
return (null != node) && Node.ELEMENT_NODE == node.getNodeType();
}
/**
* 在已有节点上创建子节点
*
* @param node 节点
* @param tagName 标签名
* @return 子节点
*/
public static Element appendChild(Node node, String tagName) {
Document doc = (node instanceof Document) ? (Document) node : node.getOwnerDocument();
Element child = doc.createElement(tagName);
node.appendChild(child);
return child;
}
/**
* 将Map转换为XML格式的字符串
*
* @param doc {@link Document}
* @param element 节点
* @param data Map类型数据
*/
private static void mapToXml(Document doc, Element element, Map data) {
Element filedEle;
Object key;
for (Entry entry : data.entrySet()) {
key = entry.getKey();
if (null != key) {
// key作为标签名
filedEle = doc.createElement(key.toString());
element.appendChild(filedEle);
final Object value = entry.getValue();
// value作为标签内的值。
if (null != value) {
if (value instanceof Map) {
//如果值依旧为map，递归继续
mapToXml(doc, filedEle, (Map) value);
element.appendChild(filedEle);
} else {
filedEle.appendChild(doc.createTextNode(value.toString()));
}
}
}
}
}
/**
* 关闭XXE，避免漏洞攻击
