Android学习笔记三十六之网络数据解析

前面我们介绍了HTTP协议和Android中通过HTTP协议通信的两种方式：HttpUrlConnection和HttpClient，这些都只是在协议层的，数据在网络中传递需要有一定的格式才能被识别的解析，目前，常用的有XML和JSON，那么这一篇，我们来学习一下XML数据和JSON数据的解析：

1、XML数据解析

　　XML不仅仅在android中常用，在各种应用中也广泛使用，是承载数据的一个重要角色。作为一个Android开发者，我们需要学会在Android中读写XML数据，下面我们开始学习一下XML数据的解析吧！

1.1、XML数据简介

　　XML 是可扩展标记语言（Extensible Markup Language）的缩写，其中的 标记（markup）是关键部分。您可以创建内容，然后使用限定标记标记它，从而使每个单词、短语或块成为可识别、可分类的信息。您创建的文件，或文档实例 由元素（标记）和内容构成。当从打印输出读取或以电子形式处理文档时，元素能够帮助更好地理解文档。元素的描述性越强，文档各部分越容易识别。在这里就不在做很深入的学习了，我们只需要知道，XML可以用来存储数据，可以将XML当成是一个小型的数据库，前面我们学习Android数据存储的时候，学习到的SharedPreference存储方式中，底层存储数据就是通过XML的形式。XML数据解析方式有三种，分别是SAX方式、DOM方式、PULL方式，那么我们开始学习一下这三种方式解析XML数据吧！

1.2、SAX方式解析XML数据

　　SAX（Simple API for XML）解析器是一个基于事件的解析方式，由事件流驱动，从文档的顺序开始到文档结束，中间不可以回退或者暂停。SAX解析器解析速度快，占用内存少，非常适合在Android端使用。

　　SAX解析器的解析原理就是：对文档进行顺序扫描，当扫描到文档开始，元素开始和结束，文档结束等地方时通知事件处理函数，事件处理函数做出相应处理之后继续扫描，直到文档扫描结束。

常用的SAX接口和类：

• Attrbutes：用于得到属性的个数、名字和值。

• ContentHandler：定义与文档本身关联的事件(例如，开始和结束标记)。大多数应用程序都注册这些事件。

• DTDHandler：定义与DTD关联的事件。它没有定义足够的事件来完整地报告DTD。如果需要对DTD进行语法分析，请使用可选的DeclHandler。

• DeclHandler是SAX的扩展。不是所有的语法分析器都支持它。

• EntityResolver：定义与装入实体关联的事件。只有少数几个应用程序注册这些事件。

• ErrorHandler：定义错误事件。许多应用程序注册这些事件以便用它们自己的方式报错。

• DefaultHandler：它提供了这些接LI的缺省实现。在大多数情况下，为应用程序扩，DefaultHandler并覆盖相关的方法要比直接实现一个接口更容易。

SAX解析器的使用步骤：

• 1、通过SAXParserFactory.newInstance()创建一个SAXParserFactory对象

• 2、通过SAXParserFactory.newSAXParser()方法返回一个SAXParser解析器

• 3、实例化一个DefaultHandler对象

• 4、将第二步创建的SAXParser分配给解析器,对文档进行解析,将事件发送给处理器

下面我们通过一个简单的例子体会一下SAX解析XML数据：

首先是SAXHandler代码：

package com.example.datasave;

import android.util.Log;

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

import java.util.ArrayList;
import java.util.List;

/**
 * Created by Devin on 2016/7/25.
 */
public class SAXHandler extends DefaultHandler {
private CarModel mCarModel;
private List<CarModel> mCarModels = new ArrayList<>();
private static String TAG = "SAXHandler";
private String result;

@Override
public void startDocument() throws SAXException {
    super.startDocument();
    Log.i(TAG, "------>>startDocument");
}

@Override
public void endDocument() throws SAXException {
    super.endDocument();
    Log.i(TAG, "------>>endDocument");
}

/**
 * 读到第一个元素标签开始的时候调用
 *
 * @param uri        命名空间的URI
 * @param localName  元素标签名
 * @param qName      限定元素名
 * @param attributes 附加在元素上的属性
 * @throws SAXException
 */
@Override
public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
    super.startElement(uri, localName, qName, attributes);

    if (localName.equals("car")) {
        Log.i(TAG, "------>>startElement");
        mCarModel = new CarModel();
    }
}

/**
 * 元素标签结束的时候回调
 *
 * @param uri       命名空间的URI
 * @param localName 元素标签名
 * @param qName     限定元素名称
 * @throws SAXException
 */

