xml与json互相转换

最新推荐文章于 2024-06-18 16:17:33 发布
最新推荐文章于 2024-06-18 16:17:33 发布
阅读量6.3k 收藏 11
点赞数 4
分类专栏： xml 文章标签： xml
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jincheng_921/article/details/90408630
版权 


import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import org.dom4j.*;

import java.util.List;
import java.util.Set;

/**
 * @author
 */
public class XmlConvert {
    /**
     * 属性名前缀
     */
    private String attributeNamePrefix;
    /**
     * 文本键名称
     */
    private String textKey;
    /**
     * 移除xml头文件，<?xml version="1.0" encoding="UTF-8"?>
     */
    private boolean removeHeader;

    public XmlConvert() {
        this.setAttributeNamePrefix("@");
        this.setTextKey("#text");
        this.setRemoveHeader(true);
    }

    public XmlConvert(String attributeNamePrefix, String textKey) {
        this(attributeNamePrefix, textKey, true);
    }

    public XmlConvert(String attributeNamePrefix, String textKey, boolean removeHeader) {
        this.attributeNamePrefix = attributeNamePrefix;
        this.textKey = textKey;
        this.removeHeader = removeHeader;
    }

    /**
     * json转xml<br/>
     * {"abc":["aa","bb"]},此种格式的json串不支持，无根节点； 格式应该为：{"root":{"abc":["aa","bb"]}}
     *
     * @param json
     * @return
     */
    public String jsonToXml(String json) {
        JSONObject jsonObject = JSON.parseObject(json);
        Set<String> keySet = jsonObject.keySet();
        if (!keySet.isEmpty() && keySet.size() == 1) {
            // 将第一个节点name，作为根节点
            String rootName = keySet.iterator().next();
            Element rootElement = DocumentHelper.createElement(rootName);
            Element element = processObject(jsonObject.get(rootName), rootElement);
            String xml = DocumentHelper.createDocument(element).asXML();
            if (isRemoveHeader()) {
                xml = removeHeader(xml);
            }
            return xml;
        } else {
            throw new RuntimeException("The json text is not formatted correctly");
        }
    }

    private Element processObject(Object object, Element element) {
        if (object instanceof JSONObject) {
            return processJSONObject((JSONObject) object, element);
        } else if (object instanceof JSONArray) {
            return processJSONArray((JSONArray) object, element, element.getName());
        } else {
            return processText(object.toString(), element);
        }
    }

    private static Element processText(String text, Element element) {
        element.setText(text);
        return element;
    }

    private Element processJSONObject(JSONObject jsonObject, Element element) {
        jsonObject.forEach((key, value) -> {
            if (key.startsWith(getAttributeNamePrefix())) {
                element.addAttribute(key.substring(getPrefixLength()), value.toString());
            } else if (key.equals(getTextKey())) {
                element.setText(value.toString());
            } else {
                processValue(element, key, value);
            }
        });
        return element;
    }

    private void processValue(Element element, String name, Object value) {
        if (value instanceof JSONObject) {
            Element tempElement = processJSONObject((JSONObject) value, DocumentHelper.createElement(name));
            element.add(tempElement);
        } else if (value instanceof JSONArray) {
            JSONArray jsonArray = (JSONArray) value;
            int size = jsonArray.size();
            for (int i = 0; i < size; i++) {
                processValue(element, name, jsonArray.get(i));
            }
        } else {
            Element temp = processText(value.toString(), DocumentHelper.createElement(name));
            element.add(temp);
        }
    }

    private Element processJSONArray(JSONArray jsonArray, Element root, String name) {
        int size = jsonArray.size();
        for (int i = 0; i < size; ++i) {
            processValue(root, name, jsonArray.get(i));
        }
        return root;
    }

    /**
     * xml转json
     *
     * @param xml
     * @return
     */
    public String xmlToJson(String xml) {
        try {
            Document document = DocumentHelper.parseText(xml);
            Element rootElement = document.getRootElement();
            JSON json = processObjectElement(rootElement);
            JSONObject jsonObject = new JSONObject();
            jsonObject.put(rootElement.getName(), json);
            return jsonObject.toJSONString();
        } catch (DocumentException e) {
            throw new RuntimeException("The XML text is not formatted correctly", e);
        }
    }

