概述
在网络中，数据交互通常是以XML和Json的格式进行，所以对这两种格式的数据进行解析，是Android开发中的必备功能，本文以一个简单的小例子，简述Android开发中Xml和Json解析的常用方式，仅供学习分享使用。
XML解析
Android 提供了三种解析XML的方式：SAX(Simple API XML), DOM(Document Object Model), PULL，本文主要讲解Pull的方式解析Xml。
PULL解析Xml优点：PULL解析器小巧轻便，解析速度快，简单易用，非常适合在Android移动设备中使用，Android系统内部在解析各种XML时也是用PULL解析器，Android官方推荐开发者们使用Pull解析技术。Pull解析技术是第三方开发的开源技术，它同样可以应用于JavaSE开发。
涉及知识点
- XmlPullParser 是一个提供对XML进行Pull方式解析的基础功能的接口。
- xmlPullParser.getEventType() 返回当前节点的事件类型(如：START_TAG, END_TAG, TEXT, etc.)。
- xmlPullParser.getName() 获取当前节点对应的名称。
- xmlPullParser.getAttributeCount() 获取当前节点对应的属性个数。
- xmlPullParser.getText() 获取当前节点对应的文本内容。
- xmlPullParser.getAttributeName(0) 获取属性对应的名称。
- xmlPullParser.getAttributeValue(0) 获取属性对应的值。
- xmlPullParser.next() 移动到下一个事件。
Xml文件
Xml存放相对路径：DemoXml\app\src\main\res\xml\test.xml [xml文件夹]
<bookstore>
<book category="COOKING">
<title lang="en">Everyday Italian</title>
<author>Giada De Laurentiis</author>
<year>2005</year>
<price>30.00</price>
</book>
<book category="CHILDREN">
<title lang="en">Harry Potter</title>
<author>J K. Rowling</author>
<year>2005</year>
<price>29.99</price>
</book>
<book category="WEB">
<title lang="en">Learning XML</title>
<author>Erik T. Ray</author>
<year>2003</year>
<price>39.95</price>
</book>
</bookstore>
Xml解析源码
/**
* 获取Xml内容
* @param resources
* @param id
* @return
* @throws XmlPullParserException
* @throws IOException
*/
private List<String> xml_parser(Resources resources, int id) throws XmlPullParserException, IOException {
XmlPullParser xmlPullParser = resources.getXml(id);
List<String> lstContent=new ArrayList<String>();
int eventType = xmlPullParser.getEventType();
while (eventType != XmlPullParser.END_DOCUMENT) {
switch (eventType) {
case XmlPullParser.START_DOCUMENT://文档开始
Log.i(TAG, "xml_parser: START_DOCUMENT");
break;
case XmlPullParser.END_DOCUMENT://文档结束
Log.i(TAG, "xml_parser: END_DOCUMENT");
break;
case XmlPullParser.START_TAG://标记（元素，节点）开始
Log.i(TAG, "xml_parser: START_TAG");
String tagName = xmlPullParser.getName();
//有些节点是没有属性值的，所以需要判断，否则会越界
int count = xmlPullParser.getAttributeCount();//获取属性个个数
String tagAttributeValue="";
String tagAttributeName="";
//String text =xmlPullParser.getText();//此处获取不到text
String content="";
if (count > 0) {
tagAttributeName=xmlPullParser.getAttributeName(0);
tagAttributeValue = xmlPullParser.getAttributeValue(0);
content="标签="+tagName+"属性名="+tagAttributeName+"属性值="+tagAttributeValue;
}else{
content="标签="+tagName;
}
lstContent.add(content);
break;
case XmlPullParser.TEXT:
String text =xmlPullParser.getText();
lstContent.add("节点内容="+text);
break;
case XmlPullParser.END_TAG://标记结束
Log.i(TAG, "xml_parser: END_TAG");
break;
}
eventType = xmlPullParser.next();
}
return lstContent;
}
如果Xml文件过大的话，则不适合在Activity主线程中执行，本文是在Worker线程中执行的，如下所示：
private static final String TAG="TAG";
private static final int MSG_FINISH=0x0001;
private TextView tvMsg;
private Handler handler=new Handler(){
@Override
public void handleMessage(Message msg) {
switch (msg.what){
case MSG_FINISH:
List<String> lstContent=(List<String>)msg.obj;
for (String info :lstContent){
tvMsg.append(info+"\r\n");
}
break;
}
}
};
public void bn_xml_parser_click(View view){
tvMsg.setText("");
new Thread(){
@Override
public void run() {
try {
List<String> lstContent=xml_parser(getResources(),R.xml.test);
Message msg=handler.obtainMessage();
msg.what=MSG_FINISH;
msg.obj=lstContent;
handler.sendMessage(msg);
} catch (XmlPullParserException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}.start();
}
JSON解析
Json是一种轻量级的数据交换格式，具有良好的可读和便于快速编写的特性。业内主流技术为其提供了完整的解决方案，从而可以在不同平台间进行数据交换。
涉及知识点
- JSONObject 表示一个Json格式的对象。
- jsonObject.getString("key"); 获取字符串格式的值。
- jsonObject.getInt("key"); 获取Int类型的值。
- jsonObject.getBoolean("key"); 获取bool类型的值。
- jsonObject.getDouble("key"); 获取浮点数类型的值。
- jsonObject.get("key"); 返回Object类型的对象。
- jsonObject.getJSONArray("key"); 返回数据类型的对象。
- InputStream 输入流。
Json文件
Json存放相对路径：DemoXml\app\src\main\res\raw\test2.json [raw文件夹]
{
"name": "小明",
"age": 14,
"gender": true,
"height": 1.65,
"grade": null,
"middle_school": "\"W3C\" Middle School",
"skills": [
"JavaScript",
"Java",
"Python",
"Lisp"
]
}
Json解析源码
/**
* 解析到列表
* @return
* @throws IOException
* @throws JSONException
*/
private List<String> json_parser() throws IOException, JSONException {
List<String> lstContent = new ArrayList<String>();
String data = getContent(getResources(), R.raw.test2);
JSONObject jsonObject = new JSONObject(data);
String name = jsonObject.getString("name");
int age = jsonObject.getInt("age");
boolean gender = jsonObject.getBoolean("gender");
double height = jsonObject.getDouble("height");
Object grade = jsonObject.get("grade");
String middleSchool = jsonObject.getString("middle_school");
JSONArray jsonArray = jsonObject.getJSONArray("skills");
lstContent.add("name=" + name);
lstContent.add("age=" + age);
lstContent.add("gender=" + gender);
lstContent.add("height=" + height);
lstContent.add("grade=" + grade);
lstContent.add("middleSchool=" + middleSchool);
for (int i = 0; i < jsonArray.length(); i++) {
String skill = jsonArray.getString(i);
lstContent.add("skill=" + skill);
}
return lstContent;
} /**
* 通过id获取Json文件对应的内容
* @param resources
* @param id
* @return
* @throws IOException
*/
private String getContent(Resources resources, int id) throws IOException {
StringBuilder stringBuilder = new StringBuilder();
InputStream inputStream = null;
try {
inputStream = resources.openRawResource(id);
byte[] bytes = new byte[1024];
int length = inputStream.read(bytes, 0, 1024);
while (length > -1) {
stringBuilder.append(new String(bytes, 0, length));
length = inputStream.read(bytes, 0, 1024);
}
} finally {
if (inputStream != null) {
inputStream.close();
}
}
return stringBuilder.toString();
}
同样，如果Json文件比较大，或者解析比较慢，则不能在Activity主线程中执行，需要新启动一个Worker线程，在后台执行，如下所示：
private static final String TAG="TAG";
private static final int MSG_FINISH=0x0001;
private static final int MSG_SERIALIZE=0x0002;
private TextView tvMsg;
private Handler handler=new Handler(){
@Override
public void handleMessage(Message msg) {
switch (msg.what){
case MSG_FINISH:
List<String> lstContent=(List<String>)msg.obj;
for (String info :lstContent){
tvMsg.append(info+"\r\n");
}
break;
}
}
};
/**
* 解析Json
* @param view
*/
public void bn_json_parser_click(View view) {
tvMsg.setText("");
new Thread() {
@Override
public void run() {
try {
List<String> lstContent = json_parser();
Message msg = handler.obtainMessage();
msg.what = MSG_FINISH;
msg.obj = lstContent;
handler.sendMessage(msg);
} catch (IOException e) {
e.printStackTrace();
} catch (JSONException e) {
e.printStackTrace();
}
}
}.start();
}
如果需要将Json反序列化成类对象，或者将类对象序列化成Json格式文件，如下是一个帮助类：
package com.hex.demoxml; import android.util.Log; import java.util.Collection;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Collection;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import org.json.JSONStringer; /** JSON序列化辅助类 **/
public class JsonHelper {
private static final String TAG="TAG";
/**
* 将对象转换成Json字符串
**/
public static String toJSON(Object obj) {
JSONStringer js = new JSONStringer();
serialize(js, obj);
return js.toString();
} /**
* 序列化为JSON
**/
private static void serialize(JSONStringer js, Object o) {
if (isNull(o)) {
try {
js.value(null);
} catch (JSONException e) {
e.printStackTrace();
}
return;
} Class<?> clazz = o.getClass();
if (isObject(clazz)) { // 对象
serializeObject(js, o);
} else if (isArray(clazz)) { // 数组
serializeArray(js, o);
} else if (isCollection(clazz)) { // 集合
Collection<?> collection = (Collection<?>) o;
serializeCollect(js, collection);
} else { // 单个值
try {
js.value(o);
} catch (JSONException e) {
e.printStackTrace();
}
}
} /**
* 序列化数组
**/
private static void serializeArray(JSONStringer js, Object array) {
try {
js.array();
for (int i = 0; i < Array.getLength(array); ++i) {
Object o = Array.get(array, i);
serialize(js, o);
}
js.endArray();
} catch (Exception e) {
e.printStackTrace();
}
} /**
* 序列化集合
**/
private static void serializeCollect(JSONStringer js, Collection<?> collection) {
try {
js.array();
for (Object o : collection) {
serialize(js, o);
}
js.endArray();
} catch (Exception e) {
e.printStackTrace();
}
} /**
* 序列化对象
**/
private static void serializeObject(JSONStringer js, Object obj) {
try {
js.object();
for (Field f : obj.getClass().getFields()) {
Object o = f.get(obj);
js.key(f.getName());
serialize(js, o);
}
js.endObject();
} catch (Exception e) {
e.printStackTrace();
}
} /**
* 反序列化简单对象
*
* @throws
**/
public static <T> T parseObject(JSONObject jo, Class<T> clazz) {
Log.i(TAG, "parseObject: >>>>>>第二个开始");
if (clazz == null || isNull(jo)) {
Log.i(TAG, "parseObject: >>>>>>第二个parseObject");
return null;
} T obj = createInstance(clazz);
if (obj == null) {
Log.i(TAG, "parseObject: >>>>>>创建实例为空");
return null;
}
Log.i(TAG, "parseObject: >>>>>>属性长度"+clazz.getFields().length);
Log.i(TAG, "parseObject: >>>>>>属性长度2"+clazz.getClass());
for (Field f : clazz.getFields()) {
Log.i(TAG, "parseObject: >>>>>>"+f.getName());
setField(obj, f, jo);
//Log.i(TAG, "parseObject: >>>>>>"+obj.);
}
Log.i(TAG, "parseObject: >>>>>返回obj"+obj.getClass());
return obj;
} /**
* 反序列化简单对象
*
* @throws
**/
public static <T> T parseObject(String jsonString, Class<T> clazz) {
if (clazz == null || jsonString == null || jsonString.length() == 0) {
Log.i(TAG, "parseObject: >>>>>>>null");
return null;
}
Log.i(TAG, "parseObject: >>>>>>>not null");
JSONObject jo = null;
try {
jo = new JSONObject(jsonString);
} catch (JSONException e) {
Log.i(TAG, "parseObject: >>>>>>转换json对象异常:"+e.getMessage());
e.printStackTrace();
} if (isNull(jo)) {
Log.i(TAG, "parseObject: >>>>>转换后为null");
return null;
}
Log.i(TAG, "parseObject: >>>>>>进入下一步");
return parseObject(jo, clazz);
} /**
* 反序列化数组对象
*
* @throws
**/
public static <T> T[] parseArray(JSONArray ja, Class<T> clazz) {
if (clazz == null || isNull(ja)) {
return null;
} int len = ja.length();
Log.i(TAG, "parseArray: >>>>>"+len);
Log.i(TAG, "parseArray: >>>>>"+clazz.getName());
@SuppressWarnings("unchecked")
T[] array = (T[]) Array.newInstance(clazz, len); for (int i = 0; i < len; ++i) {
try {
Object object=ja.get(i);
if(isSingle(clazz)){
Log.i(TAG, "parseArray: >>>>>:"+object.toString());
array[i]=(T)object.toString();
}else {
JSONObject jo = ja.getJSONObject(i);
Log.i(TAG, "parseArray: >>>>>jo:"+jo.toString());
T o = parseObject(jo, clazz);
Log.i(TAG, "parseArray: >>>>>o:" + o.toString());
array[i] = o;
}
} catch (JSONException e) {
e.printStackTrace();
}
} return array;
} /**
* 反序列化数组对象
*
* @throws
**/
public static <T> T[] parseArray(String jsonString, Class<T> clazz) {
if (clazz == null || jsonString == null || jsonString.length() == 0) {
return null;
}
JSONArray jo = null;
try {
jo = new JSONArray(jsonString);
} catch (JSONException e) {
e.printStackTrace();
} if (isNull(jo)) {
return null;
} return parseArray(jo, clazz);
} /**
* 反序列化泛型集合
*
* @throws
**/
@SuppressWarnings("unchecked")
public static <T> Collection<T> parseCollection(JSONArray ja, Class<?> collectionClazz,
Class<T> genericType) { if (collectionClazz == null || genericType == null || isNull(ja)) {
return null;
} Collection<T> collection = (Collection<T>) createInstance(collectionClazz); for (int i = 0; i < ja.length(); ++i) {
try {
JSONObject jo = ja.getJSONObject(i);
T o = parseObject(jo, genericType);
collection.add(o);
} catch (JSONException e) {
e.printStackTrace();
}
} return collection;
} /**
* 反序列化泛型集合
*
* @throws
**/
public static <T> Collection<T> parseCollection(String jsonString, Class<?> collectionClazz,
Class<T> genericType) {
if (collectionClazz == null || genericType == null || jsonString == null
|| jsonString.length() == 0) {
return null;
}
JSONArray jo = null;
try {
jo = new JSONArray(jsonString);
} catch (JSONException e) {
e.printStackTrace();
} if (isNull(jo)) {
return null;
} return parseCollection(jo, collectionClazz, genericType);
} /**
* 根据类型创建对象
**/
private static <T> T createInstance(Class<T> clazz) {
if (clazz == null)
return null;
T obj = null;
try {
obj = clazz.newInstance();
} catch (Exception e) {
Log.i(TAG, "createInstance: >>>>>>创建实例异常");
e.printStackTrace();
}
return obj;
} /**
* 设定字段的值
**/
private static void setField(Object obj, Field f, JSONObject jo) {
String name = f.getName();
Class<?> clazz = f.getType();
Log.i(TAG, "setField: >>>>>name:"+name);
try {
if (isArray(clazz)) { // 数组
Log.i(TAG, "setField: >>>>>数组");
Class<?> c = clazz.getComponentType();
JSONArray ja = jo.optJSONArray(name);
if (!isNull(ja)) {
Log.i(TAG, "setField: >>>>>ja:"+ja.getString(0));
Object array = parseArray(ja, c);
f.set(obj, array);
}else{
Log.i(TAG, "setField: >>>>>数组为空");
}
} else if (isCollection(clazz)) { // 泛型集合
Log.i(TAG, "setField: >>>>>泛型集合");
// 获取定义的泛型类型
Class<?> c = null;
Type gType = f.getGenericType();
if (gType instanceof ParameterizedType) {
ParameterizedType ptype = (ParameterizedType) gType;
Type[] targs = ptype.getActualTypeArguments();
if (targs != null && targs.length > 0) {
Type t = targs[0];
c = (Class<?>) t;
}
} JSONArray ja = jo.optJSONArray(name);
if (!isNull(ja)) {
Object o = parseCollection(ja, clazz, c);
f.set(obj, o);
}
} else if (isSingle(clazz)) { // 值类型
Log.i(TAG, "setField: >>>>>Single值类型");
Object o = jo.opt(name);
if (o != null) {
f.set(obj, o);
}
} else if (isObject(clazz)) { // 对象
Log.i(TAG, "setField: >>>>>Object对象:"+clazz);
JSONObject j = jo.optJSONObject(name);
if (!isNull(j)) { Object o = parseObject(j, clazz);
f.set(obj, o);
}else{
Log.i(TAG, "setField: >>>>>Object对象为null");
}
} else {
Log.i(TAG, "setField: >>>>>未知类型:"+clazz);
throw new Exception("unknow type!");
}
} catch (Exception e) {
e.printStackTrace();
}
} /**
* 判断对象是否为空
**/
private static boolean isNull(Object obj) {
if (obj instanceof JSONObject) {
return JSONObject.NULL.equals(obj);
}
return obj == null;
} /**
* 判断是否是值类型
**/
private static boolean isSingle(Class<?> clazz) {
return isBoolean(clazz) || isNumber(clazz) || isString(clazz);
} /**
* 是否布尔值
**/
public static boolean isBoolean(Class<?> clazz) {
return (clazz != null)
&& ((Boolean.TYPE.isAssignableFrom(clazz)) || (Boolean.class
.isAssignableFrom(clazz)));
} /**
* 是否数值
**/
public static boolean isNumber(Class<?> clazz) {
return (clazz != null)
&& ((Byte.TYPE.isAssignableFrom(clazz)) || (Short.TYPE.isAssignableFrom(clazz))
|| (Integer.TYPE.isAssignableFrom(clazz))
|| (Long.TYPE.isAssignableFrom(clazz))
|| (Float.TYPE.isAssignableFrom(clazz))
|| (Double.TYPE.isAssignableFrom(clazz)) || (Number.class
.isAssignableFrom(clazz)));
} /**
* 判断是否是字符串
**/
public static boolean isString(Class<?> clazz) {
return (clazz != null)
&& ((String.class.isAssignableFrom(clazz))
|| (Character.TYPE.isAssignableFrom(clazz)) || (Character.class
.isAssignableFrom(clazz)));
} /**
* 判断是否是对象
**/
private static boolean isObject(Class<?> clazz) {
return clazz != null && !isSingle(clazz) && !isArray(clazz) && !isCollection(clazz);
} /**
* 判断是否是数组
**/
public static boolean isArray(Class<?> clazz) {
return clazz != null && clazz.isArray();
} /**
* 判断是否是集合
**/
public static boolean isCollection(Class<?> clazz) {
return clazz != null && Collection.class.isAssignableFrom(clazz);
}
}
备注
沉舟侧畔千帆过，病树前头万木春。