@Override
public void endElement(String uri, String localName, String qName) throws SAXException {
    super.endElement(uri, localName, qName);
    if (localName.equals("car_name")) {
        mCarModel.setCar_name(result);
    } else if (localName.equals("car_color")) {
        mCarModel.setCar_color(result);
    } else if (localName.equals("car_pice")) {
        mCarModel.setCar_pice(result);
    } else if (localName.equals("car")) {
        Log.i(TAG, "------>>endElement");
        System.out.println("----->>" + mCarModel);
        mCarModels.add(mCarModel);
        mCarModel = null;
    }
}

/**
 * 获取到元素节点的内容
 *
 * @param ch     字符
 * @param start  字符数组起始位置
 * @param length 字符数组长度
 * @throws SAXException
 */
@Override
public void characters(char[] ch, int start, int length) throws SAXException {
    super.characters(ch, start, length);
    result = new String(ch, start, length);
}

public List<CarModel> getCarModels() {
    return mCarModels;
}
}

Activity代码：

btn_xml_sax = (Button) findViewById(R.id.btn_xml_sax);
    btn_xml_sax.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            getCar();
            System.out.println(parserSax());
            tv_xml_sax.setText(parserSax());
        }
    });

private void getCar() {
    //获取到需要解析的xml文件
    InputStream inputStream = null;
    try {
        inputStream = this.getAssets().open("car.xml");
        //1、通过SAXParserFactory.newInstance()创建一个SAXParserFactory
        SAXParserFactory factory = SAXParserFactory.newInstance();
        //2、通过SAXParserFactory.newSAXParser()方法返回一个SAXParser解析器
        SAXParser parser = factory.newSAXParser();
        //3、实例化一个DefaultHandler对象
        SAXHandler handler = new SAXHandler();
        //4、将第二步创建的SAXParser分配给解析器,对文档进行解析,将事件发送给处理器
        parser.parse(inputStream, handler);
        inputStream.close();
        mCarModels = handler.getCarModels();
    } catch (Exception e) {
        e.printStackTrace();
    }

}

private String parserSax() {
    StringBuffer buffer = new StringBuffer();
    for (int i = 0; i < mCarModels.size(); i++) {
        buffer.append("车名：");
        buffer.append(mCarModels.get(i).getCar_name() + " ,");
        buffer.append(" 颜色：");
        buffer.append(mCarModels.get(i).getCar_color() + " ,");
        buffer.append(" 价格：");
        buffer.append(mCarModels.get(i).getCar_pice() + " 元");
        buffer.append("\n");
    }
    return buffer.toString();
}

实现效果图：

这样就可以实现SAX方式解析XMl数据

1.3、DOM方式解析XML数据

　　 DOM方式是将XML文档中的内容全部以树的方式加载到内存中，检索的时候需要将文档内容全部加载到内存中和构造树形结构完成之后才会开始，允许开发人员使用DOM API对文档进行读取、搜索、修改、添加和删除等操作。

　　DOM解析方式的原理：使用DOM对XML文件进行操作时，首先要解析文件，将文件分为独立的元素、属性和注释等，然后以节点树的形式在内存中对XML文件进行表示，就可以通过节点树访问文档的内容，并根据需要修改文档。

常用的DoM接口和类：

• Document：该接口定义分析并创建DOM文档的一系列方法，它是文档树的根，是操作DOM的基础。

• Element：该接口继承Node接口，提供了获取、修改XML元素名字和属性的方法。

• Node：该接口提供处理并获取节点和子节点值的方法。

• NodeList：提供获得节点个数和当前节点的方法。这样就可以迭代地访问各个节点。

• DOMParser：该类是Apache的Xerces中的DOM解析器类，可直接解析XML文件。

DOM解析方式使用步骤：

• 1、通过DocumentBuilderFactory.newInstance()创建一个DocumentBuilderFactory对象实例

• 2、通过factory.newDocumentBuilder()创建一个DocumentBuilder对象实例

• 3、然后加载XML文档（Document）

• 4、然后获取文档的根结点(Element)

• 5、然后获取根结点中所有子节点的列表（NodeList）

• 6、然后使用再获取子节点列表中的需要读取的结点。

下面通过一个例子体会一下DOM方式解析数据：

Activity代码：