    private JSONObject processObjectElement(Element element) {
        if (element == null) {
            return new JSONObject();
        }
        JSONObject jsonObject = new JSONObject();

        List<Attribute> attributes = element.attributes();
        for (Attribute attribute : attributes) {
            String attributeName = getAttributeNamePrefix() + attribute.getName();
            String attributeValue = attribute.getValue();
            setOrAccumulate(jsonObject, attributeName, attributeValue);
        }

        int nodeCount = element.nodeCount();
        for (int i = 0; i < nodeCount; i++) {
            Node node = element.node(i);
            if (node instanceof Text) {
                Text text = (Text) node;
                setOrAccumulate(jsonObject, getTextKey(), text.getText());
            } else if (node instanceof Element) {
                setValue(jsonObject, (Element) node);
            }
        }

        return jsonObject;
    }

    private void setValue(JSONObject jsonObject, Element element) {
        if (isObject(element)) {
            JSONObject elementJsonObj = processObjectElement(element);
            setOrAccumulate(jsonObject, element.getName(), elementJsonObj);
        } else {
            setOrAccumulate(jsonObject, element.getName(), element.getStringValue());
        }
    }

    private boolean isObject(Element element) {
        int attributeCount = element.attributeCount();
        if (attributeCount > 0) {
            return true;
        }

        int attrs = element.nodeCount();
        if (attrs == 1 && element.node(0) instanceof Text) {
            return false;
        } else {
            return true;
        }
    }

    private void setOrAccumulate(JSONObject jsonObject, String key, Object value) {
        if (jsonObject.containsKey(key)) {
            Object obj = jsonObject.get(key);
            if (obj instanceof JSONArray) {
                // 若为数组直接添加
                ((JSONArray) obj).add(value);
            } else {
                // 若为非数组，创建数组（已存在的值obj,待添加的值value）
                JSONArray jsonArray = new JSONArray();
                jsonArray.add(obj);
                jsonArray.add(value);
                jsonObject.put(key, jsonArray);
            }
        } else {
            jsonObject.put(key, value);
        }
    }

    /**
     * 移除xml报文头
     *
     * @param source
     * @return
     */
    private String removeHeader(String source) {
        return source.replace("<?xml version=\"1.0\" encoding=\"UTF-8\"?>", "")
                .replaceAll("\r|\n", "");
    }


    public String getAttributeNamePrefix() {
        return attributeNamePrefix;
    }

    public void setAttributeNamePrefix(String attributeNamePrefix) {
        this.attributeNamePrefix = attributeNamePrefix;
    }

    public String getTextKey() {
        return textKey;
    }

    public void setTextKey(String textKey) {
        this.textKey = textKey;
    }

    public boolean isRemoveHeader() {
        return removeHeader;
    }

    public void setRemoveHeader(boolean removeHeader) {
        this.removeHeader = removeHeader;
    }

    private int getPrefixLength() {
        return this.attributeNamePrefix.length();
    }

}





import net.sf.json.JSON;
import net.sf.json.JSONSerializer;
import net.sf.json.xml.XMLSerializer;

/**
 * @author
 */
public class XmlJsonUtils {
    private XmlJsonUtils() {
    }

    /**
     * xml转json,默认忽略根节点
     *
     * @param xml
     * @return
     */
    @Deprecated
    public static String xmlToJsonStr(String xml) {
        return xmlToJsonStr(xml, false);
    }

    /**
     * xml转json
     *
     * @param xml
     * @param forceTopLevelObject 显示(解析)根节点
     * @return
     */
    @Deprecated
    public static String xmlToJsonStr(String xml, boolean forceTopLevelObject) {
        XMLSerializer xmlSerializer = new XMLSerializer();
        xmlSerializer.setForceTopLevelObject(forceTopLevelObject);
        return xmlSerializer.read(xml).toString();
    }

    /**
     * json转xml,默认根节点为o
     *
     * @param jsonStr
     * @return
     */
    @Deprecated
    public static String jsonToXml(String jsonStr) {
        return jsonToXml(jsonStr, "");
    }

    /**
     * json转xml
     *
     * @param jsonStr
     * @param rootName 可设置根节点
     * @return
     */
    @Deprecated
    public static String jsonToXml(String jsonStr, String rootName) {
        return jsonToXml(jsonStr, rootName, null);
    }

