xml转json工具（如何将XML文档转换为JSON格式）

本文目录

• 如何将XML文档转换为JSON格式
• xml为什么转化为json数据
• javascript 将xml转换为json对象
• xml字符串转json数字不对
• 如何把xml转成json对象，底层代码
• 如何将xml的字符串转换为json
• JAVA能把下面的 xml 转化为JSON
• 用python怎么实现json和xml的互转

如何将XML文档转换为JSON格式

之所以使用JSON一般是为了跳过XML这个过程，使JAVA类型到客户端的javascript类型可以不需要再解析XML就直接生成．为什么会从XML转换成json？
个人建议是通过Java解析XML，生成JavaBean或者其它类型的java对象，然后使用GSON，将java对象转化成json．GSON是google开发的一个包，小巧而功能强大，可定制性也很强，推荐使用．

xml为什么转化为json数据

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。它基于JavaScript（Standard
ECMA-262 3rd Edition - December 1999）的一个子集。
JSON采用完全独立于语言的文本格式，但是也使用了类似于C语言家族的习惯（包括C, C++, C#, Java, JavaScript,
Perl, Python等）。这些特性使JSON成为理想的数据交换语言。
易于人阅读和编写，同时也易于机器解析和生成(网络传输速度)。XML它可以用来标记数据、定义数据类型，是一种允许用户对自己的标记语言进行定义的源语
言。
它非常适合万维网传输，提供统一的方法来描述和交换独立于应用程序或供应商的结构化数据。是Internet环境中跨平台的、依赖于内容的技术，也是当今
处理分布式结构信息的有效工具。早在1998年，W3C就发布了XML1.0规范，使用它来简化Internet的文档信息传输。作为开发中比较常用到的
两种数据格式，他们之间的转换是怎样的呢，下面就是关于它们转化的工具类。

javascript 将xml转换为json对象

代码如下:

// Changes XML to JSON
function xmlToJson(xml) {
    // Create the return object
    var obj = {};
    if (xml.nodeType == 1) { // element
        // do attributes
        if (xml.attributes.length 》 0) {
        obj = {};
            for (var j = 0; j 《 xml.attributes.length; j++) {
                var attribute = xml.attributes.item(j);
                obj = attribute.nodeValue;
            }
        }
    } else if (xml.nodeType == 3) { // text
        obj = xml.nodeValue;
    }
    // do children
    if (xml.hasChildNodes()) {
        for(var i = 0; i 《 xml.childNodes.length; i++) {
            var item = xml.childNodes.item(i);
            var nodeName = item.nodeName;
            if (typeof(obj) == "undefined") {
                obj = xmlToJson(item);
            } else {
                if (typeof(obj.length) == "undefined") {
                    var old = obj;
                    obj;
                    obj.push(old);
                }
                obj.push(xmlToJson(item));
            }
        }
    }
    return obj;
};

xml字符串转json数字不对

xml字符串转json数字不对解决方法如下：
1、使用第三方库或工具，如XML2JSON，可以将XML字符串转换为格式正确的JSON字符串。在使用XML2JSON时，可以指定数字类型的值应该被解析为十进制数字类型还是其他类型，如字符串类型。
2、自己编写代码来处理数字类型的值。这需要对XML和JSON格式有一定的了解，并且需要使用正则表达式等工具来匹配和转换数字类型的值。

如何把xml转成json对象，底层代码

