XML 和 JSON 相互转换

已于 2022-12-21 09:14:42 修改
阅读量3.7k 收藏 4
点赞数 1
分类专栏： Json 文章标签： xml to json
于 2022-12-21 09:13:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aa765aa/article/details/128392495
版权

XML 和 JSON 相互转换， 包括 attribute。转换的时候将 XML 属性转换成JSON 的时候， 前面用 @ 特殊字符表示 XML 属性

import java.io.Reader;
import java.io.StringReader;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import org.json.XML;
import org.json.XMLParserConfiguration;
import org.json.XMLTokener;
import org.json.XMLXsiTypeConverter;

public class XMLJson extends XML {

	private static final String ATTR_PREFIX = "@";

    public static JSONObject toJSONObject(Reader reader, XMLParserConfiguration config) throws JSONException {
        JSONObject jo = new JSONObject();
        XMLTokener x = new XMLTokener(reader);
        while (x.more()) {
            x.skipPast("<");
            if(x.more()) {
                parse(x, jo, null, config);
            }
        }
        return jo;
    }

    public static JSONObject toJSONObject(String string) throws JSONException {
        return toJSONObject(string, XMLParserConfiguration.ORIGINAL);
    }


    public static JSONObject toJSONObject(String string, XMLParserConfiguration config) throws JSONException {
        return toJSONObject(new StringReader(string), config);
    }

    public static String toString(Object object) throws JSONException {
        return toString(object, null, XMLParserConfiguration.ORIGINAL);
    }


    public static String toString(final Object object, final String tagName) {
        return toString(object, tagName, XMLParserConfiguration.ORIGINAL);
    }

    /**
     * Convert a JSONObject into a well-formed, element-normal XML string.
     *
     * @param object
     *            A JSONObject.
     * @param tagName
     *            The optional name of the enclosing tag.
     * @param config
     *            Configuration that can control output to XML.
     * @return A string.
     * @throws JSONException Thrown if there is an error parsing the string
     */
    public static String toString(final Object object, final String tagName, final XMLParserConfiguration config)
            throws JSONException {
        StringBuilder sb = new StringBuilder();
        JSONArray ja;
        JSONObject jo;
        String string;

        if (object instanceof JSONObject) {

            // Emit <tagName>
            if (tagName != null) {
                sb.append('<');
                sb.append(tagName);
                sb.append('>');
            }
            int indexAttr = sb.length() - 1;
            // Loop thru the keys.
            // don't use the new entrySet accessor to maintain Android Support
            jo = (JSONObject) object;
            for (final String key : jo.keySet()) {
                Object value = jo.opt(key);
                if (value == null) {
                    value = "";
                } else if (value.getClass().isArray()) {
                    value = new JSONArray(value);
                }

                // Emit content in body
                if (key.equals(config.getcDataTagName())) {
                    if (value instanceof JSONArray) {
                        ja = (JSONArray) value;
                        int jaLength = ja.length();
                        // don't use the new iterator API to maintain support for Android
						for (int i = 0; i < jaLength; i++) {
                            if (i > 0) {
                                sb.append('\n');
                            }
                            Object val = ja.opt(i);
                            sb.append(escape(val.toString()));
                        }
                    } else {
                        sb.append(escape(value.toString()));
                    }

                    // Emit an array of similar keys

                }else if(key.startsWith(ATTR_PREFIX)) {//set attribute
                	StringBuilder ab = new StringBuilder(" ").append(key.substring(1)).append(EQ).append(QUOT).append(escape(value.toString())).append(QUOT);
                	sb.insert(indexAttr, ab);
                	indexAttr = indexAttr + ab.length();
                }else if (value instanceof JSONArray) {
                    ja = (JSONArray) value;
                    int jaLength = ja.length();
                    // don't use the new iterator API to maintain support for Android
					for (int i = 0; i < jaLength; i++) {
                        Object val = ja.opt(i);
                        if (val instanceof JSONArray) {
                            sb.append('<');
                            sb.append(key);
                            sb.append('>');
                            sb.append(toString(val, null, config));
                            sb.append("</");
                            sb.append(key);
                            sb.append('>');
                        } else {
                            sb.append(toString(val, key, config));
                        }
                    }
                } else if ("".equals(value)) {
                    sb.append('<');
                    sb.append(key);
                    sb.append("/>");

                    // Emit a new tag <k>

                } else {
                    sb.append(toString(value, key, config));
                }
            }
            if (tagName != null) {

                // Emit the </tagName> close tag
                sb.append("</");
                sb.append(tagName);
                sb.append('>');
            }
            return sb.toString();

        }

        if (object != null && (object instanceof JSONArray ||  object.getClass().isArray())) {
            if(object.getClass().isArray()) {
                ja = new JSONArray(object);
            } else {
                ja = (JSONArray) object;
            }
            int jaLength = ja.length();
            // don't use the new iterator API to maintain support for Android
			for (int i = 0; i < jaLength; i++) {
                Object val = ja.opt(i);
                // XML does not have good support for arrays. If an array
                // appears in a place where XML is lacking, synthesize an
                // <array> element.
                sb.append(toString(val, tagName == null ? "array" : tagName, config));
            }
            return sb.toString();
        }

        string = (object == null) ? "null" : escape(object.toString());
        return (tagName == null) ? "\"" + string + "\""
                : (string.length() == 0) ? "<" + tagName + "/>" : "<" + tagName
                        + ">" + string + "</" + tagName + ">";

    }