    /**
     * @param jsonStr
     * @param rootName
     * @param elementName
     * @return
     */
    @Deprecated
    public static String jsonToXml(String jsonStr, String rootName, String elementName) {
        XMLSerializer xmlSerializer = new XMLSerializer();
        // 关闭类型提示
        xmlSerializer.setTypeHintsEnabled(false);
        // 设置根节点名称
        xmlSerializer.setRootName(rootName);
        xmlSerializer.setElementName(elementName);
        JSON json = getJSON(jsonStr);
        String xmlStr = xmlSerializer.write(json);
        return removeHeaderMessage(xmlStr);
    }

    /**
     * 移除xml报文头
     *
     * @param source
     * @return
     */
    @Deprecated
    private static String removeHeaderMessage(String source) {
        return source.replace("<?xml version=\"1.0\" encoding=\"UTF-8\"?>", "").replaceAll("\r|\n", "");
    }

    /**
     * json串转换为json对象
     *
     * @param jsonStr
     * @return
     */
    @Deprecated
    private static JSON getJSON(String jsonStr) {
        return JSONSerializer.toJSON(jsonStr);
    }

    // 新的xml与json互相转换

    /**
     * xml转json
     *
     * @param xml                 待转换的xml
     * @param attributeNamePrefix xml属性名前缀
     * @param textKey             xml文本键名称
     * @return
     */
    public static String xmlToJSON(String xml, String attributeNamePrefix, String textKey) {
        XmlConvert xmlConvert = new XmlConvert(attributeNamePrefix, textKey);
        return xmlConvert.xmlToJson(xml);
    }

    /**
     * xml转json<br/>
     * 默认xml文本键名称为:#text
     *
     * @param xml                 待转换的xml
     * @param attributeNamePrefix xml属性名前缀
     * @return
     */
    public static String xmlToJSON(String xml, String attributeNamePrefix) {
        return xmlToJSON(xml, attributeNamePrefix, "#text");
    }

    /**
     * xml转json<br/>
     * 默认xml文本键名称为:#text,xml属性名前缀为'@'
     *
     * @param xml 待转换的xml
     * @return
     */
    public static String xmlToJSON(String xml) {
        return xmlToJSON(xml, "@");
    }


    /**
     * json转xml
     *
     * @param json                待转换的json串
     * @param attributeNamePrefix 转换后的xml属性名前缀
     * @param textKey             转换后的xml文本键名称
     * @param removeHeader        移除xml头文件
     * @return
     */
    public static String jsonToXML(String json, String attributeNamePrefix, String textKey, boolean removeHeader) {
        XmlConvert xmlConvert = new XmlConvert(attributeNamePrefix, textKey, removeHeader);
        return xmlConvert.jsonToXml(json);
    }

    /**
     * json转xml<br/>
     * 默认转换后移除xml头文件
     *
     * @param json                待转换的json串
     * @param attributeNamePrefix 转换后的xml属性名前缀
     * @param textKey             转换后的xml文本键名称
     * @return
     */
    public static String jsonToXML(String json, String attributeNamePrefix, String textKey) {
        return jsonToXML(json, attributeNamePrefix, textKey, true);
    }

    /**
     * json转xml<br/>
     * 默认转换后移除xml头文件,xml文本键名称为#text
     *
     * @param json                待转换的json串
     * @param attributeNamePrefix 转换后的xml属性名前缀
     * @return
     */
    public static String jsonToXML(String json, String attributeNamePrefix) {
        return jsonToXML(json, attributeNamePrefix, "#text", true);
    }

    /**
     * json转xml<br/>
     * 默认转换后移除xml头文件,xml文本键名称为#text,属性名前缀为'@'
     *
     * @param json 待转换的json串
     * @return
     */
    public static String jsonToXML(String json) {
        return jsonToXML(json, "@");
    }

}



        <!-- xml 解析 start -->
        <dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>1.6.1</version>
        </dependency>

        <dependency>
            <groupId>net.sf.json-lib</groupId>
            <artifactId>json-lib</artifactId>
            <version>2.4</version>
            <classifier>jdk15</classifier>
        </dependency>
        <!-- xml解析end -->
