XML与JSON互相转化工具类

最新推荐文章于 2024-08-22 14:06:14 发布
最新推荐文章于 2024-08-22 14:06:14 发布
阅读量2.1w 收藏 12
点赞数 1
分类专栏： 工具类 文章标签： json java xml dom
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44248490/article/details/109184193
版权

需要用到的net.sf.json和org.dom4j
本例用的包为：
json-lib-2.4-jdk15.jar
dom4j-1.6.1.jar

引入包之后，直接复制下面这个工具类使用

package com.java;

import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;

import java.io.*;
import java.util.Arrays;
import java.util.List;

/**
 * JSON与XML互转，工具类
 */
public class JsonXmlUtil {

    private static final char EOFC = (char) -1;

    /**
     * JSON 转 XML
     *
     * @param jsonString JSON字符串
     */
    public static String getXmlFromJson(String jsonString) throws IOException {
        InputStream in = new ByteArrayInputStream(jsonString.getBytes());
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        translate(in, out);
        return out.toString();
    }

    /**
     * 将xml转换为JSON对象
     *
     * @param xml xml字符串
     */
    public static JSONObject getJsonFromXml(String xml) throws Exception {
        return getJsonFromXml(xml, "");
    }

    /**
     * 将xml转换为JSON对象
     *
     * @param xml             xml字符串
     * @param parseArrayNames （如果xml中的一个节点不是数组，而你又需要将它转化为json数组），请填写该节点名称，多个值时用逗号分隔
     * @return
     * @throws Exception
     */
    public static JSONObject getJsonFromXml(String xml, String parseArrayNames) throws DocumentException {
        JSONObject jsonObject = new JSONObject();
        Document document = DocumentHelper.parseText(xml);
        //获取根节点元素对象
        Element root = document.getRootElement();
        iterateNodes(root, jsonObject, parseArrayNames);
        return jsonObject;
    }

    /**
     * 将 JSON输入流 转化为 XML输出流
     */
    private static void translate(InputStream in, OutputStream out) throws IOException, IllegalArgumentException {
        InputStreamReader re = new InputStreamReader(in);
        char c;
        while ((c = (char) re.read()) != EOFC) {
            switch (c) {
                case '{':
                    translateObject(re, out);
                    break;
                case '[':
                    translateArray(re, out, null);
                    break;
                default:
                    if (Character.isSpaceChar(c)) {
                        break;
                    } else {
                        throw new IllegalArgumentException("invalid character:" + c + " (" + (int) c + ")");
                    }
            }
        }
    }

    private static void translateArray(InputStreamReader re, OutputStream out, String tname) throws IOException, IllegalArgumentException {
        char c;
        while ((c = (char) re.read()) != EOFC) {
            switch (c) {
                case '{':
                    translateObject(re, out);
                    break;
                case '[':
                    translateArray(re, out, tname);
                    break;
                case ',':
                    if (tname != null) {
                        out.write("</".getBytes());
                        out.write(tname.getBytes());
                        out.write("><".getBytes());
                        out.write(tname.getBytes());
                        out.write(">".getBytes());
                    }
                    break;
                case ']':
                    return;
                case '"':
                    String n = readStringToken(re);
                    if (n != null) {
                        out.write(n.getBytes());
                    }
                    break;
                default:
                    if (Character.isSpaceChar(c)) {
                        break;
                    } else {
                        out.write(("" + c).getBytes());
                    }
            }
        }
    }

    private static String readStringToken(InputStreamReader re) throws IOException {
        StringBuilder b = new StringBuilder();
        char c;
        boolean esc = false;
        while ((c = (char) re.read()) != EOFC) {
            switch (c) {
                case '\\':
                    esc = true;
                    break;
                case 'n':
                    if (!esc) {
                        b.append(c);
                    } else {
                        b.append((char) 10);
                        esc = false;
                    }
                    break;
                case 'r':
                    if (!esc) {
                        b.append(c);
                    } else {
                        b.append((char) 13);
                        esc = false;
                    }
                    break;
                case 't':
                    if (!esc) {
                        b.append(c);
                    } else {
                        b.append((char) 9);
                        esc = false;
                    }
                    break;
                case 'u':
                    if (!esc) {
                        b.append(c);
                    } else {
                        StringBuilder sb = new StringBuilder(6);
                        sb.append("0x");
                        sb.append((char) re.read());
                        sb.append((char) re.read());
                        sb.append((char) re.read());
                        sb.append((char) re.read());
                        b.append((char) Integer.decode(sb.toString()).intValue());
                        esc = false;
                    }
                    break;
                case '"':
                    if (!esc) {
                        return b.toString();
                    }
                default:
                    b.append(c);
                    esc = false;
            }
        }
        return b.toString();
    }