private String parserDom() {
    List<CarModel> modelList = new ArrayList<>();
    //1、通过DocumentBuilderFactory.newInstance()创建一个DocumentBuilderFactory对象实例
    DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    try {
        //2、通过factory.newDocumentBuilder()创建一个DocumentBuilder对象实例
        DocumentBuilder builder = factory.newDocumentBuilder();
        //3、将需要解析的文档加载到内存中
        Document document = builder.parse(getAssets().open("car.xml"));
        //4、获取到根节点
        Element root = document.getDocumentElement();
        //5、获取根节点的所有子节点列表
        NodeList rootList = root.getElementsByTagName("car");
        //6、开始读取需要的节点
        for (int i = 0; i < rootList.getLength(); i++) {
            CarModel model = new CarModel();
            Node car = rootList.item(i);
            NodeList childList = car.getChildNodes();

            for (int j = 0; j < childList.getLength(); j++) {
                Node childNode = childList.item(j);
                //判断子节点类型是否是元素节点
                if (childNode.getNodeType() == Node.ELEMENT_NODE) {
                    Element childName = (Element) childNode;
                    String nodeName = childName.getNodeName();
                    if (nodeName.equals("car_name")) {
                        model.setCar_name(childName.getFirstChild().getNodeValue());
                    } else if (nodeName.equals("car_color")) {
                        model.setCar_color(childName.getFirstChild().getNodeValue());
                    } else if (nodeName.equals("car_pice")) {
                        model.setCar_pice(childName.getFirstChild().getNodeValue());
                    }

                }

            }
            modelList.add(model);

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

    StringBuffer buffer = new StringBuffer();
    buffer.append("使用DOM方式解析").append("\n").append("\n");
    for (int i = 0; i < modelList.size(); i++) {
        buffer.append("车名：");
        buffer.append(modelList.get(i).getCar_name() + " ,");
        buffer.append(" 颜色：");
        buffer.append(modelList.get(i).getCar_color() + " ,");
        buffer.append(" 价格：");
        buffer.append(modelList.get(i).getCar_pice() + " 元");
        buffer.append("\n");
    }
    return buffer.toString();
}

实现的效果图

1.4、PULL方式XML数据

　　 Android并未提供对Java StAX API的支持。但是，Android附带了一个pull解析器，其工作方式类似于StAX。它允许用户的应用程序代码从解析器中获取事件，这与SAX解析器自动将事件推入处理程序相反。

　　PULL解析器的运行方式和SAX类似，都是基于事件的模式。不同的是，在PULL解析过程中返回的是数字，且我们需要自己获取产生的事件然后做相应的操作，而不像SAX那样由处理器触发一种事件的方法，执行我们的代码。PULL解析器小巧轻便，解析速度快，简单易用，非常适合在Android移动设备中使用，Android系统内部在解析各种XML时也是用PULL解析器，Android官方推荐开发者们使用Pull解析技术。

　　PULL 的工作原理：XML pull提供了开始元素和结束元素。当某个元素开始时，我们可以调用parser．nextText从XML文档中提取所有字符数据。当解释到一个文档结束时，自动生成EndDocument事件。

常用的XML PULL的接口和类：

• XmlPullParser：XML pull解析器是一个在XMLPULL VlAP1中提供了定义解析功能的接口。

• XmlSerializer：它是一个接口，定义了XML信息集的序列。

• XmlPullParserFactory：这个类用于在XMPULL V1 API中创建XML Pull解析器。

• XmlPullParserException：抛出单一的XML pull解析器相关的错误。

使用PULL解析器解析的步骤：

• 1、1、创建一个XmlPullParser对象实例,有两种方式：Xml.newPullParser()；通过XmlPullParserFactory.newInstance()获取到XmlPullParserFactory对象实例，然后通过factory.newPullParser()创建

• 2、得到文件流，设置输出方式

• 3、获得解析到的事件类别，这里有开始文档，结束文档，开始标签，结束标签，文本等事件

• 4、开始解析和获取数据

下面通过实例体会一下这种解析方式：

private String parserPull() {
    //1、创建一个XmlPullParser对象实例,有两种方式：Xml.newPullParser()；通过XmlPullParserFactory.newInstance()获取到XmlPullParserFactory对象实例，然后通过factory.newPullParser()创建
    XmlPullParser pullParser = Xml.newPullParser();
    List<CarModel> modelList = new ArrayList<>();
    CarModel model = null;
    try {
        //2、得到文件流，设置输出方式
        pullParser.setInput(getAssets().open("car.xml"), "UTF-8");
        //3、获得解析到的事件类别，这里有开始文档，结束文档，开始标签，结束标签，文本等事件
        int eventType = pullParser.getEventType();
        String name = "";
        while (eventType != XmlPullParser.END_DOCUMENT) {
            name = pullParser.getName();
            switch (eventType) {
                case XmlPullParser.START_DOCUMENT:
                    break;
                case XmlPullParser.START_TAG:
                    if (name.equals("car")) {
                        model = new CarModel();
                    } else if (name.equals("car_name")) {
                        model.setCar_name(pullParser.nextText());
                    } else if (name.equals("car_color")) {
                        model.setCar_color(pullParser.nextText());
                    } else if (name.equals("car_pice")) {
                        model.setCar_pice(pullParser.nextText());
                    }
                    break;
                case XmlPullParser.END_TAG:
                    if (name.equals("car")) {
                        modelList.add(model);
                        model = null;
                    }
                    break;
            }
            eventType = pullParser.next();
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    StringBuffer buffer = new StringBuffer();
    buffer.append("使用PULL方式解析").append("\n").append("\n");
    for (int i = 0; i < modelList.size(); i++) {
        buffer.append("车名：");
        buffer.append(modelList.get(i).getCar_name() + " ,");
        buffer.append(" 颜色：");
        buffer.append(modelList.get(i).getCar_color() + " ,");
        buffer.append(" 价格：");
        buffer.append(modelList.get(i).getCar_pice() + " 元");
        buffer.append("\n");
    }
    return buffer.toString();
}

最终实现的效果：

　　上面我们已经完成了三种方式解析XML数据的基本介绍，对于Android的移动设备而言，因为设备的资源比较宝贵，内存是有限的，所以我们需要选择适合的技术来解析XML，这样有利于提高访问的速度。DOM在处理XML文件时，将XML文件解析成树状结构并放入内存中进行处理。当XML文件较小时，我们可以选DOM，因为它简单、直观。SAX则是以事件作为解析XML文件的模式，它将XML文件转化成一系列的事件，由不同的事件处理器来决定如何处理。XML文件较大时，选择SAX技术是比较合理的。虽然代码量有些大，但是它不需要将所有的XML文件加载到内存中。这样对于有限的Android内存更有效，而且Android提供了一种传统的SAX使用方法以及一个便捷的SAX包装器。。XML pull解析并未像SAX解析那样监听元素的结束，而是在开始处完成了大部分处理。这有利于提早读取XML文件，可以极大的减少解析时间，这种优化对于连接速度较漫的移动设备而言尤为重要。对于XML文档较大但只需要文档的一部分时，XML Pull解析器则是更为有效的方法。

2、JSON数据解析

2.1、JSON数据简介

　　一种轻量级的数据交换格式，具有良好的可读和便于快速编写的特性。业内主流技术为其提供了完整的解决方案（有点类似于正则表达式 ，获得了当今大部分语言的支持），从而可以在不同平台间进行数据交换。JSON采用兼容性很高的文本格式，同时也具备类似于C语言体系的行为。

JSON和XMl的比较：

• 1.JSON和XML的数据可读性基本相同

• 2.JSON和XML同样拥有丰富的解析手段

• 3.JSON相对于XML来讲，数据的体积小

• 4.JSON与JavaScript的交互更加方便

• 5.JSON对数据的描述性比XML较差

• 6.JSON的速度要远远快于XML

Android给我们提供的解析JSON的类：

• JSONObject：可以看作是一个json对象,这是系统中有关JSON定义的基本单元，其包含一对(Key/Value)数值。

• JSONStringer：json文本构建类 ，根据官方的解释，这个类可以帮助快速和便捷的创建JSON text。其最大的优点在于可以减少由于 格式的错误导致程序异常，引用这个类可以自动严格按照JSON语法规则（syntax rules）创建JSON text。每个JSONStringer实体只能对应创建一个JSON text。

• JSONArray：它代表一组有序的数值。将其转换为String输出(toString)所表现的形式是用方括号包裹，数值以逗号”,”分隔（例如：[value1,value2,value3]）。

JSONTokener：json解析类 
JSONException：json中用到的异常

2.2、Android实现解析JSON数据

下面我们通过例子体会一下JSON数据解析：

Activity代码：

package com.example.datasave;

import android.os.Bundle;
import android.support.annotation.Nullable;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

import org.json.JSONArray;
import org.json.JSONObject;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

/**
 * Created by Devin on 2016/7/25.
 */
public class JSONParserActivity extends AppCompatActivity {
private Button btn_json;
private TextView tv_json;

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_json);
    btn_json = (Button) findViewById(R.id.btn_json);
    tv_json = (TextView) findViewById(R.id.tv_json);
    btn_json.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            tv_json.setText(parserJson());
        }
    });
}

