XML（SAX）和Json解析分析

                                                XML（SAX）和Json解析分析
一：XML解析步骤

分析：XML解析最终是通过XMLReader的对象来关联一个自己继承自DefaultHandler抽象类（表示一个解析器，它是通过读数据流中对应的标签时触发里面对应的方法）。通过重写里面的：

//开始解析XML文件（当读到<文件头开始标签>事件触发，执行此方法)
public void startDocument(){}；

//结束解析XML文件（当读到<文件头结束标签>事件触发，执行此方法)
public void endDocument(){}；

//开始解析元素标签（当读到<标签头开始标签>事件触发，执行此方法)
public void startElement(String uri, String localName, String qName,
Attributes attributes）{
String localName：表示不带标签头的标签
String qName：表示带标签头的标签
Attributes attributes：代表标签中的属性
}；

//结束解析元素标签（当读到<标签头开始标签>事件触发，执行此方法)
public void endElement(String uri, String localName, String qName){}；

//解析标签对里面的内容，标签对只的内容存在char[] 数组中，通过判断当前解析的标签对的值，然后通过char[]数组和对应的参数来构建字符串，该字符串的值就是标签对中的内容。
public void characters(char[] ch, int start,
int length){
注意：该方法在遇到回车、换行、标签结束符时都会执行。

}；
五个方法。



1：创建DefaultHandler（解析器）的实现类：MySaxHandler类
public class MySaxHandler extends DefaultHandler{
重写对应的五个事件触发的方法。
}；

2:获取XMLReader（XML数据持有的者）的对象。（有两种方法可以获取）

方法一：
第一步：获取Sax解析的工厂类的对象（表示是Sax解析）

SAXParserFactory saxfacFactory=SAXParserFactory.newInstance();

第二步：通过Sax解析工厂类的对象获取一个SAXParser（Sax解析者）的对象

SAXParser parser=saxfacFactory.newSAXParser();

第三步：通过Sax解析者的对象获取XMLReader（XML数据持有者对象）

XMLReader reader=parser.getXMLReader();

     方法二：
直接通过XMLReaderFactory类来创建一个XMLReader（XML数据持有的者）的对象
XMLReader reader=XMLReaderFactory.createXMLReader();


3：通过XML数据持有者对象来关联自己创建的解析器类
reader.setContentHandler(new MySaxHandler());


4：通过数据持有者去解析对应的XML文件或者XML文件所对应的流
reader.parse(String XMLFile);
reader.parse(new InputSource(Intputstream in));


二：Json解析步骤：


分析：Json解析只是将XML文件换了一种表示形式，他通过一个Json对象的数组来对应一个XML文件。Json对象是包含在一个{}中的，Json对象中有多个键值对，对应着XML中的一个标签对和标签对中的值。注意：Json对象的值中可以内嵌多个Json对象，如同XML中的标签分层一样。Json对象键的属性都是String类类型。

一个最简单的Json类型的数据：String JsonData="[{\"name\":\"zhangsan\",\"age\":20},{\"name\":\"lisi\",\"age\":30}]";

里面对应两个Json对象：{\"name\":\"zhangsan\",\"age\":20}、{\"name\":\"lisi\",\"age\":30}。

当数据类型是Json数组格式时，Json解析（两种方式）的步骤如下：

第一种：通过JsonReader类来解析：

/**
* 通过JsonReader解析jsion数据
* @param jsionData 需要解析的jsion数据
* @param in 对应需要解析的数据流
* @throws IOException
*/
public void parseJsionByReader(InputStream in) throws IOException{

1： //获取JsionReader对象
JsonReader jsonReader=new JsonReader(new InputStreamReader(in));
try {

2：//开始解析JsonArray
jsonReader.beginArray();


3： //循环解析jsonArray中的对象
while(jsonReader.hasNext()){
//开始解析JsonObject
jsonReader.beginObject();

4：//循环解析JsonObject中的属性值
while(jsonReader.hasNext()){
//取出每个JsonObject中的键值
String jsonName=jsonReader.nextName();

if(jsonName.equals("name")){

//取出键值后面的value值
String value=jsonReader.nextString();
System.out.println("解析的值为："+jsonName+"--------value值 为:"+value);
}
if(jsonName.equals("age")){
int value=jsonReader.nextInt();
System.out.println("解析的值为："+jsonName+"--------value值 为:"+value);
}
}
//结束解析当前JsonObject对象
jsonReader.endObject();
}
//结束解析当前的JsonArray数组
jsonReader.endArray();

} catch (Exception e) {
e.printStackTrace();
}
}



第二种：通过JsonArray类来解析：


/**
*
* @param in对应需要解析的数据流
*/

public void parseJsonByArray(InputStream in){
try {

//获取Json对象耳的数组JsonArray里面的参数是通过对应的数据流来转换成一个字符串
JSONArray jsonArray=new JSONArray(new Scanner(in).useDelimiter("\\A").next());
//通过遍历JsonArray来获取该数组中的每个对象
for(int i=0;i<jsonArray.length();i++){
String name=jsonArray.getJSONObject(i).get("name").toString();
int age=jsonArray.getJSONObject(i).getInt("age");
System.out.println("name="+name+"------------age="+age);
}
} catch (JSONException e) {
e.printStackTrace();
}

}

              Json数据端的封装可以通过字符串拼接和第三方的工具包去封装Json对象。

第一种：直接通过JsonObject对象来封装：
情况一：JSONObject studentJSONObject = new JSONObject();
try {
studentJSONObject.put("name", "Jason");
studentJSONObject.put("id", 20130001);
studentJSONObject.put("phone", "13579246810");
} catch (JSONException e) {
e.printStackTrace();
}

return studentJSONObject.toString();



情况二：private static String JSONText = "{\"id\":20130001,\"phone\": \"13579246810\",\"name\":\"Jason\"}";
private static String getJSONContent2(){
String name = null;
int id = 0;
String phone = null;
try {
JSONObject studentJSONObject = new JSONObject(JSONText);
name = studentJSONObject.getString("name");
id = studentJSONObject.getInt("id");
phone = studentJSONObject.getString("phone");

} catch (JSONException e) {
e.printStackTrace();
}
return name + " " + id + " " + phone;
}





第二种：通过JSONStringer对象来封装：
JSONStringer jsonStringer = new JSONStringer();
try {
jsonStringer.object();
jsonStringer.key("name");
jsonStringer.value("Jason");
jsonStringer.key("id");
jsonStringer.value(20130001);
jsonStringer.key("phone");
jsonStringer.value("13579246810");
jsonStringer.endObject();
} catch (JSONException e) {
e.printStackTrace();
}
return jsonStringer.toString();

第三种：通过JSONTokener对象来封装：
private static String JSONText = "{\"id\":20130001,\"phone\": \"13579246810\",\"name\":\"Jason\"}";

private static String getJSONContent(){
JSONTokener jsonTokener = new JSONTokener(JSONText);
JSONObject studentJSONObject;
String name = null;
int id = 0;
String phone = null;
try {
studentJSONObject = (JSONObject) jsonTokener.nextValue();
name = studentJSONObject.getString("name");
id = studentJSONObject.getInt("id");
phone = studentJSONObject.getString("phone");

} catch (JSONException e) {
e.printStackTrace();
}
return name + " " + id + " " + phone;
}


可见：三种方式都可以封装Json数据，第一种JsonObject对象封装的数据顺序杂乱，后面两种顺序一致。

所以：一般情况下使用JSONObject即可，但对于一些嵌套的JSON，某些JSONArray没有key,只有value等特殊情况，则使 用JSONStringer.

最后：两种的解析方式的与原理是一样的，只是数据封装的形式不同而已。