使用json-lib的XMLSerializer对象
(1)创建XMLSerializer对象
(2)使用XMLSerializer的read(xml)方法即可
view plain copy
/* 第二种方法，使用json-lib提供的方法 */
//创建 XMLSerializer对象
XMLSerializer xmlSerializer = new XMLSerializer();
//将xml转为json（注：如果是元素的属性，会在json里的key前加一个@标识）
String result = xmlSerializer.read(xml).toString();
//输出json内容
System.out.println(result);
3.测试
view plain copy
public class Test {
public static void main(String args) {
String xml = "《class id="
+ "’1’"
+ "》《student》《name》aaaaaa《/name》《age》21《/age》《/student》《student》《name》bbbbbb《/name》《age》22《/age》《/student》《/class》";

/* 第一种方法，使用JSON-JAVA提供的方法 */
//将xml转为json
JSONObject xmlJSONObj = XML.toJSONObject(xml);
//设置缩进
String jsonPrettyPrintString = xmlJSONObj.toString(4);
//输出格式化后的json
System.out.println(jsonPrettyPrintString);

/* 第二种方法，使用json-lib提供的方法 */
//创建 XMLSerializer对象
XMLSerializer xmlSerializer = new XMLSerializer();
//将xml转为json（注：如果是元素的属性，会在json里的key前加一个@标识）
String result = xmlSerializer.read(xml).toString();
//输出json内容
System.out.println(result);

}
第一种方法输出：
view plain copy
{"class": {
"id": 1,
"student": [
{
"age": 21,
"name": "aaaaaa"
},
{
"age": 22,
"name": "bbbbbb"
}
]
}}
第二种方法输出：
view plain copy
{"@id":"1","student":}

如何将xml的字符串转换为json

放上maven依赖
《dependency》
《groupId》org.json《/groupId》
《artifactId》json《/artifactId》
《version》20151123《/version》
《/dependency》
xml字符串转换为json字符串代码实现如下：
import org.json.JSONException;
import org.json.JSONObject;
import org.json.XML;
public class JsonUtils {
public static String xml2jsonString(String xml)throws JSONException{
JSONObject xmlJSONObj = XML.toJSONObject(xml);
return xmlJSONObj.toString();
}
}
json字符串转换为json对象代码实现如下：
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
JSONObject jsonObject = null;
try{
jsonObject = JSON.parseObject(jsonString);
}catch(Exception e){
logger.error("json串转json对象时发生异常,json串="+jsonString);
throw new RuntimeException("json串转json对象时发生异常,json串="+jsonString,e);
}
return jsonObject;
不过org.json有个问题比较麻烦，xml如下所示：
《?xml version="1.0" encoding="gb2312"?》
《payUnitinfo》
《err_msg》《/err_msg》
《retcode》1《/retcode》
《payUnits》
《payUnit》
《provinceId》v1955《/provinceId》
《cityId》v1961《/cityId》
《payProjectId》c2680《/payProjectId》
《payUnitId》v96564《/payUnitId》
《payUnitName》浙江省电费《/payUnitName》
《/payUnit》
《payUnit》
《provinceId》v1955《/provinceId》
《cityId》v1961《/cityId》
《payProjectId》c2680《/payProjectId》
《payUnitId》v85002《/payUnitId》
《payUnitName》国网浙江省电力公司《/payUnitName》
《/payUnit》
《/payUnits》
《/payUnitinfo》
当xml中出现多个《payUnit》时，org.json将xml中的《payUnit》转换为json数组格式的字符串，当只有一个《payUnit》时，org.json将xml中的《payUnit》转换为json对象格式的字符串。
假设jsonObject是上述xml转换为json对象后的变量，则通过以下方式获取：
JSONObject payUnitsJsonObject = jsonObject.getJSONObject("payUnitinfo").getJSONObject("payUnits");
JSONObject payUnitJsonObject = null;
JSONArray payUnitJsonArray = null;
Object payUnitObject = payUnitsJsonObject.get("payUnit");
if(payUnitObject instanceof JSONObject){
payUnitJsonObject = (JSONObject)payUnitObject;
}else if(payUnitObject instanceof JSONArray){
payUnitJsonArray = (JSONArray)payUnitObject;
}

JAVA能把下面的 xml 转化为JSON

《p》package com.shine.framework.core.util;《/p》
import java.io.ByteArrayOutputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import net.sf.json.JSON;
import net.sf.json.JSONSerializer;
import net.sf.json.xml.XMLSerializer;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;
/**
* common xml conver utility
*
* @author viruscodecn@gmail.com
* @version Framework 2010.10.26
***隐藏网址***
*/
public class XmlConverUtil {
/**
* map to xml xml 《node》《key label="key1"》value1《/key》《key
* label="key2"》value2《/key》......《/node》
*
* @param map
* @return
*/
public static String maptoXml(Map map) {
Document document = DocumentHelper.createDocument();
Element nodeElement = document.addElement("node");
for (Object obj : map.keySet()) {
Element keyElement = nodeElement.addElement("key");
keyElement.addAttribute("label", String.valueOf(obj));
keyElement.setText(String.valueOf(map.get(obj)));
}
return doc2String(document);
}
/**
* list to xml xml 《nodes》《node》《key label="key1"》value1《/key》《key
* label="key2"》value2《/key》......《/node》《node》《key
* label="key1"》value1《/key》《key
* label="key2"》value2《/key》......《/node》《/nodes》
*
* @param list
* @return
*/
public static String listtoXml(List list) throws Exception {
Document document = DocumentHelper.createDocument();
Element nodesElement = document.addElement("nodes");
int i = 0;
for (Object o : list) {
Element nodeElement = nodesElement.addElement("node");
if (o instanceof Map) {
for (Object obj : ((Map) o).keySet()) {
Element keyElement = nodeElement.addElement("key");
keyElement.addAttribute("label", String.valueOf(obj));
keyElement.setText(String.valueOf(((Map) o).get(obj)));
}
} else {
Element keyElement = nodeElement.addElement("key");
keyElement.addAttribute("label", String.valueOf(i));
keyElement.setText(String.valueOf(o));
}
i++;
}
return doc2String(document);
}
/**
* json to xml {"node":{"key":{"@label":"key1","#text":"value1"}}} conver
* 《o》《node class="object"》《key class="object"
* label="key1"》value1《/key》《/node》《/o》
*
* @param json
* @return
*/
public static String jsontoXml(String json) {
try {
XMLSerializer serializer = new XMLSerializer();
JSON jsonObject = JSONSerializer.toJSON(json);
return serializer.write(jsonObject);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* xml to map xml 《node》《key label="key1"》value1《/key》《key
* label="key2"》value2《/key》......《/node》
*
* @param xml
* @return
*/
public static Map xmltoMap(String xml) {
try {
Map map = new HashMap();
Document document = DocumentHelper.parseText(xml);
Element nodeElement = document.getRootElement();
List node = nodeElement.elements();
for (Iterator it = node.iterator(); it.hasNext();) {
Element elm = (Element) it.next();
map.put(elm.attributeValue("label"), elm.getText());
elm = null;
}
node = null;
nodeElement = null;
document = null;
return map;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* xml to list xml 《nodes》《node》《key label="key1"》value1《/key》《key
* label="key2"》value2《/key》......《/node》《node》《key
* label="key1"》value1《/key》《key
* label="key2"》value2《/key》......《/node》《/nodes》
*
* @param xml
* @return
*/
public static List xmltoList(String xml) {
try {
List《Map》 list = new ArrayList《Map》();
Document document = DocumentHelper.parseText(xml);
Element nodesElement = document.getRootElement();
List nodes = nodesElement.elements();
for (Iterator its = nodes.iterator(); its.hasNext();) {
Element nodeElement = (Element) its.next();
Map map = xmltoMap(nodeElement.asXML());
list.add(map);
map = null;
}
nodes = null;
nodesElement = null;
document = null;
return list;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* xml to json 《node》《key label="key1"》value1《/key》《/node》 转化为
* {"key":{"@label":"key1","#text":"value1"}}
*
* @param xml
* @return
*/
public static String xmltoJson(String xml) {
XMLSerializer xmlSerializer = new XMLSerializer();
return xmlSerializer.read(xml).toString();
}
/**
*
* @param document
* @return
*/
public static String doc2String(Document document) {
String s = "";
try {
// 使用输出流来进行转化
ByteArrayOutputStream out = new ByteArrayOutputStream();
// 使用UTF-8编码
OutputFormat format = new OutputFormat(" ", true, "UTF-8");
XMLWriter writer = new XMLWriter(out, format);
writer.write(document);
s = out.toString("UTF-8");
} catch (Exception ex) {
ex.printStackTrace();
}
return s;
}
}需要的jar
需要json-lib-2.1-jdk15.jar和xom-1.2.5.jar，maven pom.xml如下：

用python怎么实现json和xml的互转

ajax是属于template里面的一个异步请求而已，如果你在views里面传回来是你说的“实体对像（models）”的话，我就有点搞不明白了。。。
不知道你在那个view方法直接return的是什么？
如果使用json处理对象的话请使用：
***隐藏网址***
from models import mymodels
import simplejson
...
def ajax(request):
a = mymodels.objects.all()
’’’
此处假设a中有name、age参数
model对象是不能直接作为json可以处理,必须先转换为dict类型
’’’
result = {}
result = a.name
result = a.age
result = simplejson.dumps(result)
return HttpResponse(result)
此时用ajax访问这个试图返回的内容就是：
上面这种办法不是很好，建议先写一个template模板专门来显示此model内容。
假设模板ajax.html的内容为：
===================ajax.html===============
name: }《br /》
age: }
=======================================
views视图如下:
***隐藏网址***
from models import mymodels
from django.shortcuts import render_to_response
...
def ajax(request):
a = mymodels.objects.all()
return render_to_response("ajax.html",)
此时用ajax访问这个视图返回的内容就是:
name: Jim Green
age: 14
以上的代码可能会有错误，因为是随手写的，希望能够帮到你
＝＝＝＝修改了一下＝＝＝＝
模板文件名打错了。。。
修改了一下就到了楼上的下面了，楼上你也太没水准了。直接复制
=====修改＝＝＝＝＝
使用model.__dict__属性可以获得字典，希望能帮到你
你的串号我已经记下，采纳后我会帮你制作