    private static boolean translateValue(InputStreamReader re, OutputStream out, String tname) throws IOException, IllegalArgumentException {
        char c;
        while ((c = (char) re.read()) != EOFC) {
            switch (c) {
                case '[':
                    translateArray(re, out, tname);
                    return false;
                case '{':
                    translateObject(re, out);
                    return false;
                case '"':
                    String v = readStringToken(re);
                    outs(out, v);
                    return false;
                case 'n':
                    re.read(); // u
                    re.read(); // l
                    re.read(); // l
                    return false;
                case ' ':
                    break;
                case '}':
                    return true;
                case ',':
                    return false;
                default:
                    outc(out, c);
                    break;
            }
        }
        return false;
    }

    private static void outs(OutputStream out, String s) throws IOException {
        if (s != null) {
            for (int i = 0, l = s.length(); i < l; i++) {
                outc(out, s.charAt(i));
            }
        }
    }

    private static void outc(OutputStream out, char c) throws IOException {
        switch (c) {
            case '<':
                out.write("&lt;".getBytes());
                break;
            case '>':
                out.write("&gt;".getBytes());
                break;
            case '\"':
                out.write("&quot;".getBytes());
                break;
            case '&':
                out.write("&amp;".getBytes());
                break;
            case '\'':
                out.write("&apos;".getBytes());
                break;
            default:
//                if (c > 0x7f) {
//                    if (c < 0x400 || c > 0x4FF) {
//                        out.write(("&#" + ((int) c) + ";").getBytes());
//                    } else {
//                        out.write(("" + c).getBytes());
//                    }
//                } else {
//                    out.write(("" + c).getBytes());
//                }
                out.write(("" + c).getBytes());
        }
    }

    private static void translateObject(InputStreamReader re, OutputStream out) throws IOException, IllegalArgumentException {
        char c;
        String field = null;
        while ((c = (char) re.read()) != EOFC) {
            switch (c) {
                case ':':
                    if (field != null) {
                        out.write("<".getBytes());
                        out.write(field.getBytes());
                        out.write(">".getBytes());
                    }
                    boolean eoo = translateValue(re, out, field);
                    if (field != null) {
                        out.write("</".getBytes());
                        out.write(field.getBytes());
                        out.write(">".getBytes());
                    }
                    if (eoo) {
                        return;
                    }
                    break;
                case '"':
                    field = readStringToken(re);
                    break;
                case '}':
                    return;
                default:
            }
        }
    }

    /**
     * 遍历元素
     *
     * @param node 元素
     * @param json 将元素遍历完成之后放进JSON对象
     */
    private static void iterateNodes(Element node, JSONObject json, String parseArrayNames) {
        //获取当前元素的名称
        String nodeName = node.getName();
        List<String> parseArrayNamesList = Arrays.asList(parseArrayNames.split(","));
        //判断已遍历的JSON中是否已经有了该元素的名称
        if (json.containsKey(nodeName) || parseArrayNamesList.contains(nodeName)) {
            //该元素在同级下有多个
            Object Object = json.get(nodeName);
            JSONArray array = new JSONArray();
            if (Object instanceof JSONArray) {
                array = (JSONArray) Object;
            } else if (Object != null) {
                array = new JSONArray();
                array.add(Object);
            }
            //获取该元素下所有子元素
            List<Element> listElement = node.elements();
            if (listElement.isEmpty()) {
                //该元素无子元素，获取元素的值
                String nodeValue = node.getTextTrim();
                array.add(nodeValue);
                json.put(nodeName, array);
                return;
            }
            //有子元素
            JSONObject newJson = new JSONObject();
            //遍历所有子元素
            for (Element e : listElement) {
                //递归
                iterateNodes(e, newJson, parseArrayNames);
            }
            array.add(newJson);
            json.put(nodeName, array);
            return;
        }
        //该元素同级下第一次遍历
        //获取该元素下所有子元素
        List<Element> listElement = node.elements();
        if (listElement.isEmpty()) {
            //该元素无子元素，获取元素的值
            String nodeValue = node.getTextTrim();
            json.put(nodeName, nodeValue);
            return;
        }
        //有子节点，新建一个JSONObject来存储该节点下子节点的值
        JSONObject object = new JSONObject();
        //遍历所有一级子节点
        for (Element e : listElement) {
            //递归
            iterateNodes(e, object, parseArrayNames);
        }
        json.put(nodeName, object);
        return;
    }
}

