1.引子：DOM
这篇文章写得挺好
http://www.cnblogs.com/yexiaochai/archive/2013/05/28/3102674.html
document object model 文档对象模型，用于访问xml html的标准
在XML DOM每个元素 都会被解析为一个节点Node，而常用的节点类型又分为
•元素节点 Element
•属性节点 Attr
•文本节点 Text
•文档节点 Document
document对象的常用方法
•getElementById()返回对拥有指定 id 的第一个对象的引用
•getElementsByName()返回带有指定名称的对象集合
•getElementsByTagName()返回带有指定标签名的对象集合
节点常用属性
lnodeName
•如果节点是元素节点，nodeName返回这个元素的名称
•如果是属性节点，nodeName返回这个属性的名称
•如果是文本节点，nodeName返回一个内容为#text 的字符串
lnodeType
•Node.ELEMENT_NODE ---1 -- 元素节点
•Node.ATTRIBUTE_NODE ---2 -- 属性节点
•Node.TEXT_NODE ---3 -- 文本节点
lnodeValue
•如果给定节点是一个属性节点，返回值是这个属性的值
•如果给定节点是一个文本节点，返回值是这个文本节点内容
•如果给定节点是一个元素节点，返回值是 null
<!doctype html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="Generator" content="EditPlus®">
<meta name="Author" content="">
<meta name="Keywords" content="">
<meta name="Description" content="">
<title>Dom概述</title>
</head>
<body>
<h1>明天休息</h1>
<script>
//alert(document.getElementsByTagName("h1")[0].firstChild.nodeValue);
//alert(document.getElementsByTagName("h1")[0].lastChild.nodeValue);
//alert(document.getElementsByTagName("h1")[0].childNodes[0].nodeValue );
//alert(document.getElementsByTagName("h1")[0].innerHTML);
</script>
</body>
</html>由于这里只有一个子节点，first=last ，都能弹出明天休息的框框
<!doctype html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="Generator" content="EditPlus®">
<meta name="Author" content="">
<meta name="Keywords" content="">
<meta name="Description" content="">
<title>打印ul里面的li子节点信息</title>
<script>
function getLi(){
var bjNode= document.getElementById("bj");
var childnum = bjNode.childNodes.length;
//alert(childnum);
for(var i=0;i<childnum ;i++)
alert( bjNode.childNodes[i].nodeName+","+bjNode.childNodes[i].nodeType+","+
bjNode.childNodes[i].nodeValue );
//#text 3 北京
//h1 1
//#text 3 奥运
}
</script>
</head>
<body>
<ul>
<li id="bj" value="beijing">
北京
<h1>海淀</h1>
奥运
</li>
<li id="sh" value="shanghai">
上海
</li>
<br/>
<input type="button" value="li取值" οnclick="getLi()"/>
</ul>
</body>
</html>这里第一个节点下有3个子节点，第一个是文本节点，北京，第二个是一个元素节点，变大了的海淀，第三个是文本节点，奥运
所以依次输出了
#text,3,北京
H1,1,null
#text,3,奥运
由上面这两个例子就大概可以看出xml解析需要的基本知识，按节点获取，至于增删改查之类的这里不多说了~
2.关于xml
如果想系统、深入的学习xml的知识，最好看看Javascript的相关知识，包括各种BOM、DOM、xml约束、解析什么的
xml，可标记语言，用来传输数据，至于展示数据需要别的软件解析
例如数据结构的树形数据结构，如何才能交给PC处理？
xml的标签
一个标签中只能有一个主标签；一个标签下由若干子标签，但是不能互相嵌套；主题内容中的空格也会被读取，如果不处理，跑起来容易挂掉
<![CDATA[内容]]> 把 内容 当纯文本显示
由于xml中大量自定义标签，所以不能出错，这就是为什么会有约束：DTD 、Schema
约束文档定义了在XML中允许出现的元素名称、属性及元素出现的顺序等等。
DTD约束文档可以在XML文档中直接定义，也可以作为单独的文档进行编写(单独的文档必须以UTF-8编码进行保存) 。
3.着重看下如何解析，做安卓开发主要还是用，SAX DOM PULL
首先简单说下SAX和DOM解析的异同，而PULL解析是安卓特有，单独说
首先解析方式上，主要是以下两种，几乎所有商用的xml 解析器都同时实现了这两个接口
•DOM：Document Object Model，文档对象模型。这种方式是W3C推荐的处理XML的一种方式。
•SAX：Simple API for XML。这种方式不是官方标准，属于开源社区XML-DEV，几乎所有的XML解析器都支持它
•JAXP：是SUN公司推出的解析标准实现。
•Dom4J：是开源组织推出的解析开发包。
•JDom：是开源组织推出的解析开发包。
(1) JAXP,
Java API for XML Processing,是JavaSE的一部分，它由以下几个包及其子包组成：
•org.w3c.dom:提供DOM方式解析XML的标准接口
•org.xml.sax:提供SAX方式解析XML的标准接口
•javax.xml:提供了解析XML文档的类
而javax.xml.parsers包中，定义了几个工厂类。我们可以通过调用这些工厂类，得到对XML文档进行解析的DOM和SAX解析器对象。
•DocumentBuilderFactory
•SAXParserFactory
进行DOM解析
调用 DocumentBuilderFactory.newInstance() 方法得到创建 DOM 解析器的工厂。
调用工厂对象的 newDocumentBuilder方法得到 DOM 解析器对象。
调用 DOM 解析器对象的 parse() 方法解析 XML 文档，得到代表整个文档的 Document 对象，进行可以利用DOM特性对整个XML文档进行操作了。
进行SAX解析
由于在使用 DOM 解析 XML 文档时，需要读取整个 XML 文档，在内存中构架代表整个 DOM 树的Doucment对象，从而再对XML文档进行操作。此种情况下，如果 XML 文档特别大，就会消耗计算机的大量内存，并且容易导致内存溢出。
而SAX解析允许在读取文档的时候，即对文档进行处理，而不必等到整个文档装载完才会文档进行操作。
SAX采用事件处理的方式解析XML文件，利用 SAX 解析 XML 文档，涉及两个部分：解析器和事件处理器：
•解析器可以使用JAXP的API创建，创建出SAX解析器后，就可以指定解析器去解析某个XML文档。
•解析器采用SAX方式在解析某个XML文档时，它只要解析到XML文档的一个组成部分，都会去调用事件处理器的一个方法，解析器在调用事件处理器的方法时，会把当前解析到的xml文件内容作为方法的参数传递给事件处理器。
•事件处理器由程序员编写，程序员通过事件处理器中方法的参数，就可以很轻松地得到sax解析器解析到的数据，从而可以决定如何对数据进行处理
使用SAXParserFactory创建SAX解析工厂
SAXParserFactory spf = SAXParserFactory.newInstance();
通过SAX解析工厂得到解析器对象
SAXParser sp = spf.newSAXParser();
通过解析器对象得到一个XML的读取器
XMLReader xmlReader = sp.getXMLReader();
设置读取器的事件处理器
xmlReader.setContentHandler(new BookParserHandler());
解析xml文件
xmlReader.parse("book.xml");
(2)DOM4J解析
看名字就知道这个是DOM模式解析，脱胎于更早期的JDOM
Dom4j是一个非常优秀的Java XML API，具有性能优异、功能强大和极易使用的特点。现在很多软件采用的Dom4j，例如Hibernate，包括sun公司自己的JAXM也用了Dom4j。
使用Dom4j开发，需下载dom4j相应的jar文件。
DOM4j中，获得Document对象的方式有三种：
1.读取XML文件,获得document对象
SAXReader reader = new SAXReader();
Document document = reader.read(new File("input.xml"));
Document document = reader.read(new File("input.xml"));
2.解析XML形式的文本,得到document对象.
String text = "<members></members>";
Document document = DocumentHelper.parseText(text);
Document document = DocumentHelper.parseText(text);
3.主动创建document对象.
Document document = DocumentHelper.createDocument();
//创建根节点
//创建根节点
Element root = document.addElement("members");
获取节点对象
1.获取文档的根节点.
Element root = document.getRootElement();
2.取得某个节点的子节点.
Element element=node.element(“书名");
3.取得节点的文字
String text=node.getText();
4.取得某节点下所有名为“member”的子节点，并进行遍历.
List nodes = rootElm.elements("member");
for (Iterator it = nodes.iterator(); it.hasNext();) {
Element elm = (Element) it.next();
// do something
}
List nodes = rootElm.elements("member");
for (Iterator it = nodes.iterator(); it.hasNext();) {
Element elm = (Element) it.next();
// do something
}
5.对某节点下的所有子节点进行遍历.
for(Iterator it=root.elementIterator();it.hasNext();){
Element element = (Element) it.next();
// do something
}
for(Iterator it=root.elementIterator();it.hasNext();){
Element element = (Element) it.next();
// do something
}
6.在某节点下添加子节点.
Element ageElm = newMemberElm.addElement("age");
Element ageElm = newMemberElm.addElement("age");
7.设置节点文字.
element.setText("29");
element.setText("29");
8.删除某节点.
//childElm是待删除的节点,parentElm是其父节点
//childElm是待删除的节点,parentElm是其父节点
parentElm.remove(childElm);
9.添加一个CDATA节点.
Element contentElm = infoElm.addElement("content");
contentElm.addCDATA(diary.getContent());
Element contentElm = infoElm.addElement("content");
contentElm.addCDATA(diary.getContent());
节点对象属性
1.取得某节点下的某属性
Element root=document.getRootElement();
//属性名name
Element root=document.getRootElement();
//属性名name
Attribute attribute=root.attribute("size");
2.取得属性的文字
String text=attribute.getText();
String text=attribute.getText();
3.删除某属性
Attribute attribute=root.attribute("size");
root.remove(attribute);
Attribute attribute=root.attribute("size");
root.remove(attribute);
4.遍历某节点的所有属性
Element root=document.getRootElement();
for(Iterator it=root.attributeIterator();it.hasNext();){
Attribute attribute = (Attribute) it.next();
String text=attribute.getText();
System.out.println(text);
}
Element root=document.getRootElement();
for(Iterator it=root.attributeIterator();it.hasNext();){
Attribute attribute = (Attribute) it.next();
String text=attribute.getText();
System.out.println(text);
}
5.设置某节点的属性和文字.
newMemberElm.addAttribute("name", "sitinspring");
newMemberElm.addAttribute("name", "sitinspring");
6.设置属性的文字
Attribute attribute=root.attribute("name");
attribute.setText("sitinspring");
Attribute attribute=root.attribute("name");
attribute.setText("sitinspring");
将文档写入XML
1.文档中全为英文,不设置编码,直接写入的形式.
XMLWriter writer = new XMLWriter(new FileWriter("output.xml"));
writer.write(document);
writer.close();
XMLWriter writer = new XMLWriter(new FileWriter("output.xml"));
writer.write(document);
writer.close();
2.文档中含有中文,设置编码格式写入的形式.
OutputFormat format = OutputFormat.createPrettyPrint();
指定XML编码
OutputFormat format = OutputFormat.createPrettyPrint();
指定XML编码
format.setEncoding("GBK");
XMLWriter writer = new XMLWriter(new FileOutputStream ("output.xml"),format);
writer.write(document);
writer.close();
XMLWriter writer = new XMLWriter(new FileOutputStream ("output.xml"),format);
writer.write(document);
writer.close();
来对比下：
SAX这种基于事件的处理方式，一边读数据一边解析，无需保存数据，在需要的时候直接停止亦可
而DOM这种基于树的处理方式，需要先把数据完全读入，可以对他的数据、结构进行修改，但是另一方面来说，对于比较大的文档，他的内存消耗就比较大了
所以：
如果想对数据更改并输出为xml，DOM更合适；对于大文件，XML更合适，另外如果对速度有要求，同样XML是更好的选择
当然，SAX 和 DOM 不是相互排斥的，记住这点很重要。您可以使用 DOM 来创建 SAX 事件流，也可以使用 SAX 来创建 DOM 树。事实上，用于创建 DOM 树的大多数解析器实际上都使用 SAX 来完成这个任务！
实例：
正好看到一篇好文，直接引用了。http://www.cnblogs.com/JerryWang1991/archive/2012/02/24/2365507.html
<?xml version="1.0" encoding="utf-8"?>
<channel>
<item id="0" url="http://www.baidu.com">百度</item>
<item id="1" url="http://www.qq.com">腾讯</item>
<item id="2" url="http://www.sina.com.cn">新浪</item>
<item id="3" url="http://www.taobao.com">淘宝</item>
</channel>4.最后关于PULL解析
在android系统中，很多资源文件中,很多都是xml格式，在android系统中解析这些xml的方式，是使用pul解析器进行解析的，它和sax解析一样（个人感觉要比sax简单点），也是采用事件驱动进行解析的，当pull解析器，开始解析之后，我们可以调用它的next（）方法，来获取下一个解析事件（就是开始文档，结束文档，开始标签，结束标签），当处于某个元素时可以调用XmlPullParser的getAttributte()方法来获取属性的值，也可调用它的nextText()获取本节点的值。
跟SAX不同的是， Pull解析器产生的事件是一个数字，而非方法，因此可以使用一个switch对感兴趣的事件进行处理。当元素开始解析时，调用parser.nextText()方法可以获取下一个Text类型节点的值pull本来是一个开源项目
Android SDK中已经集成了Pull解析器，无需添加任何jar文件
• 使用Pull解析器解析XML文件
– 1. Xml.newPullParser() 获得解析器
– 2 parser.setInput(in, "UTF-8") 设置输入流以及编码
– 3. parser.next() 获取下一个解析事件，得到一个事件代码
– 4. XmlPullParser中定义了常量来标识各种解析事件
START_DOCUMENT、
END_DOCUMENT 、
START_TAG 、
END_TAG 、
TEXT<?xml version='1.0' encoding='utf-8' standalone='yes' ?>
<map><string name='nickname'>hellokitty</string><boolean name='autostart' value='false' /><float name='autoclose' value='1000.0' /></map>bean
package com.example.bean;
public class Book {
private String bookname;
private String author;
private String priceString;
@Override
public String toString() {
return "Book [bookname=" + bookname + ", author=" + author
+ ", priceString=" + priceString + "]";
}
public String getBookname() {
return bookname;
}
public void setBookname(String bookname) {
this.bookname = bookname;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public String getPriceString() {
return priceString;
}
public void setPriceString(String priceString) {
this.priceString = priceString;
}
}
public class MainActivity extends Activity {
public static String TAG = "pullparser";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
public void parsebyPull(View v) throws IOException{
//得到解析器XmlPullParser
XmlPullParser pullparser = Xml.newPullParser();
List<Book> booklist= new ArrayList<Book>();
Book book = null;
try {
//设置读取文件，要与xml里的编码格式一致
InputStream in = new FileInputStream("data/data/com.example.pullparser/files/books.xml");
pullparser.setInput(in, "UTF-8");
//类型
int evenType = pullparser.getEventType();
while(evenType!=XmlPullParser.END_DOCUMENT){
if (evenType==XmlPullParser.START_DOCUMENT) {
Log.i(TAG, "START_DOCUMENT") ;
}
if (evenType==XmlPullParser.START_TAG){
Log.i(TAG, "START_TAG"+pullparser.getName()) ;
if ("book".equals(pullparser.getName())) {
book = new Book();
}
if ("bookname".equals(pullparser.getName())) {
book.setBookname(pullparser.nextText());
}
if ("author".equals(pullparser.getName())) {
book.setAuthor(pullparser.nextText());
}
if ("price".equals(pullparser.getName())) {
book.setPriceString(pullparser.nextText());
}
}
if (evenType==XmlPullParser.TEXT) {
Log.i(TAG, "TEXT" +pullparser.getText()) ;
}
if (evenType==XmlPullParser.END_TAG) {
Log.i(TAG, "END_TAG"+pullparser.getName()) ;
if ("book".equals(pullparser.getName())) {
booklist.add(book);
book = null;
}
}
evenType=pullparser.next();
}
if (evenType==XmlPullParser.END_DOCUMENT) {
Log.i(TAG, "END_DOCUMENT") ;
}
for ( Book book2 : booklist) {
Log.i(TAG, book2.toString() ) ;
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (XmlPullParserException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}5.JSON
对比下JSON与XML
<?xmlversion="1.0"encoding="utf-8"?>
<country>
<name>中国</name>
<province>
<name>黑龙江</name>
<cities>
<city>哈尔滨</city>
<city>大庆</city>
</cities>
</province>
<province>
<name>广东</name>
<cities>
<city>广州</city>
<city>深圳</city>
<city>珠海</city>
</cities>
</province>
<province>
<name>台湾</name>
<cities>
<city>台北</city>
<city>高雄</city>
</cities>
</province>
<province>
<name>新疆</name>
<cities>
<city>乌鲁木齐</city>
</cities>
</province>
</country>
var pro ={
"name":"中国",
"province":[{"name":"黑龙江","cities":{"city":["哈尔滨","大庆"]}},
{"name":"广东","cities":{"city":["广州","深圳","珠海"]}},
{"name":"台湾","cities":{"city":["台北","高雄"]}},
{"name":"新疆","cities":{"city":["乌鲁木齐"]}}
]
}
可读性上，JSON更简洁，xml更规范
扩展性上没有区别
解析上，事先知道结构的时候，JSON显然更有优势
传输效率上，JSON无需闭合标签，总数据量会少一些，传输压力更小
查询手机号，利用网络上的服务提供数据，先看一下解析出来的数据格式
xml
http://api.k780.com:88/?app=phone.get&phone=13800138000&appkey=14114&sign=ede788f7bf8d0678e281f660654ef995&format=xml
JSON格式
public class MainActivity extends Activity {
public static final String TAG = "phonenumberqurey";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
Handler hanlder = new Handler(){
@Override
public void handleMessage(Message msg) {
// TODO Auto-generated method stub
super.handleMessage(msg);
switch (msg.what) {
case 1:
//正确的连到服务器就要获取出来，而不是toast
TextView tv_loaction = (TextView) findViewById(R.id.tv_location);
tv_loaction.setText((String)msg.obj);
break;
case 2:
Toast.makeText(MainActivity.this, (String)msg.obj, 0).show();
break;
default:
break;
}
}
};
public void query(View v){
//先获取电话号码
EditText et_number = (EditText) findViewById(R.id.et_number);
String number = et_number.getText().toString();
final String path ="http://api.k780.com:88/?app=phone.get&phone="+number+"&appkey=14114&sign=ede788f7bf8d0678e281f660654ef995&format=xml";
//发请求的线程
Thread thread = new Thread(){
public void run() {
try {
URL url = new URL(path);
HttpURLConnection conn= (HttpURLConnection) url.openConnection();
//
conn.setReadTimeout(5000);
conn.setConnectTimeout(5000);
conn.setRequestMethod("GET");
//
conn.connect();
//
String city =null;
String operator = null;
if(conn.getResponseCode()==200){
//登陆成功
//登陆失败？
InputStream is= conn.getInputStream();
//String text = WebUtils.gettextFromInputStream(is, null);
XmlPullParser pullparser = Xml.newPullParser();
pullparser.setInput(is, "UTF-8");
//得到读取到的某部分的类型
int evenType = pullparser.getEventType();
while(evenType!=XmlPullParser.END_DOCUMENT){
if (evenType==XmlPullParser.START_TAG) {
Log.i(TAG, "START_TAG"+pullparser.getName()) ;
if ("operators".equals(pullparser.getName())) {
operator=pullparser.nextText();
}
if ("style_citynm".equals(pullparser.getName())) {
city=pullparser.nextText();
}
}
evenType=pullparser.next();
}
Log.i(TAG,operator+":"+city);
Message msg = hanlder.obtainMessage();
msg.what=1;
if(city==null||operator==null)
msg.obj="没有查询到结果";
else
msg.obj= city+":"+operator;
hanlder.sendMessage(msg);
}
else {
Message msg = hanlder.obtainMessage();
msg.what=2;
msg.obj="没有链接到服务器";
hanlder.sendMessage(msg);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
};
};
thread.start();
}
public void querybyjson(View v){
//先获取电话号码
EditText et_number = (EditText) findViewById(R.id.et_number);
String number = et_number.getText().toString();
final String path ="http://api.k780.com:88/?app=phone.get&phone="+number+"&appkey=14114&sign=ede788f7bf8d0678e281f660654ef995&format=json";
//发请求的线程
Thread thread = new Thread(){
public void run() {
try {
URL url = new URL(path);
HttpURLConnection conn= (HttpURLConnection) url.openConnection();
conn.setReadTimeout(5000);
conn.setConnectTimeout(5000);
conn.setRequestMethod("GET");
conn.connect();
String city =null;
String operator = null;
if(conn.getResponseCode()==200){
InputStream is= conn.getInputStream();
//json需要提取出文本
String text = WebUtils.gettextFromInputStream(is, null);
JSONObject jsonObject = new JSONObject(text);
JSONObject result = jsonObject.getJSONObject("result");
city= result.getString("style_citynm");
operator = result.getString("operators");
Log.i(TAG,operator+":"+city);
Message msg = hanlder.obtainMessage();
msg.what=1;
if(city==null||operator==null)
msg.obj="没有查询到结果";
else
msg.obj= city+":"+operator;
hanlder.sendMessage(msg);
}
else {
Message msg = hanlder.obtainMessage();
msg.what=2;
msg.obj="没有链接到服务器";
hanlder.sendMessage(msg);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
};
};
thread.start();
}
class Myhandler extends AsyncHttpResponseHandler {
@Override
public void onSuccess(int statusCode, Header[] headers, byte[] responseBody) {
// TODO Auto-generated method stub
String city =null;
String operator = null;
//String text = WebUtils.gettextFromInputStream(is, null);
XmlPullParser pullparser = Xml.newPullParser();
//onSuccess的最后一个参数传递的是数组，这里需要一个把数组转成流的方法~
ByteArrayInputStream bais= new ByteArrayInputStream(responseBody);
try {
pullparser.setInput(bais, "utf-8");
//得到读取到的某部分的类型
int evenType = pullparser.getEventType();
while(evenType!=XmlPullParser.END_DOCUMENT){
if (evenType==XmlPullParser.START_TAG) {
Log.i(TAG, "START_TAG"+pullparser.getName()) ;
if ("operators".equals(pullparser.getName())) {
operator=pullparser.nextText();
}
if ("style_citynm".equals(pullparser.getName())) {
city=pullparser.nextText();
}
}
evenType=pullparser.next();
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//json
JSONObject jsonObject =null;
try {
jsonObject = new JSONObject(new String(responseBody));
JSONObject result = jsonObject.getJSONObject("result");
city= result.getString("style_citynm");
operator = result.getString("operators");
} catch (JSONException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
TextView tv_loaction = (TextView) findViewById(R.id.tv_location);
tv_loaction.setText(city+":"+operator);
}
@Override
public void onFailure(int statusCode, Header[] headers,
byte[] responseBody, Throwable error) {
// TODO Auto-generated method stub
}
}
public void querybyxml_async(View v){
EditText et_number = (EditText) findViewById(R.id.et_number);
String number = et_number.getText().toString();
final String path ="http://api.k780.com:88/?app=phone.get&phone="+number+"&appkey=14114&sign=ede788f7bf8d0678e281f660654ef995&format=xml";
AsyncHttpClient asyncHttpClient = new AsyncHttpClient();
asyncHttpClient.post(path, new Myhandler());
}
public void querybyjson_aysnc(View v){
EditText et_number = (EditText) findViewById(R.id.et_number);
String number = et_number.getText().toString();
final String path ="http://api.k780.com:88/?app=phone.get&phone="+number+"&appkey=14114&sign=ede788f7bf8d0678e281f660654ef995&format=json";
AsyncHttpClient asyncHttpClient = new AsyncHttpClient();
asyncHttpClient.post(path, new Myhandler());
}
}
最后再对比下
关于轻量级和重量级
轻量级和重量级是相对来说的，那么XML相对于JSON的重量级体现在哪呢?应该体现在解析上，XML目前设计了两种解析方式：DOM和 SAX。
<1>.DOM
DOM是把一个数据交换格式XML看成一个DOM对象，需要把XML文件整个读入内存，这一点上JSON和XML的原理是一样的，但是XML要考虑父节点和子节点，这一点上JSON的解析难度要小很多，因为JSON构建于两种结构：key/value，键值对的集合;值的有序集合，可理解为数组；
<2>.SAX
SAX不需要整个读入文档就可以对解析出的内容进行处理，是一种逐步解析的方法。程序也可以随时终止解析。这样，一个大的文档就可以逐步的、一点一点的展现出来，所以SAX适合于大规模的解析。这一点，JSON目前是做不到得。
所以，JSON和XML的轻/重量级的区别在于：
JSON只提供整体解析方案，而这种方法只在解析较少的数据时才能起到良好的效果；
XML提供了对大规模数据的逐步解析方案，这种方案很适合于对大量数据的处理。