Java中操作Xml使用方法备忘录(Hutool工具类XmlUtil、XStream)
更新时间：2023年11月15日 14:52:59 作者：划]破
这篇文章主要给大家介绍了关于Java中操作Xml使用方法(Hutool工具类XmlUtil、XStream)的相关资料,XMLUtil是一个工具类,主要用于读取XML配置文件并提供相应的操作方法,文中通过代码介绍的非常详细,需要的朋友可以参考下
1. Hutool中XmlUtil的使用简介
# 说明1： XmlUtil只是w3c dom的简单工具化封装，减少操作dom的难度，
# 如果项目对XML依赖较大，依旧推荐Dom4j框架
# 说明2：JDK已经封装有XML解析和构建工具：w3c dom
# Hutool中XmlUtil简化XML的创建、读、写
1. 读取XML
读取XML分为两个方法：XmlUtil.readXML 读取XML文件
XmlUtil.parseXml 解析XML字符串为Document对象
2. 写XML
XmlUtil.toStr 将XML文档转换为String
XmlUtil.toFile 将XML文档写入到文件
3. 创建XML
XmlUtil.createXml 创建XML文档, 创建的XML默认是utf8编码，
修改编码的过程是在toStr和toFile方法里，既XML在转为文本的时候才定义编码。4. XML读取操作
通过以下工具方法，可以完成基本的节点读取操作。
XmlUtil.cleanInvalid 除XML文本中的无效字符
XmlUtil.getElements 根据节点名获得子节点列表
XmlUtil.getElement 根据节点名获得第一个子节点
XmlUtil.elementText 根据节点名获得第一个子节点
XmlUtil.transElements 将NodeList转换为Element列表
5. XML与对象转换
writeObjectAsXml 将可序列化的对象转换为XML写入文件，已经存在的文件将被覆盖。
readObjectFromXml 从XML中读取对象。
注意 这两个方法严重依赖JDK的XMLEncoder和XMLDecoder，
生成和解析必须成对存在（遵循固定格式），普通的XML转Bean会报错。6. Xpath操作
createXPath 创建XPath
getByXPath 通过XPath方式读取XML节点等信息
2. Hutool中XmlUtil快速读取Xml字符串某个节点值 [简单取值时，推荐使用]
2-1 Hutool工具包Maven依赖和测试Xml字符串如下
<!-- 引入Hutool的Maven依赖 -->
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>5.8.16</version>
</dependency>
<!-- 下方测试用的Xml字符串 --> <?xml version="1.0" encoding="utf-8"?> <returnsms> <returnstatus>Success（成功）</returnstatus> <message>ok</message> <remainpoint>1490</remainpoint> <taskID>885</taskID> <successCounts>1</successCounts> </returnsms>
2-2 读取Xml中的节点的值
Document docResult=XmlUtil.readXML(xmlFile);
// 结果为“ok”
Object value = XmlUtil.getByXPath("//returnsms/message", docResult, XPathConstants.STRING);
// 说明：Element对象目前仅能支持一层一层的向下解析，所以请不要跳级去做查询，
// 否则会报null。如果想直接获取到某个标签的文本，在有准确定位的情况下
// 可以直接写出路径获取，
// 但是如果该层级存在相同的标签则只获取第一个标签的数据。
String xmlData="xml字符串";
Document document= XmlUtil.parseXml(xmlData);
//获得XML文档根节点
Element elementG=XmlUtil.getRootElement(document);
//通过固定路径获取到数据
Object bString = XmlUtil.getByXPath("//root/base/message/event_no", document, XPathConstants.STRING);
System.out.println("event_no元素节点值："+bString);
3. Hutool中XmlUtil详细操作示例
3-1 Xml示例字符串如下
<forms version="2.1">
<formExport>
<summary id="1132755668421070367" name="formmain_0031"/>
<definitions>
<column id="field0001" type="0" name="field1" length="255"/>
<column id="field0002" type="0" name="field2" length="256"/>
</definitions>
<values>
<column name="field1">
<value>
建行一世
</value>
</column>
<column name="field2">
<value>
中国人民
</value>
</column>
</values>
<subForms/>
</formExport>
</forms>
3-2 查询标签内的属性
// 例： 获取<definitions>标签中第一个标签<column >属性length的值
String xmlData="上面规定的xml字符串"; // 测试时自己替换下
Document document= XmlUtil.parseXml(xmlData);
//获得XML文档根节点
Element elementG=XmlUtil.getRootElement(document);
//打印节点名称
System.out.println(elementG.getTagName());
//获取下层节点（该方法默认取第一个）
Element elementZ=XmlUtil.getElement(elementG,"formExport");
System.out.println(elementZ.getTagName());
//获取下层节点（该方法默认取第一个）
Element elementZ1=XmlUtil.getElement(elementZ,"definitions");
System.out.println(elementZ1.getTagName());
//获取下层节点（该方法默认取第一个）
Element elementZ2=XmlUtil.getElement(elementZ1,"column");
System.out.println(elementZ2.getTagName());
//读取属性length
System.out.println(elementZ2.getAttribute("length"));
3-3 查询一对标签中的文本
// 例：获取<values>标签中第一个标签<column>下的<value>所包含的文本，可直接看最后一行
// =======以下内容同3-2，内容开始========================================
String xmlData="上面规定的xml字符串";
Document document= XmlUtil.parseXml(xmlData);
//获得XML文档根节点
Element elementG=XmlUtil.getRootElement(document);
//获取下层节点（该方法默认取第一个）
Element elementZ=XmlUtil.getElement(elementG,"formExport");
//获取下层节点（该方法默认取第一个）
Element elementZ_1=XmlUtil.getElement(elementZ,"values");
//获取下层节点（该方法默认取第一个）
Element elementZ_2=XmlUtil.getElement(elementZ_1,"column");
// =======以上内容同3-2，内容结束========================================
//获取到所有子标签 // Value返回的时NodeList，遍历获取即可
NodeList nodeList=elementZ_2.getElementsByTagName("value");
for (int i = 0; i <nodeList.getLength() ; i++) {
//打印标签的文本
System.out.println(nodeList.item(i).getTextContent());
}
3-4 查询Xml后，再新增一个标签并赋值
// 例：给<values>标签中第一个标签<column>下再度添加一个<value>标签，所包含的文本为：从零开始
// =======以下内容同3-2，内容开始========================================
String xmlData="上面规定的xml字符串";
Document document= XmlUtil.parseXml(xmlData);
//获得XML文档根节点
Element elementG=XmlUtil.getRootElement(document);
//获取下层节点（该方法默认取第一个）
Element elementZ=XmlUtil.getElement(elementG,"formExport");
//获取下层节点（该方法默认取第一个）
Element elementZ_1=XmlUtil.getElement(elementZ,"values");
//获取下层节点（该方法默认取第一个）
Element elementZ_2=XmlUtil.getElement(elementZ_1,"column");
// =======以上内容同3-2，内容结束========================================
//创建一个标签
Element elementItem = document.createElement("value");
//赋值
elementItem.setTextContent("从零开始");
//放到某个标签下面
elementZ_2.appendChild(elementItem);
//获取到所有子标签
NodeList nodeList=elementZ_2.getElementsByTagName("value");
for (int i = 0; i <nodeList.getLength() ; i++) {
//打印标签的文本
System.out.println(nodeList.item(i).getTextContent());
}
System.out.println(XmlUtil.toStr(document));
// 打印的结果： 在<value>建行一世</value>后，新增了一个<value>从零开始</value>
3-5 修改一个标签数据
// 例：给<values>标签中第一个标签<column>下的第一个<value>标签修改成：张三丰
// =======以下内容同3-2，内容开始========================================
String xmlData="上面规定的xml字符串";
Document document= XmlUtil.parseXml(xmlData);
//获得XML文档根节点
Element elementG=XmlUtil.getRootElement(document);
//获取下层节点（该方法默认取第一个）
Element elementZ=XmlUtil.getElement(elementG,"formExport");
//获取下层节点（该方法默认取第一个）
Element elementZ_1=XmlUtil.getElement(elementZ,"values");
//获取下层节点（该方法默认取第一个）
Element elementZ_2=XmlUtil.getElement(elementZ_1,"column");
// =======以上内容同3-2，内容结束========================================
//获取到所有子标签
NodeList nodeList=elementZ_2.getElementsByTagName("value");
//第一次打印
for (int i = 0; i <nodeList.getLength() ; i++) {
//打印标签的文本
System.out.println(nodeList.item(i).getTextContent());
}
//修改
for (int i = 0; i <nodeList.getLength() ; i++) {
// ******************* 这里进行修改 ********************
nodeList.item(i).setTextContent("张三丰");
}
//第二次打印
for (int i = 0; i <nodeList.getLength() ; i++) {
//打印标签的文本
System.out.println(nodeList.item(i).getTextContent());
}
// 打印输出结果：
// 第一次打印输出为： 建行一世
// 第二次打印输出为： 张三丰
4 依赖Hutool再次封装的工具类XmlUtil，实现xml-map、map-xml、xml-json功能
// 作用：
// 1.xml转map
// 2.xml转json
// 3.map转xml
4-1 需要添加的依赖
<dependency> <groupId>cn.hutool</groupId> <artifactId>hutool-all</artifactId> <version>5.7.15</version> </dependency> <dependency> <groupId>org.dom4j</groupId> <artifactId>dom4j</artifactId> <version>2.1.3</version> </dependency>
4-2 工具类XmlUtil代码
4-2-1 用到的一个枚举XmlSort如下：
import java.util.HashMap;
import java.util.LinkedHashMap;
/**
* xml解析顺序是否有序
* @author ASen
*/
public enum XmlSort{
/**
* 有序
*/
SORT(LinkedHashMap.class,"有序"),
/**
* 无序
*/
NO_SORT(HashMap.class,"无序");
/**
* 创建的map字节码对象
*/
private final Class<?> mapClass;
/**
* 顺序名称
*/
private final String message ;
XmlSort(Class<?> mapClass, String message) {
this.mapClass = mapClass;
this.message = message;
}
public Class<?> getMapClass() {
return mapClass;
}
public String getMessage() {
return message;
}
}
4-2-2 XmlUtil.java如下
package com.asen.demo.util;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.json.JSONUtil;
import com.asen.demo.constant.XmlSort;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.dom4j.tree.DefaultDocument;
import org.dom4j.tree.DefaultElement;
import java.io.File;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
/**
* xml解析帮组类
* @author asen
* @date 2022/1/10 15:17
*/
public class XmlUtil {
/**
* 标签属性
*/
private final static String TAG_ATTR = "attr";
/**
* 创建的map类型
*/
private XmlSort xmlSort = XmlSort.NO_SORT;
/**
* map to xml
* @param map map对象
* @return xml 字符串
*/
public String mapToXml(Map<String,Object> map) {
if(map.size() != 1){
throw new RuntimeException("map根节点长度不为1");
}
String key = "";
for (String str : map.keySet()) {
key = str ;
}
// 创建根节点
Element rootElement = new DefaultElement(key);
Document document = new DefaultDocument(rootElement);
Element node = document.getRootElement();
Object obj = map.get(key);
// 断言
Assert.isAssignable(Map.class,obj.getClass());
mapNodes(node,(Map<String, Object>)obj);
return document.asXML();
}
/**
* 父类节点已经创建， map 包含父类
* @param node node
* @param map map
*/
public void mapNodes(Element node, Map<String, Object> map) {
map.forEach((k,v)->{
Object obj = map.get(k);
// 给当前父类添加属性
if(TAG_ATTR.equals(k)){
Assert.isAssignable(Map.class,obj.getClass());
Map<String,Object> tagMap = (Map<String,Object>) obj;
tagMap.forEach((tagKey,tagValue)->{
node.addAttribute(tagKey, (String) tagValue);
});
return ;
}
if(obj instanceof Map){
Element newElement = node.addElement(k);
// map 处理
Map<String,Object> childMap = (Map<String,Object>) obj;
mapNodes(newElement,childMap);
}else if (obj instanceof String){
Element newElement = node.addElement(k);
newElement.setText((String) v);
} else if (obj instanceof List) {
List<Map<String, Object>> list = (List<Map<String, Object>>) obj;
list.forEach(itemMap->{
Element newElement = node.addElement(k);
mapNodes(newElement,itemMap);
});
}
});
}
/**
* 读取xml文件，返回json字符串
*
* @param fileName 文件路径
* @return json字符串
* @throws DocumentException 异常
*/
public String xmlToJson(String fileName) throws DocumentException {
Map<String, Object> xmlMap = xmlToMap(fileName);
return JSONUtil.toJsonStr(xmlMap);
}
/**
* 读取xml文件，返回map对象
*
* @param fileName 文件路径
* @return map对象
* @throws DocumentException 异常
*/
public Map<String, Object> xmlToMap(String fileName) throws DocumentException {
// 创建saxReader对象
SAXReader reader = new SAXReader();
// 通过read方法读取一个文件 转换成Document对象
Document document = reader.read(new File(fileName));
//获取根节点元素对象
Element node = document.getRootElement();
//遍历所有的元素节点
Map<String, Object> map = getNewMap();
// 处理节点
listNodes(node, map);
return map;
}
/**
* 遍历当前节点元素下面的所有(元素的)子节点
*
* @param node node
*/
public void listNodes(Element node, Map<String, Object> map) {
Map<String, Object> xiaoMap = getNewMap();
String nodeKey = node.getName();
// 获取当前节点的所有属性节点
List<Attribute> list = node.attributes();
// 遍历属性节点
Map<String, Object> attrMap = getNewMap();
for (Attribute attr : list) {
attrMap.put(attr.getName(), attr.getValue());
}
if (ObjectUtil.isNotEmpty(attrMap)) {
xiaoMap.put(TAG_ATTR, attrMap);
}
// 当前节点下面子节点迭代器
Iterator<Element> it = node.elementIterator();
if (!("".equals(node.getTextTrim())) || !it.hasNext()) {
map.put(nodeKey, node.getTextTrim());
}else{
// 不为空
if (ObjectUtil.isEmpty(map.get(nodeKey))) {
map.put(nodeKey, xiaoMap);
} else {
List<Map<String, Object>> childList = null;
// 获取原来的
Object obj = map.get(nodeKey);
if (obj instanceof Iterable) {
// 非第一个
childList = (List<Map<String, Object>>) obj;
childList.add(xiaoMap);
} else if (obj instanceof Map) {
// 第一个
Map<String, Object> childMap = (Map<String, Object>) obj;
childList = new ArrayList<>();
childList.add(childMap);
childList.add(xiaoMap);
}
// 添加新的
map.put(nodeKey, childList);
}
}
// 遍历
while (it.hasNext()) {
// 获取某个子节点对象
Element e = it.next();
// 对子节点进行遍历
listNodes(e, xiaoMap);
}
}
/**
* 获取一个新的map对象
*
* @return map对象
*/
private Map<String, Object> getNewMap() {
Object obj = null;
try {
obj = xmlSort.getMapClass().newInstance();
if (obj instanceof Map) {
return (Map<String, Object>) obj;
}
} catch (InstantiationException | IllegalAccessException e) {
e.printStackTrace();
}
return null;
}
/**
* 设置是否排序
*
* @param xmlSort 是否排序对象
*/
public void setXmlSort(XmlSort xmlSort) {
this.xmlSort = xmlSort;
}
}
5 JavaBean与Xml互转_使用XStream实现，很实用 [强烈推荐使用]
说明：
相对于JAXB，XStream更简洁一些。
常用注解：
- @XStreamAlias：定义xml节点名
- @XStreamAsAttribute：把字段节点设置成属性
5-1 引入XStream依赖
<dependency> <groupId>com.thoughtworks.xstream</groupId> <artifactId>xstream</artifactId> <version>1.4.19</version> </dependency>
5-2 工具类XStreamXmlBeanUtil
import com.thoughtworks.xstream.XStream;
/**
* XStream 实现bean与xml之间相互转换
*/
public class XStreamXmlBeanUtil {
/**
* JavaBean转XML
* @param bean - JavaBean
* @return - XML
*/
public static String toXml(Object bean) {
return initXStream(bean.getClass()).toXML(bean);
}
/**
* XML转JavaBean
* @param xml - XML
* @param beanClazz - JavaBean Class
* @param <T>
* @return - JavaBean
*/
@SuppressWarnings("unchecked")
public static <T> T fromXml(String xml, Class<T> beanClazz) {
return (T) initXStream(beanClazz).fromXML(xml);
}
private static XStream initXStream(Class<?> beanClazz) {
XStream x = new XStream();
x.registerConverter(new DateConverter("yyyy-MM-dd HH:mm:ss", null,TimeZone.getTimeZone("GMT+8")));
//不使用默认的类加载器，需要手动设置类加载器
x.setClassLoader(beanClazz.getClassLoader());
x.processAnnotations(beanClazz);
x.allowTypesByRegExp(new String[]{".*"});
// 开起注解功能
x.autodetectAnnotations(true);
// 忽律未知字段
x.ignoreUnknownElements();
return x;
}
}
5-3 使用实例
import com.thoughtworks.xstream.annotations.XStreamAlias;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
public class Test {
public static void main(String[] args) {
// 1. 普通bean与Xml互转
User user = new User("貂蝉", 18, "女");
System.out.println("============普通bean转Xml===============");
String xml = XStreamXmlBeanUtil.toXml(user);
System.out.println(xml);
System.out.println("============Xml转普通bean===============");
System.out.println(XStreamXmlBeanUtil.fromXml(xml, User.class));
// 2. 继承bean与Xml互转
Child child = new Child("吃糖葫芦");
child.setName("葫芦娃");
child.setAge(2);
child.setGender("男");
child.setHobby("打游戏");
System.out.println("============继承bean转Xml===============");
xml = XStreamXmlBeanUtil.toXml(child);
System.out.println(xml);
System.out.println("============Xml转继承bean====");
// 生成的Xml仅有Child的属性hobby，但转后后的Child对象，父属性都是有值的；
System.out.println(XStreamXmlBeanUtil.fromXml(xml, Child.class));
System.out.println("============Xml转继承bean，测试转换后，父属性、自身属性是否有值====");
Child c2 = XStreamXmlBeanUtil.fromXml(xml, Child.class);
System.out.println( "11111==" + c2.getName() + c2.getGender() + c2.getHobby());
// 输出内容如下：
// ============普通bean转Xml===============
// <Women>
// <name>貂蝉</name>
// <age>18</age>
// <gender>女</gender>
// </Women>
// ============Xml转普通bean===============
// XmlTest.User(name=貂蝉, age=18, gender=女)
// ============继承bean转Xml===============
// <User>
// <name>葫芦娃</name>
// <age>2</age>
// <gender>男</gender>
// <hobby>打游戏</hobby>
// </User>
// ============Xml转继承bean====
// XmlTest.Child(hobby=打游戏)
// 11111==葫芦娃男打游戏
}
}
@Data
@NoArgsConstructor
@AllArgsConstructor
@XStreamAlias("Women")
class User {
private String name;
private int age;
private String gender;
}
@NoArgsConstructor
@AllArgsConstructor
@Data
@XStreamAlias("User")
class Child extends User {
private String hobby;
}
5-4 关于XStream更详细的使用，如设置别名、设置属性、隐藏集合根节点等，请参考如下博文
总结
到此这篇关于Java中操作Xml使用方法备忘录的文章就介绍到这了,更多相关Java操作Xml使用内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！
相关文章
这篇文章主要介绍了Java面向对象程序设计：抽象类，接口用法,结合实例形式分析了java抽象类与接口相关概念、原理、用法与操作注意事项,需要的朋友可以参考下2020-04-04
这篇文章主要介绍了SpringCloud Gateway跨域配置代码实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下2019-11-11
IDEA 2021.3 使用及idea2021.3.1激活使用方法
IDEA 全称 IntelliJ IDEA，是java语言开发的集成环境，IntelliJ在业界被公认为最好的java开发工具之一，今天通过本文给大家介绍idea2021.3.1激活及使用教程，感兴趣的朋友一起看看吧2022-01-01
本次分享的是关于springcloud服务注册与发现的内容，将通过分别搭建服务中心，服务注册，服务发现来说明，非常具有实用价值，需要的朋友可以参考下2018-06-06
这篇文章主要介绍了Java编程二项分布的递归和非递归实现代码实例，小编觉得还是挺不错的，具有一定借鉴价值，需要的朋友可以参考下2018-01-01
我们在设计系统的时候，为了系统的高扩展性，会创建无状态的系统。但是，要使系统具有更好的可扩展性，除了无状态设计之外，还要考虑采用什么负载均衡算法，本文就带领大家认识以下常见的4种负载均衡算法2023-01-01
今天小编就为大家分享一篇关于例举fastJson和jackson转json的区别，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧2018-12-12
ZooKeeper是一个分布式的，开放源码的分布式应用程序协调服务，是Google的Chubby一个开源的实现，是Hadoop和Hbase的重要组件。它是一个为分布式应用提供一致性的软件，提供的功能包括：配置维护、域名服务、分布式同步、组服务等2023-03-03
Java中Map转List及List转Map的方法(简单好用!)
这篇文章主要给大家介绍了关于Java中Map转List及List转Map的相关资料,可以使用Java 8的Stream API将Java Map转换为List,文中通过示例代码介绍的非常详细,需要的朋友可以参考下2023-07-07
最近在看java虚拟相关知识，把每天看到的一些内容做一个归纳总结，下面这篇文章主要给大家介绍了关于Java中内存区域的划分与异常的相关资料，文中通过示例代码介绍的非常详细，需要的朋友可以参考借鉴，下面来一起看看吧2018-06-06
最新评论