用法示例：

import net.sf.json.JSONObject;

import static com.java.JsonXmlUtil.getJsonFromXml;
import static com.java.JsonXmlUtil.getXmlFromJson;

public class MyTest3 {
    public static void main(String[] args) throws Exception {
        //json转xml
        String jsonString = "{\"result\":{\"userList\":[{\"name\":\"zs\",\"age\":21},{\"name\":\"bb\",\"age\":35}]}}";
        String xml = getXmlFromJson(jsonString);
        System.out.println("输入的json为：");
        System.out.println(jsonString);
        System.out.println("输出的xml为：");
        System.out.println(xml);
        System.out.println("------------------------" + "分割线" + "------------------------");
        //xml转json
        String input_xml = "<result>" +
                "<userList><name>zs</name><age>21</age></userList>" +
                "<userList><name>bb</name><age>35</age></userList>" +
                "</result>";
        //JSONObject json = getJsonFromXml(input_xml);//减少xml中userList的个数到1个，对比一下两者的区别
        JSONObject json = getJsonFromXml(input_xml, "userList");
        System.out.println("输入的xml为：");
        System.out.println(input_xml);
        System.out.println("输出的json为：");
        System.out.println(json);
    }
}

效果展示：
xml与json互转结果展示

weixin_44248490
关注
专栏目录
JSON对象与XML互相转换
kugeliujian的博客
11-29 350
java对象转换xml比较麻烦，所以可以把对象转换为JSON再把JSON转换为XML 降低复杂度。此工具类依赖于json-lib、fastjson、dom4j等jar包 代码工具： package com.bsoft.commons.utils; import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSONArray; im...
xml与json互转 C语言实现,C# XML与Json之间相互转换
weixin_29163581的博客
05-19 715
XML转换为Json字符串在代码中预定义的一个xml字符串，如下：string xml = @"Alanhttp://www.jb51.netLouishttp://www.jb51.net";然后把预定的xml字符串加载到xmlDocument对象中：mlDocument doc = new XmlDocument();doc.LoadXml(xml);然后通过Json.Net类库中专有的方法进...
XML转JSON工具类
09-30
XML转JSON工具类，支持多层XML嵌套解析转JSON,采用dom4j解析转JSON格式，多次线上环境使用
【工具类】Java优雅的将XML转为JSON格式、XML转JSON
最新发布
张三博客
08-22 531
注：可以根据不同的业务场景来进行选择 提供URL 直接读取和File文件及InputStream流数据等。
发送xml的http请求并返回xml消息体--例子 .
weixin_34148340的博客
06-14 460
发送xml的http请求并返回xml消息体--例子 .public class SendAndGetXml {   public static void main(String[] args) throws Exception     {           String rqestXml = "";   String urls="";        try   {               ...
Xml和Json互转工具类
04-17
本实例主要是通过json-libjar包中的工具类进行操作，简单实现了xml字符串和json字符串之间的转化，xml文件和json文件的转化。而且还兼容jsonObject和jsonArray两种格式，自己摸索，记录一下以便学习。
XmlToJson:基于 QT 的实用程序可将 XML 文件转换为 Json 文件，反之亦然
07-06
3. 将数据结构转化为 JSON：数据结构然后被转换为 JSON 格式，QT 的 QJsonDocument 和 QJsonObject 类可以用来构建和序列化 JSON 对象。 4. 保存 JSON 文件：最后，转换后的 JSON 数据被写入新的文件中。 相反，从 ...
Xml、Json、实体类之间的转换案例
11-22
本文将深入探讨XML与JSON的特性和它们与Java中的实体类之间的转换方法，提供一个实际的案例分析。 XML是一种结构化数据表示方式，用于存储和传输数据。它使用标签来定义元素和属性，提供了丰富的结构，适合复杂的...
XMLJson：用于将任何XML转换为JSON格式的Swift CLI工具
02-06
XMLJson 是一个基于 Swift 的命令行接口（CLI）工具，其主要功能是将XML数据转换成JSON格式。这个工具对于开发者来说非常有用，因为它能够帮助处理XML和JSON这两种广泛使用的数据交换格式之间的转换。XML（可扩展...
xml与json互转工具类
09-10
JsonTest是xml与json字符互转的工具类，方便，通用性强。JsonEasyView是对json数据格式化显示的工具类。
xml/Json转换工具类
05-31
文件中有maven依赖，将其复制到pom文件中就可以直接使用。里面有注释，代码简洁易懂。(除了注释只有四五行)
java的xml和json相互转换工具类，直接用
10-17
实现的一个简单的基于java 的，可以在xml和json之间相互转换的工具类，因为实在没有积分了，所以要点积分，希望理解~
json转xml插件工具
06-01
- JQuery - jquery.json2xml.js - jquery.xml2json.js 2. XML 字符串转换成 JSON 对象 $.xml2json(str); 3. JSON 对象转换成 XML 字符串 $.json2xml(obj);
XML转换为JSON
03-12
XML转换为JSON：效率更高，支持STRING定义和文件方式
xml转json
晨曦的博客
12-26 581
import org.dom4j.Attribute; import org.dom4j.Document; import org.dom4j.DocumentException; import org.dom4j.DocumentHelper; import org.dom4j.Element; import com.alibaba.fastjson.JSONArray; import co...
Java XML转JSON工具类
cl617287的博客
07-23 296
最近对接微信发现很多接口数据用的还是XML格式，所以为了方便使用我们给它转成JSON格式的，这里特别处理了一下多层嵌套的问题。
java http返回的xml格式转成json格式
lin的专栏
09-12 3950
package Yishikeji.Hbase.Admin.Hbase; import java.io.InputStream; import java.net.URL; import java.net.URLConnection; public class HdfsClusterTest { public static void json() throws Exception{ ...
xml和json互转工具类
for_the_time_begin
08-30 2608
分享一个json与xml互转的工具类，非常好用
xml2json 工具类
12-04
XML2JSON工具类是指一个用于将XML数据转换为JSON格式的工具类。XML和JSON都是常用的数据交换格式，而在某些情况下，我们可能需要将XML数据转换为JSON格式来实现数据的处理和交互。 XML2JSON工具类的主要功能包括解析XML数据并将其转换为JSON格式的数据。它可以将XML标签和属性转换为对应的JSON键值对，并且支持层级结构的转换。例如，一个XML节点可以被转换为JSON的一个键值对，其中键表示节点的名称，值表示节点的值或属性。而多层级的XML结构也可以转换为相应的嵌套的JSON结构。 XML2JSON工具类的实现通常基于一些XML解析库，通过解析XML文档的节点、标签和属性，将其转换为JSON数据结构。在转换过程中，可以选择性地过滤和转换特定的节点或属性，以满足具体的需求。 使用XML2JSON工具类可以方便地处理从XML格式到JSON格式的转化，提供了更便捷和灵活的数据操作方式。例如，我们可以通过XML2JSON工具类将从服务器返回的XML数据转换为JSON格式，然后在前端进行操作和展示。同时，JSON格式具有更简洁、易读和易处理的特点，能够提供更好地用户体验和数据交互效果。 总之，XML2JSON工具类是一种能够实现XML到JSON转换的工具，能够提供更方便和灵活的数据操作方式，满足不同需求下的数据处理和交互。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值