    /**
     * Scan the content following the named tag, attaching it to the context.
     *
     * @param x
     *            The XMLTokener containing the source string.
     * @param context
     *            The JSONObject that will include the new material.
     * @param name
     *            The tag name.
     * @return true if the close tag is processed.
     * @throws JSONException
     */
    private static boolean parse(XMLTokener x, JSONObject context, String name, XMLParserConfiguration config)
            throws JSONException {
        char c;
        int i;
        JSONObject jsonObject = null;
        String string;
        String tagName;
        Object token;
        XMLXsiTypeConverter<?> xmlXsiTypeConverter;

        // Test for and skip past these forms:
        // <!-- ... -->
        // <! ... >
        // <![ ... ]]>
        // <? ... ?>
        // Report errors for these forms:
        // <>
        // <=
        // <<

        token = x.nextToken();

        // <!

        if (token == BANG) {
            c = x.next();
            if (c == '-') {
                if (x.next() == '-') {
                    x.skipPast("-->");
                    return false;
                }
                x.back();
            } else if (c == '[') {
                token = x.nextToken();
                if ("CDATA".equals(token)) {
                    if (x.next() == '[') {
                        string = x.nextCDATA();
                        if (string.length() > 0) {
                            context.accumulate(config.getcDataTagName(), string);
                        }
                        return false;
                    }
                }
                throw x.syntaxError("Expected 'CDATA['");
            }
            i = 1;
            do {
                token = x.nextMeta();
                if (token == null) {
                    throw x.syntaxError("Missing '>' after '<!'.");
                } else if (token == LT) {
                    i += 1;
                } else if (token == GT) {
                    i -= 1;
                }
            } while (i > 0);
            return false;
        } else if (token == QUEST) {

            // <?
            x.skipPast("?>");
            return false;
        } else if (token == SLASH) {

            // Close tag </

            token = x.nextToken();
            if (name == null) {
                throw x.syntaxError("Mismatched close tag " + token);
            }
            if (!token.equals(name)) {
                throw x.syntaxError("Mismatched " + name + " and " + token);
            }
            if (x.nextToken() != GT) {
                throw x.syntaxError("Misshaped close tag");
            }
            return true;

        } else if (token instanceof Character) {
            throw x.syntaxError("Misshaped tag");

            // Open tag <

        } else {
            tagName = (String) token;
            token = null;
            jsonObject = new JSONObject();
            boolean nilAttributeFound = false;
            xmlXsiTypeConverter = null;
            for (;;) {
                if (token == null) {
                    token = x.nextToken();
                }
                // attribute = value
                if (token instanceof String) {
                    string = (String) token;
                    string = new StringBuilder(ATTR_PREFIX).append(string).toString();
                    token = x.nextToken();
                    if (token == EQ) {
                        token = x.nextToken();
                        if (!(token instanceof String)) {
                            throw x.syntaxError("Missing value");
                        }

                        if (config.isConvertNilAttributeToNull()
                                && NULL_ATTR.equals(string)
                                && Boolean.parseBoolean((String) token)) {
                            nilAttributeFound = true;
                        } else if(config.getXsiTypeMap() != null && !config.getXsiTypeMap().isEmpty()
                                && TYPE_ATTR.equals(string)) {
                            xmlXsiTypeConverter = config.getXsiTypeMap().get(token);
                        } else if (!nilAttributeFound) {
                            jsonObject.accumulate(string,
                                    config.isKeepStrings()
                                            ? ((String) token)
                                            : stringToValue((String) token));
                        }
                        token = null;
                    } else {
                        jsonObject.accumulate(string, "");
                    }


                } else if (token == SLASH) {
                    // Empty tag <.../>
                    if (x.nextToken() != GT) {
                        throw x.syntaxError("Misshaped tag");
                    }
                    if (config.getForceList().contains(tagName)) {
                        // Force the value to be an array
                        if (nilAttributeFound) {
                            context.append(tagName, JSONObject.NULL);
                        } else if (jsonObject.length() > 0) {
                            context.append(tagName, jsonObject);
                        } else {
                            context.put(tagName, new JSONArray());
                        }
                    } else {
                        if (nilAttributeFound) {
                            context.accumulate(tagName, JSONObject.NULL);
                        } else if (jsonObject.length() > 0) {
                            context.accumulate(tagName, jsonObject);
                        } else {
                            context.accumulate(tagName, "");
                        }
                    }
                    return false;

                } else if (token == GT) {
                    // Content, between <...> and </...>
                    for (;;) {
                        token = x.nextContent();
                        if (token == null) {
                            if (tagName != null) {
                                throw x.syntaxError("Unclosed tag " + tagName);
                            }
                            return false;
                        } else if (token instanceof String) {
                            string = (String) token;
                            if (string.length() > 0) {
                                if(xmlXsiTypeConverter != null) {
                                    jsonObject.accumulate(config.getcDataTagName(),
                                            stringToValue(string, xmlXsiTypeConverter));
                                } else {
                                    jsonObject.accumulate(config.getcDataTagName(),
                                            config.isKeepStrings() ? string : stringToValue(string));
                                }
                            }

                        } else if (token == LT) {
                            // Nested element
                            if (parse(x, jsonObject, tagName, config)) {
                                if (config.getForceList().contains(tagName)) {
                                    // Force the value to be an array
                                    if (jsonObject.length() == 0) {
                                        context.put(tagName, new JSONArray());
                                    } else if (jsonObject.length() == 1
                                            && jsonObject.opt(config.getcDataTagName()) != null) {
                                        context.append(tagName, jsonObject.opt(config.getcDataTagName()));
                                    } else {
                                        context.append(tagName, jsonObject);
                                    }
                                } else {
                                    if (jsonObject.length() == 0) {
                                        context.accumulate(tagName, "");
                                    } else if (jsonObject.length() == 1
                                            && jsonObject.opt(config.getcDataTagName()) != null) {
                                        context.accumulate(tagName, jsonObject.opt(config.getcDataTagName()));
                                    } else {
                                        context.accumulate(tagName, jsonObject);
                                    }
                                }

                                return false;
                            }
                        }
                    }
                } else {
                    throw x.syntaxError("Misshaped tag");
                }
            }
        }
    }
}