焱鋮
关注
  • 4
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
json转换xml
yq337744的博客
05-26 167
1.相关依赖 <dependency> <groupId>dom4j</groupId> <artifactId>dom4j</artifactId> <version>1.6.1</version> </dependency> <!--json--> <dependency>.
js实现json和xml之互转
wuhawang的博客
10-08 1万+
在web工程里面，可能需要经常使用到xml和web的互转功能， 在这里，使用万恶的百度之后，发现用java实现效率和效果很差，json转成xml会出现一些类的头，比如,这类的，找了很多方法都没有能够消除 鉴于js对json的良好支持，所以我们在前端使用js进行转化，发送到conroller 在这里，简单说下找到这个方法的“心路历程”，真是累，不过解决完以后还是很开心的 1.
XML 和 JSON 相互转换
churchill的专栏
12-21 3701
xml 和 json 互转
JSON及xml互相转换
神奇少年的博客
05-26 1685
1、Json转换为XML并保存。​注意:格式一定要注意正确。2、Xml转换为Json。
FastJson==xml与json格式互转工具类
卓越之识论道，平常之识论事，狭隘之识论人
05-08 1022
FastJson==xml与json格式互转工具类
XML转换成JSON
Twinkle_sone的博客
06-07 1万+
相信大家对 XML 都不会很陌生了，XML 被设计用来结构化、存储以及传输信息。最近在开发过程中发现，有一些旧接口返回的数据格式即是 XML 的格式，因此需要我们对返回的 XML 数据进行解析，转换成我们好处理的 JSON 数据结构，对此我花了一点时间写了一个简单的 XML 转换 JSON 格式的方法，所以也就有了今天的这一篇文章，虽然实现起来并不难，但还是希望这一篇文章可以对有需要的同学起到一丢丢的帮助。
json、javaBean、xml互转的几种工具介绍
热门推荐
清风抚白杨
11-29 4万+
package cn.shopex.util; import java.io.IOException; import java.io.InputStream; import java.util.ArrayList; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import net.sf
JSON和XML相互转换
cool
12-06 1199
XML和JSON的相互转换
json与xml互相转换工具类
03-10
json与xml互相转换工具类
php实现xml与json之间的相互转换功能实例
10-21
此外，为了帮助开发者进行调试和测试，网上有一些在线工具，例如XML/JSON互相转换工具，PHP代码格式化工具等。这些工具可以极大地简化开发过程，提高效率。 对于PHP开发人员来说，理解和掌握XML与JSON之间的转换...
json-xml报文互相转换
01-12
json和xml报文互相转换的源码，可以自己编译打成jar包使用。
通过fastjson实现各种格式与json之间的转换
03-22
通过fastjson实现了JavaBean，list，MAP,list等格式与json格式之间的转换，已经附带fastjson的包，包的版本为fastjson-1.1.36.jar
JSON与XML转换jar包
08-26
JSON与XML之间互相转换开发jar包
C++结构体和json/xml之间互相转换
02-09
用于在C++结构体和json/xml之间互相转换, bson在xbson中支持。 只需要头文件, 无需编译库文件。 具体可以参考example的例子
C# | JSON格式与XML格式互相转换
猿长大人
04-04 4518
JSON格式与XML格式是目前互联网上使用最为广泛的数据交换格式之一，而两种格式各自有着自己的特点和优势。在实际开发中，我们经常需要将数据在不同的系统或模块之间进行传递和转换，而JSON格式和XML格式的互相转换是一项非常基础和必要的技能。同时，对于需要将数据存储在不同的介质中的应用场景，比如在移动端本地存储数据，或者在服务器端将数据保存到文件或数据库中，也需要将JSON或XML格式进行相应的转换。因此，熟练掌握JSON与XML格式互相转换的方法对于开发人员来说是非常重要的。
(详解)XML与JSON的互相转换
AaronCao
05-18 1万+
XML与JSON的互相转换 文章目录XML与JSON的互相转换1. XML转JSON1.1 代码目的1.2 代码实现2. JSON转XML3. JSON转XML并输出成指定的文件4. 主要的pom.xml配置如下5. 整体代码 1. XML转JSON 1.1 代码目的 实现xml与json的互相转换，先实现xml -> json, 然后实现json -> xml字符串，最后xml字符...
让XML数据和json互相转化
weixin_60884460的博客
05-06 1104
注意 ： 这里用dumps转换成的是 字符串 ， 是不能用键对值的方式进行数据切分的。注：JSON对象在Python里面的数据类型为 dict。
xml转json
m0_63592293的博客
02-02 888
xml转json
XML&XXE实体注入
最新发布
q
06-18 829
转到pe_getxml用例可以看到，wechat_getxml调用了pe_getxml,相当于wechat_getxml调用了simplexml函数。使用CTRL+B快捷键转到wechat_getxml方法声明或用例，下面使用xml返回的数据都是固定的，应该是无回显。pe_getxml方法用到了simplexml，使用CTRL+B快捷键转到pe_getxml方法声明或用例。查看生成的file.txt,成功读取到c盘下123.txt。将get.php放入到服务器，将get.php放入到服务器，
jackson、Gson、xmlpull、xmlbeans、dom4j、jdom等。这些库提供了各种将XML和JSON字符串互相转换的方法 在java中的使用方式
06-09
这些库都提供了各种将XML和JSON字符串互相转换的方法，具体使用方式如下： 1. Jackson： - 将Java对象转换为JSON字符串： ``` ObjectMapper objectMapper = new ObjectMapper(); String json = objectMapper.writeValueAsString(myObject); ``` - 将JSON字符串转换为Java对象： ``` ObjectMapper objectMapper = new ObjectMapper(); MyObject myObject = objectMapper.readValue(json, MyObject.class); ``` 2. Gson： - 将Java对象转换为JSON字符串： ``` Gson gson = new Gson(); String json = gson.toJson(myObject); ``` - 将JSON字符串转换为Java对象： ``` Gson gson = new Gson(); MyObject myObject = gson.fromJson(json, MyObject.class); ``` 3. xmlpull： - 将XML字符串转换为Java对象： ``` XmlPullParserFactory factory = XmlPullParserFactory.newInstance(); XmlPullParser xpp = factory.newPullParser(); xpp.setInput(new StringReader(xml)); MyObject myObject = new MyObject(); while (xpp.getEventType() != XmlPullParser.END_DOCUMENT) { if (xpp.getEventType() == XmlPullParser.START_TAG && xpp.getName().equals("myField")) { myObject.setMyField(xpp.nextText()); } xpp.next(); } ``` - 将Java对象转换为XML字符串： ``` StringWriter writer = new StringWriter(); XmlSerializer serializer = Xml.newSerializer(); serializer.setOutput(writer); serializer.startDocument("UTF-8", true); serializer.startTag("", "myObject"); serializer.startTag("", "myField"); serializer.text(myObject.getMyField()); serializer.endTag("", "myField"); serializer.endTag("", "myObject"); serializer.endDocument(); String xml = writer.toString(); ``` 4. xmlbeans： - 将XML字符串转换为Java对象： ``` XmlObject xmlObject = XmlObject.Factory.parse(xml); MyObject myObject = MyObject.Factory.parse(xmlObject.newInputStream()); ``` - 将Java对象转换为XML字符串： ``` MyObject myObject = MyObject.Factory.newInstance(); myObject.setMyField("myValue"); String xml = myObject.xmlText(); ``` 5. dom4j： - 将XML字符串转换为Java对象： ``` Document document = DocumentHelper.parseText(xml); Element root = document.getRootElement(); MyObject myObject = new MyObject(); myObject.setMyField(root.element("myField").getText()); ``` - 将Java对象转换为XML字符串： ``` MyObject myObject = new MyObject(); myObject.setMyField("myValue"); Document document = DocumentHelper.createDocument(); Element root = document.addElement("myObject"); Element myField = root.addElement("myField"); myField.setText(myObject.getMyField()); String xml = document.asXML(); ``` 6. jdom： - 将XML字符串转换为Java对象： ``` SAXBuilder builder = new SAXBuilder(); Document document = builder.build(new StringReader(xml)); Element root = document.getRootElement(); MyObject myObject = new MyObject(); myObject.setMyField(root.getChildText("myField")); ``` - 将Java对象转换为XML字符串： ``` MyObject myObject = new MyObject(); myObject.setMyField("myValue"); Element root = new Element("myObject"); Element myField = new Element("myField"); myField.setText(myObject.getMyField()); root.addContent(myField); Document document = new Document(root); XMLOutputter outputter = new XMLOutputter(); String xml = outputter.outputString(document); ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值