import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StringReader;
import java.io.StringWriter;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.apache.commons.lang3.StringUtils;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 基于dom4j的工具包
*
*
*
*/
public class DOMUtils {
private static Logger logger = LoggerFactory.getLogger(DOMUtils.class);
/**
* 通过文件的路径获取xml的document对象
*
* @param path
* 文件的路径
* @return 返回文档对象
*/
public static Document getXMLByFilePath(String path) {
if (null == path) {
return null;
}
Document document = null;
try {
SAXReader reader = new SAXReader();
document = reader.read(new File(path));
} catch (Exception e) {
logger.error("", e);
e.printStackTrace();
}
return document;
}
/**
* 通过xml字符获取document文档
*
* @param xmlstr
* 要序列化的xml字符
* @return 返回文档对象
* @throws DocumentException
*/
public static Document getXMLByString(String xmlstr) throws DocumentException {
if (xmlstr == "" || xmlstr == null) {
return null;
}
Document document = DocumentHelper.parseText(xmlstr);
return document;
}
/**
* 获取某个元素的所有的子节点
*
* @param em
* 制定节点
* @return 返回所有的子节点
*/
public static List<Element> getChildElements(Element em) {
if (null == em) {
return null;
}
@SuppressWarnings("unchecked")
List<Element> lists = em.elements();
return lists;
}
/**
* 获取指定节点的子节点
*
* @param node
* 父节点
* @param childnode
* 指定名称的子节点
* @return 返回指定的子节点
*/
public static Element getChildElement(Element node, String childnode) {
if (null == node || null == childnode || "".equals(childnode)) {
return null;
}
return node.element(childnode);
}
/**
* 获取所有的属性值
*
* @param node
* @param arg
* @return
*/
public static Map<String, String> getAttributes(Element node, String... arg) {
if (node == null || arg.length == 0) {
return null;
}
Map<String, String> attrMap = new HashMap<String, String>();
for (String attr : arg) {
String attrValue = node.attributeValue(attr);
attrMap.put(attr, attrValue);
}
return attrMap;
}
/**
* 获取element的单个属性
*
* @param node
* 需要获取属性的节点对象
* @param attr
* 需要获取的属性值
* @return 返回属性的值
*/
public static String getAttribute(Element node, String attr) {
if (null == node || attr == null || "".equals(attr)) {
return "";
}
return node.attributeValue(attr);
}
/**
* 添加孩子节点元素
*
* @param parent
* 父节点
* @param childName
* 孩子节点名称
* @param childValue
* 孩子节点值
* @return 新增节点
*/
public static Element addChild(Element parent, String childName, String childValue) {
Element child = parent.addElement(childName);// 添加节点元素
child.setText(childValue == null ? "" : childValue); // 为元素设值
return child;
}
/**
* DOM4j的Document对象转为XML报文串
*
* @param document
* @param charset
* @return 经过解析后的xml字符串
*/
public static String documentToString(Document document, String charset) {
StringWriter stringWriter = new StringWriter();
OutputFormat format = OutputFormat.createPrettyPrint();// 获得格式化输出流
format.setEncoding(charset);// 设置字符集,默认为UTF-8
XMLWriter xmlWriter = new XMLWriter(stringWriter, format);// 写文件流
try {
xmlWriter.write(document);
xmlWriter.flush();
xmlWriter.close();
} catch (IOException e) {
logger.error("", e);
throw new RuntimeException(e);
}
return stringWriter.toString();
}
/**
* 去掉声明头的(即<?xml...?>去掉)
*
* @param document
* @param charset
* @return
*/
public static String documentToStringNoDeclaredHeader(Document document, String charset) {
String xml = documentToString(document, charset);
return xml.replaceFirst("\\s*<[^<>]+>\\s*", "");
}
/**
* 解析XML为Document对象
*
* @param xml
* 被解析的XMl
* @return Document
* @throws ParseMessageException
*/
public final static Element parseXml(String xml) {
StringReader sr = new StringReader(xml);
SAXReader saxReader = new SAXReader();
Document document = null;
try {
document = saxReader.read(sr);
} catch (DocumentException e) {
e.printStackTrace();
}
Element rootElement = document != null ? document.getRootElement() : null;
return rootElement;
}
/**
* 获取element对象的text的值
*
* @param e
* 节点的对象
* @param tag
* 节点的tag
* @return
*/
public final static String getText(Element e, String tag) {
Element _e = e.element(tag);
if (_e != null)
return _e.getText();
else
return null;
}
/**
* 获取去除空格的字符串
*
* @param e
* @param tag
* @return
*/
public final static String getTextTrim(Element e, String tag) {
Element _e = e.element(tag);
if (_e != null)
return _e.getTextTrim();
else
return null;
}
/**
* 获取节点值.节点必须不能为空,否则抛错
*
* @param parent
* 父节点
* @param tag
* 想要获取的子节点
* @return 返回子节点
* @throws ParseMessageException
*/
public final static String getTextTrimNotNull(Element parent, String tag) {
Element e = parent.element(tag);
if (e == null)
throw new NullPointerException("节点为空");
else
return e.getTextTrim();
}
/**
* 节点必须不能为空,否则抛错
*
* @param parent
* 父节点
* @param tag
* 想要获取的子节点
* @return 子节点
* @throws ParseMessageException
*/
public final static Element elementNotNull(Element parent, String tag) {
Element e = parent.element(tag);
if (e == null)
throw new NullPointerException("节点为空");
else
return e;
}
/**
* 将文档对象写入对应的文件中
*
* @param document
* 文档对象
* @param path
* 写入文档的路径
* @throws IOException
*/
public final static void writeXMLToFile(Document document, String path) throws IOException {
if (document == null || path == null) {
return;
}
XMLWriter writer = new XMLWriter(new FileWriter(path));
writer.write(document);
writer.close();
}
// 传入xml格式的string,转化为xml类型,然后解析其内容,返回map数据形式
public static List<Map<String, Object>> strToXmlAndPaserXml(String strXml) throws Exception {
SAXReader reader = new SAXReader();
Document doc = reader.read(new ByteArrayInputStream(strXml.getBytes("UTF-8")));
List<Map<String, Object>> xml = paserXml(doc);
return xml;
}
// 遍历解析xml数据
public static List<Map<String, Object>> paserXml(Document doc) throws Exception {
List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
Element root = doc.getRootElement(); // 获取根节点
Iterator<?> it = root.elementIterator();
Element element;
Element elements;
// 解析子节点 entity
while (it.hasNext()) {
element = (Element) it.next();
Iterator<?> its = element.elementIterator();
// 解析子节点 entity 下的节点
Map<String, Object> map = new HashMap<String, Object>();
while (its.hasNext()) {
elements = (Element) its.next();
map.put(elements.getName(), elements.getText());
}
list.add(map);
}
return list;
}
// 传入xml格式的string,转化为xml类型,然后解析其内容,返回 实体类 数据形式
public static <T> List<T> strToXmlAndPaserEntity(String strXml, Class<T> clazz) throws Exception {
SAXReader reader = new SAXReader();
Document doc = reader.read(new ByteArrayInputStream(strXml.getBytes("UTF-8")));
List<T> xml = paserXmlEntity(doc, clazz);
return xml;
}
public static <T> List<T> paserXmlEntity(Document doc, Class<T> clazz) throws Exception {
List<T> list = new ArrayList<T>();
Element root = doc.getRootElement(); // 获取根节点
Iterator<?> it = root.elementIterator();
Element element;
Element elements;
// 解析子节点 entity
while (it.hasNext()) {
element = (Element) it.next();
Iterator<?> its = element.elementIterator();
// 解析子节点 entity 下的节点
Map<String, Object> map = new HashMap<String, Object>();
while (its.hasNext()) {
elements = (Element) its.next();
map.put(elements.getName(), elements.getText());
}
list.add(mapToEntity(clazz, map));
}
return list;
}
// map转实体类
public static <T> T mapToEntity(Class<T> clazz, Map<String, Object> map) {
if (null == map) {
return null;
}
// 取到类下所有的属性,也就是变量名
Field[] fields = clazz.getDeclaredFields();
try {
T entity = clazz.newInstance();
for (Field field : fields) {
String fieldName = field.getName();
if (map.get(fieldName) == null) {
continue;
}
// 把属性的第一个字母处理成大写
String stringLetter = fieldName.substring(0, 1).toUpperCase();
// 取得set方法名,比如setBbzt
String setterName = "set" + stringLetter + fieldName.substring(1);
// 属性类型
Class<?> fieldClass = field.getType();
// 取到类下所有方法
Method[] methodArray = clazz.getMethods();
if (methodArray != null) {
for (Method method : methodArray) {
// 真正取得set方法。
String methodName = method.getName();
if (methodName.equals(setterName)) {
if (fieldClass == String.class) {
method = clazz.getMethod(setterName, fieldClass);
method.invoke(entity, String.valueOf(map.get(fieldName)));// 为其赋值
} else if (fieldClass == Integer.class || fieldClass == int.class) {
method = clazz.getMethod(setterName, fieldClass);
method.invoke(entity, Integer.parseInt(String.valueOf(map.get(fieldName))));// 为其赋值
} else if (fieldClass == Boolean.class || fieldClass == boolean.class) {
method = clazz.getMethod(setterName, fieldClass);
method.invoke(entity, Boolean.getBoolean(String.valueOf(map.get(fieldName))));// 为其赋值
} else if (fieldClass == Short.class || fieldClass == short.class) {
method = clazz.getMethod(setterName, fieldClass);
method.invoke(entity, Short.parseShort(String.valueOf(map.get(fieldName))));// 为其赋值
} else if (fieldClass == Long.class || fieldClass == long.class) {
method = clazz.getMethod(setterName, fieldClass);
method.invoke(entity, Long.parseLong(String.valueOf(map.get(fieldName))));// 为其赋值
} else if (fieldClass == Double.class || fieldClass == double.class) {
method = clazz.getMethod(setterName, fieldClass);
method.invoke(entity, Double.parseDouble(String.valueOf(map.get(fieldName))));// 为其赋值
} else if (fieldClass == Float.class || fieldClass == float.class) {
method = clazz.getMethod(setterName, fieldClass);
method.invoke(entity, Float.parseFloat(String.valueOf(map.get(fieldName))));// 为其赋值
} else if (fieldClass == BigInteger.class) {
method = clazz.getMethod(setterName, fieldClass);
method.invoke(entity, new BigInteger(String.valueOf(map.get(fieldName))));// 为其赋值
} else if (fieldClass == BigDecimal.class) {
method = clazz.getMethod(setterName, fieldClass);
if(map.get(fieldName) == null || StringUtils.isBlank(map.get(fieldName).toString())){
map.put(fieldName, "0");
}
method.invoke(entity, new BigDecimal(String.valueOf(map.get(fieldName))));// 为其赋值
} else if (fieldClass == Date.class) {
method = clazz.getMethod(setterName, fieldClass);
if (map.get(fieldName).getClass() == java.sql.Date.class) {
method.invoke(entity, new Date(((java.sql.Date) map.get(fieldName)).getTime()));// 为其赋值
} else if (map.get(fieldName).getClass() == java.sql.Time.class) {
method.invoke(entity, new Date(((java.sql.Time) map.get(fieldName)).getTime()));// 为其赋值
} else if (map.get(fieldName).getClass() == java.sql.Timestamp.class) {
method.invoke(entity,
new Date(((java.sql.Timestamp) map.get(fieldName)).getTime()));// 为其赋值
}
}
}
}
}
}
return entity;
} catch (InstantiationException e) {
e.printStackTrace();
logger.error("", e);
} catch (IllegalAccessException e) {
e.printStackTrace();
logger.error("实例化 JavaBean 失败", e);
} catch (IllegalArgumentException e) {
e.printStackTrace();
logger.error("映射错误", e);
} catch (InvocationTargetException e) {
e.printStackTrace();
logger.error("字段映射失败", e);
} catch (NoSuchMethodException e) {
e.printStackTrace();
logger.error("", e);
} catch (SecurityException e) {
e.printStackTrace();
logger.error("", e);
}
return null;
}
/**
* 根据 节点名称,解析 xml Attribute数据
*
* @param xml
* @return
* @throws Exception
*/
public static List<Map<String, Object>> paserXmlAttribute(String xml, String nodeName) {
String XMLResponse = xml.substring(xml.indexOf("<XMLResponse>"));
Element em = DOMUtils.parseXml(XMLResponse);
List<Map<String, Object>> xmlMap = listNodes(em, nodeName);
return xmlMap;
}
/**
* 递归解析xml节点,适用于 多节点数据
*
* @param node
* @param nodeName
* @return
*/
// 遍历当前节点下的所有节点 ,nodeName 要解析的节点名称
public static List<Map<String, Object>> listNodes(Element node, String nodeName) {
List<Map<String, Object>> listMap = new ArrayList<Map<String, Object>>();
// System.out.println("当前节点的名称:" + node.getName());
// 首先获取当前节点的所有属性节点
@SuppressWarnings("unchecked")
List<Attribute> list = node.attributes();
Map<String, Object> map = null;
// 遍历属性节点
for (Attribute attribute : list) {
if (node.getName().equals(nodeName)) {
if (null == map) {
map = new HashMap<String, Object>();
listMap.add(map);
}
// 取到的节点属性防止map中
// System.out.println("属性"+attribute.getName() +":" +
// attribute.getValue());
map.put(attribute.getName(), attribute.getValue());
}
}
// 如果当前节点内容不为空,则输出
if (!(node.getTextTrim().equals(""))) {
// System.out.println( node.getName() + ":" + node.getText());
}
// 同时迭代当前节点下面的所有子节点
// 使用递归
@SuppressWarnings("unchecked")
Iterator<Element> iterator = node.elementIterator();
while (iterator.hasNext()) {
Element e = iterator.next();
listMap.addAll(listNodes(e, nodeName));
}
return listMap;
}
/**
* xml转为字符串
*
* @param fileUrl 文件地址
* @return
*/
public static String xmlToString(String fileUrl) throws IOException{
BufferedReader reader = null;
StringBuffer sb = new StringBuffer();
try {
File file = new File(fileUrl);
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
reader = new BufferedReader(new InputStreamReader(bis, "utf-8"), 5 * 1024 * 1024);// 用5M的缓冲读取文本文件
String line;
while ((line = reader.readLine()) != null) {
sb.append(line);
}
} finally {
if (reader != null) {
reader.close();
}
}
return sb.toString();
}
}
xml解析工具
最新推荐文章于 2024-08-22 12:41:20 发布