Java中操作Xml使用备忘[ Hutool工具类XmlUtil、XStream ]

这篇具有很好参考价值的文章主要介绍了Java中操作Xml使用备忘[ Hutool工具类XmlUtil、XStream ]。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

  • List item

Java中操作Xml使用备忘[ Hutool工具类XmlUtil、XStream ]

第一类 Hutool中XmlUtil工具类

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;
    }
}

第二类 使用XStream封装的工具类【JavaBean与Xml互转,很实用 [强烈推荐使用]】

说明:
相对于JAXB,XStream更简洁一些。
常用注解:
@XStreamAlias:定义xml节点名
@XStreamAsAttribute:把字段节点设置成属性

1 引入XStream依赖

<dependency>
	<groupId>com.thoughtworks.xstream</groupId>
	<artifactId>xstream</artifactId>
	<version>1.4.19</version>
</dependency>

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;
    }
}

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;
}

4 关于XStream更详细的使用,如设置别名、设置属性、隐藏集合根节点等,请参考如下博文

XStream使用详解文章来源地址https://www.toymoban.com/news/detail-736338.html

到了这里,关于Java中操作Xml使用备忘[ Hutool工具类XmlUtil、XStream ]的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Java 使用hutool工具进行导出导入excel表格(代码很简单)

    创建一个Controller进行测试 

    2024年02月07日
    浏览(64)
  • java使用hutool工具类发送http或者https请求太香啦

    我们使用java内置的http工具实现远程调用的时候,都是用try catch包一堆代码,巨难受,今天看见有人使用hutool工具类那是天简单了呀,具体操作如下: 1,引入依赖 2, 如果不需要设置其他什么头信息,代码: 如果是https请求直接换url里面的http就行 返回信息格式: {\\\"code\\\":200

    2024年02月14日
    浏览(34)
  • Java RSA加解密-非对称加密-公钥私钥加解密(使用hutool工具)

    之前一篇帖子(https://blog.csdn.net/u014137486/article/details/136413532)展示了使用原生Java进行RSA加解密,本文介绍下使用当下流行的Hutool工具进行RSA加解密的用法。 目录 一、在Linux环境下生成公钥、私钥文件 二、将生成的公私钥文件导入项目中并移除pem文件的前后公私钥标记 三、po

    2024年04月23日
    浏览(90)
  • 【Java-Util】Hutool工具类判断字符串、对象为空的使用

    判断字符串、包装类、集合、对象是否为空。 字符串工具-StrUtil (hutool.cn) str1为null,str2是字符串,str3为空字符串,str4是包含不可见字符(空格等)的字符串。 使用 StrUtil.isEmpty(str) 和 StrUtil.isBlank(str) 总结: isBlank与 isEmpty(CharSequence) 的区别是: isBlank方法会校验空白字符,且

    2024年02月02日
    浏览(115)
  • 开源.NetCore通用工具库Xmtool使用连载 - XML操作篇

    《上一篇》 介绍了Xmtool工具库中的发送短信类库,今天我们继续为大家介绍其中的XML操作类库。 XML操作是软件开发过程中经常会遇到的情况;包括XML内容的遍历解析,或者特定值内容的查询获取等等。Xmtool工具库提供了一种更方便的方式对Xml进行遍历解析或者对特定节点内

    2024年02月14日
    浏览(38)
  • Java:Hutool工具箱之Hutool-crypto加密解密

    文档 https://hutool.cn/docs/#/crypto/概述 重点单词: 摘自文档 依赖 以MD5 为例 以AES 加密为例 这里有个问题,如果秘钥长度不够16位,会报错 长度只能是16位,24位,32位 参考 https://toscode.gitee.com/dromara/hutool/issues/I4O1EB 以RSA为例

    2024年02月16日
    浏览(78)
  • 干掉复杂的Java工具类,Hutool 工具库确实香~

    Hutool 大家已经比较熟悉了,这是一个超全的 Java 工具库,深受国内开发者的喜爱。 我之前其实是不太喜欢使用这种功能太多的工具类的,也比较担心稳定性和安全性,后面慢慢接受了就感觉其实也还好。而且,我们还可以按需只引入自己需要的功能模块,相对也比较灵活。

    2024年02月03日
    浏览(33)
  • java hutool工具类处理json的常用方法

    Hutool 提供了丰富的 JSON 处理工具类,包括 JSON 字符串的解析、生成、对象与 JSON 字符串的转换等。以下是 Hutool 中关于 JSON 的常用方法: JSON 字符串的解析与生成: JSONUtil.parseObj(jsonStr) :将 JSON 字符串解析为 JSONObject 对象。 JSONUtil.parseArray(jsonStr) :将 JSON 字符串解析为 JSON

    2024年04月17日
    浏览(43)
  • Hutool工具类使用详解

    当今,Java开发者需要处理各种各样的任务,这包括但不限于:日期操作、加密算法、文件操作、Excel数据处理、网络请求等等。而在处理这些任务时,为了提高效率、降低开发难度和复杂度,我们需要借助一些工具类库。Hutool是一个Java工具类库,提供了许多常用的工具类和工

    2023年04月19日
    浏览(38)
  • 使用hutool工具生成树形结构

    假设要构建一个菜单,可以实现智慧库房,菜单的样子如下: 那这种结构如何保存在数据库中呢?一般是这样的: ​ 每条数据根据 parentId 相互关联并表示层级关系, parentId 在这里也叫外键 id parentId name 1 0 智慧库房 2 1 RFID 3 1 智慧大屏 4 1 智能密集架 5 1 环境管控 使用步骤:

    2024年02月14日
    浏览(56)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包