private String parserJson() {
    List<CityWeatherModel> modelList = new ArrayList<>();
    try {
        InputStream inputStream = getAssets().open("city.json");
        String json = Stream2String(inputStream);
        JSONObject jsonObject = new JSONObject(json);
        JSONArray result = jsonObject.getJSONArray("result");
        JSONObject j1 = result.getJSONObject(0);
        JSONObject lastTwoWeeks = j1.getJSONObject("lastTwoWeeks");

        for (int i = 1; i <= 17; i++) {
            CityWeatherModel model = new CityWeatherModel();
            JSONObject object = lastTwoWeeks.getJSONObject("" + i + "");
            model.setCity(object.getString("city"));
            model.setAOI(object.getString("AQI"));
            model.setQuality(object.getString("quality"));
            model.setDate(object.getString("date"));
            modelList.add(model);
        }

        inputStream.close();
    } catch (Exception e) {
        e.printStackTrace();
    }
    StringBuffer buffer = new StringBuffer();
    for (int i = 0; i < modelList.size(); i++) {
        buffer.append("城市：" + modelList.get(i).getCity());
        buffer.append(" AQI：" + modelList.get(i).getAOI());
        buffer.append(" 天气状况：" + modelList.get(i).getQuality());
        buffer.append(" 日期：" + modelList.get(i).getDate() + "\n");
    }
    return buffer.toString();
}