aa765aa
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JSON与XML的互转
weixin_39437203的博客
12-26 540
JSON与XML的互转 一、JOSN转XML //json转换成xml public static String jsonToXml(String json){ //输入流 StringReader input = new StringReader(json); //输出流 StringWriter output = ...
java的xml和json相互转换工具类，亲测直接用
05-26
总的来说，Java中的XML和JSON相互转换是一个常见的任务，通过引入合适的库，如Jackson，可以轻松实现这一功能。在`XmlToJson.java`这个工具类中，我们展示了如何利用Jackson库进行XML与JSON之间的转换。这只是一个...
将json文件转换为xml文件，并写入相关属性
weixin_43453727的博客
08-21 2654
将json文件转换为xml文件，并写入相关属性
解析HTTP响应内容
最新发布
weixin_73725158的博客
06-05 270
在网络编程中，HTTP响应内容通常包含了服务器返回的多种信息，可能是HTML页面、JSON数据、XML文档、图片或其他类型的文件。Python作为一种功能强大的编程语言，提供了多种方法来解析这些响应内容，以便我们能够理解和使用这些数据。在上面的示例中，我们首先发送一个GET请求到指定的URL，然后检查响应的状态码是否为200。通过解析HTTP响应内容，我们可以从服务器获取所需的数据，并在Python程序中进行进一步的处理和使用。对于其他类型的文件，如图片或PDF，我们可能需要使用专门的库来解析。
【工具】XML和JSON互相转换
qq_23334071的博客
08-21 1599
【代码】【工具】XML和JSON互相转换。
Java Json xml 格式之间转换（一）
Jisan_Mo的博客
04-26 6733
实现json转map map转xml 实现 xml中标签属性的插入 和命令空间属性的插入测试xml报文如下 xml单标签转json数组 json转map 方法 map转xml json-lib实现xml转json 转换根节点为顶级对象 json-lib 如果需要转换json后没有根节点ForceTopLevelObject设为false 反之true 某些场景xml转json后会默认存在o顶级对象节点可以设为false 额外记录 mybatisplus StringPool常用符号常量...
coco json转xml格式(开箱即用代码)
weixin_38252409的博客
12-25 653
最近使用很多其它模型，大多模型都有自己对应格式，有时其它模型的cocojson格式的数据测试也都要进行数据格式转换，有时候也想看coco json注释显示在图上。那么，你可能需要一个coco json格式转xml格式代码，帮助查看，且我总是会把这些工具代码莫名丢失，重头写较为麻烦。为克服这些问题，本文将使用coco数据集格式作为标准，记录如何将coco数据格式转为xml格式。
JAVA中将XML转JSON
weixin_50003028的博客
11-22 4211
整理了下网上能找到的常见两种xml->json的方式，主要是使用json-lib包或者org.json包进行转换最后面是现成的工具类。
goxml2json：用Go编写的XML到JSON转换器（无模式，无结构）
02-03
将XML转换为JSON的Go软件包 安装 go get -u github.com/basgys/goxml2json 输入 import github.com/basgys/goxml2json 用法 代码示例 package main import ( "fmt" "strings" xj "github....
xml json互相转化
03-21
了解如何在XML和JSON之间进行转换是IT行业中的一项基本技能，特别是在处理API交互和数据解析时。本文将深入探讨这两种格式的特点以及它们之间的转换方法。 XML是一种标记语言，它的结构严谨，支持自定义标签，并...
如何在JS中实现相互转换XML和JSON
10-21
下面先是跟大家分别介绍了JSON与XML以及它们的区别比较，后又分享关于JavaScript实现XML与JSON互转例子，希望这些例子能给你带来帮助。
Xml和Json互转工具类
04-17
本实例主要是通过json-libjar包中的工具类进行操作，简单实现了xml字符串和json字符串之间的转化，xml文件和json文件的转化。而且还兼容jsonObject和jsonArray两种格式，自己摸索，记录一下以便学习。
通过fastjson实现各种格式与json之间的转换
03-22
通过fastjson实现了JavaBean，list，MAP,list等格式与json格式之间的转换，已经附带fastjson的包，包的版本为fastjson-1.1.36.jar
json和xml互转.jar
04-08
用于json字符串和xml字符串之间的相互转换。 特点：简单、方便、快捷
Python中xml和json格式相互转换操作示例
09-19
主要介绍了Python中xml和json格式相互转换操作,结合实例形式分析了xmltodict库的安装及xml格式与json格式数据相互转换操作技巧,需要的朋友可以参考下
XML转JSON格式
blizzardSniper的博客
12-18 788
XML转化为JSON，封装为工具类，遇到返回的XML可以直接解析。
一文帮你完美解决Json和Xml相互转换
时光有伱，记忆成花~
04-22 5117
我们经常会碰到Json和Xml相互转换，但是转换过程中经常出现各种奇葩问题，比如多节点了或少节点了，或者转换后的格式不对，多了空数组，还有就是遇到带属性的xml格式转换完之后属性没了等等，今天就手把手教你完美解决这些坑。上代码 1、导入用到的jar包 <dependency> <groupId>net.sf.json-lib</groupId> &lt...
XML 转 JSON
qq_38220837的博客
08-10 5607
xml格式 转 json格式
JSON does not allow non-finite numbers
attackers的博客
12-30 618
问题： JSON does not allow non-finite numbers 哇， NaN
Java xml和json互转
04-25
可以使用Java中的Jackson库来实现JSON和XML之间的相互转换。首先，需要添加Jackson的依赖： ``` <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.11.4</version> </dependency> ``` 接下来，可以使用以下代码将JSON转换为XML： ```java ObjectMapper mapper = new XmlMapper(); JsonNode json = mapper.readTree(jsonString); String xml = mapper.writeValueAsString(json); ``` 其中，jsonString是一个包含JSON数据的字符串。将XML转换为JSON的代码如下： ```java ObjectMapper mapper = new XmlMapper(); JsonNode json = mapper.readTree(xmlString.getBytes()); String json = mapper.writeValueAsString(json); ``` 其中，xmlString是一个包含XML数据的字符串。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值