private String Stream2String(InputStream is) {
    BufferedReader reader = new BufferedReader(new InputStreamReader(is), 16 * 1024); //强制缓存大小为16KB，一般Java类默认为8KB
    StringBuilder sb = new StringBuilder();
    String line = null;
    try {
        while ((line = reader.readLine()) != null) {  //处理换行符
            sb.append(line + "\n");
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            is.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    return sb.toString();
}


}

JSON数据：

{
"resultcode": "200",
"reason": "SUCCESSED!",
"error_code": 0,
"result": [
    {
        "lastTwoWeeks": {
            "1": {
                "city": "suzhou",
                "AQI": "100",
                "quality": "良",
                "date": "2014-05-08"
            },
            "2": {
                "city": "suzhou",
                "AQI": "99",
                "quality": "良",
                "date": "2014-05-07"
            },
            "3": {
                "city": "suzhou",
                "AQI": "77",
                "quality": "良",
                "date": "2014-05-06"
            },
            "4": {
                "city": "suzhou",
                "AQI": "75",
                "quality": "良",
                "date": "2014-05-05"
            },
            "5": {
                "city": "suzhou",
                "AQI": "78",
                "quality": "良",
                "date": "2014-05-04"
            },
            "6": {
                "city": "suzhou",
                "AQI": "84",
                "quality": "良",
                "date": "2014-05-03"
            },
            "7": {
                "city": "suzhou",
                "AQI": "135",
                "quality": "轻度污染",
                "date": "2014-05-02"
            },
            "8": {
                "city": "suzhou",
                "AQI": "126",
                "quality": "轻度污染",
                "date": "2014-05-01"
            },
            "9": {
                "city": "suzhou",
                "AQI": "87",
                "quality": "良",
                "date": "2014-04-30"
            },
            "10": {
                "city": "suzhou",
                "AQI": "97",
                "quality": "良",
                "date": "2014-04-29"
            },
            "11": {
                "city": "suzhou",
                "AQI": "77",
                "quality": "良",
                "date": "2014-04-28"
            },
            "12": {
                "city": "suzhou",
                "AQI": "84",
                "quality": "良",
                "date": "2014-04-27"
            },
            "13": {
                "city": "suzhou",
                "AQI": "45",
                "quality": "优",
                "date": "2014-04-26"
            },
            "14": {
                "city": "suzhou",
                "AQI": "56",
                "quality": "良",
                "date": "2014-04-25"
            },
            "15": {
                "city": "suzhou",
                "AQI": "83",
                "quality": "良",
                "date": "2014-04-24"
            },
            "16": {
                "city": "suzhou",
                "AQI": "95",
                "quality": "良",
                "date": "2014-04-23"
            },
            "17": {
                "city": "suzhou",
                "AQI": "101",
                "quality": "轻度污染",
                "date": "2014-04-22"
            }
        }

    }
]
}

实现效果图：

这样实现了JSON数据的解析，在我们实际开发中，很多情况下都是使用JSON，所以我们必须要掌握这些解析方式。但是很多情况下都是使用被人写好的解析框架，比如GSON、FastJson等，后面我们会介绍这些框架。