概述

在网络中,数据交互通常是以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文件夹]

  1. <bookstore>
  2. <book category="COOKING">
  3. <title lang="en">Everyday Italian</title>
  4. <author>Giada De Laurentiis</author>
  5. <year>2005</year>
  6. <price>30.00</price>
  7. </book>
  8. <book category="CHILDREN">
  9. <title lang="en">Harry Potter</title>
  10. <author>J K. Rowling</author>
  11. <year>2005</year>
  12. <price>29.99</price>
  13. </book>
  14. <book category="WEB">
  15. <title lang="en">Learning XML</title>
  16. <author>Erik T. Ray</author>
  17. <year>2003</year>
  18. <price>39.95</price>
  19. </book>
  20. </bookstore>

Xml解析源码

  1. /**
  2. * 获取Xml内容
  3. * @param resources
  4. * @param id
  5. * @return
  6. * @throws XmlPullParserException
  7. * @throws IOException
  8. */
  9. private List<String> xml_parser(Resources resources, int id) throws XmlPullParserException, IOException {
  10. XmlPullParser xmlPullParser = resources.getXml(id);
  11. List<String> lstContent=new ArrayList<String>();
  12. int eventType = xmlPullParser.getEventType();
  13. while (eventType != XmlPullParser.END_DOCUMENT) {
  14. switch (eventType) {
  15. case XmlPullParser.START_DOCUMENT://文档开始
  16. Log.i(TAG, "xml_parser: START_DOCUMENT");
  17. break;
  18. case XmlPullParser.END_DOCUMENT://文档结束
  19. Log.i(TAG, "xml_parser: END_DOCUMENT");
  20. break;
  21. case XmlPullParser.START_TAG://标记(元素,节点)开始
  22. Log.i(TAG, "xml_parser: START_TAG");
  23. String tagName = xmlPullParser.getName();
  24. //有些节点是没有属性值的,所以需要判断,否则会越界
  25. int count = xmlPullParser.getAttributeCount();//获取属性个个数
  26. String tagAttributeValue="";
  27. String tagAttributeName="";
  28. //String text =xmlPullParser.getText();//此处获取不到text
  29. String content="";
  30. if (count > 0) {
  31. tagAttributeName=xmlPullParser.getAttributeName(0);
  32. tagAttributeValue = xmlPullParser.getAttributeValue(0);
  33. content="标签="+tagName+"属性名="+tagAttributeName+"属性值="+tagAttributeValue;
  34. }else{
  35. content="标签="+tagName;
  36. }
  37. lstContent.add(content);
  38. break;
  39. case XmlPullParser.TEXT:
  40. String text =xmlPullParser.getText();
  41. lstContent.add("节点内容="+text);
  42. break;
  43. case XmlPullParser.END_TAG://标记结束
  44. Log.i(TAG, "xml_parser: END_TAG");
  45. break;
  46. }
  47. eventType = xmlPullParser.next();
  48. }
  49. return lstContent;
  50. }

如果Xml文件过大的话,则不适合在Activity主线程中执行,本文是在Worker线程中执行的,如下所示:

  1. private static final String TAG="TAG";
  2.  
  3. private static final int MSG_FINISH=0x0001;
  4.  
  5. private TextView tvMsg;
  6.  
  7. private Handler handler=new Handler(){
  8. @Override
  9. public void handleMessage(Message msg) {
  10. switch (msg.what){
  11. case MSG_FINISH:
  12. List<String> lstContent=(List<String>)msg.obj;
  13. for (String info :lstContent){
  14. tvMsg.append(info+"\r\n");
  15. }
  16. break;
  17. }
  18. }
  19. };
  20.  
  21. public void bn_xml_parser_click(View view){
  22. tvMsg.setText("");
  23. new Thread(){
  24. @Override
  25. public void run() {
  26. try {
  27. List<String> lstContent=xml_parser(getResources(),R.xml.test);
  28. Message msg=handler.obtainMessage();
  29. msg.what=MSG_FINISH;
  30. msg.obj=lstContent;
  31. handler.sendMessage(msg);
  32. } catch (XmlPullParserException e) {
  33. e.printStackTrace();
  34. } catch (IOException e) {
  35. e.printStackTrace();
  36. }
  37. }
  38. }.start();
  39. }

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文件夹]

  1. {
  2. "name": "小明",
  3. "age": 14,
  4. "gender": true,
  5. "height": 1.65,
  6. "grade": null,
  7. "middle_school": "\"W3C\" Middle School",
  8. "skills": [
  9. "JavaScript",
  10. "Java",
  11. "Python",
  12. "Lisp"
  13. ]
  14. }

Json解析源码

  1. /**
  2. * 解析到列表
  3. * @return
  4. * @throws IOException
  5. * @throws JSONException
  6. */
  7. private List<String> json_parser() throws IOException, JSONException {
  8. List<String> lstContent = new ArrayList<String>();
  9. String data = getContent(getResources(), R.raw.test2);
  10. JSONObject jsonObject = new JSONObject(data);
  11. String name = jsonObject.getString("name");
  12. int age = jsonObject.getInt("age");
  13. boolean gender = jsonObject.getBoolean("gender");
  14. double height = jsonObject.getDouble("height");
  15. Object grade = jsonObject.get("grade");
  16. String middleSchool = jsonObject.getString("middle_school");
  17. JSONArray jsonArray = jsonObject.getJSONArray("skills");
  18. lstContent.add("name=" + name);
  19. lstContent.add("age=" + age);
  20. lstContent.add("gender=" + gender);
  21. lstContent.add("height=" + height);
  22. lstContent.add("grade=" + grade);
  23. lstContent.add("middleSchool=" + middleSchool);
  24. for (int i = 0; i < jsonArray.length(); i++) {
  25. String skill = jsonArray.getString(i);
  26. lstContent.add("skill=" + skill);
  27. }
  28. return lstContent;
  29. }
  30.  
  31. /**
  32. * 通过id获取Json文件对应的内容
  33. * @param resources
  34. * @param id
  35. * @return
  36. * @throws IOException
  37. */
  38. private String getContent(Resources resources, int id) throws IOException {
  39. StringBuilder stringBuilder = new StringBuilder();
  40. InputStream inputStream = null;
  41. try {
  42. inputStream = resources.openRawResource(id);
  43. byte[] bytes = new byte[1024];
  44. int length = inputStream.read(bytes, 0, 1024);
  45. while (length > -1) {
  46. stringBuilder.append(new String(bytes, 0, length));
  47. length = inputStream.read(bytes, 0, 1024);
  48. }
  49. } finally {
  50. if (inputStream != null) {
  51. inputStream.close();
  52. }
  53. }
  54. return stringBuilder.toString();
  55. }

同样,如果Json文件比较大,或者解析比较慢,则不能在Activity主线程中执行,需要新启动一个Worker线程,在后台执行,如下所示:

  1. private static final String TAG="TAG";
  2.  
  3. private static final int MSG_FINISH=0x0001;
  4.  
  5. private static final int MSG_SERIALIZE=0x0002;
  6.  
  7. private TextView tvMsg;
  8.  
  9. private Handler handler=new Handler(){
  10. @Override
  11. public void handleMessage(Message msg) {
  12. switch (msg.what){
  13. case MSG_FINISH:
  14. List<String> lstContent=(List<String>)msg.obj;
  15. for (String info :lstContent){
  16. tvMsg.append(info+"\r\n");
  17. }
  18. break;
  19. }
  20. }
  21. };
  22.  
  23. /**
  24. * 解析Json
  25. * @param view
  26. */
  27. public void bn_json_parser_click(View view) {
  28. tvMsg.setText("");
  29. new Thread() {
  30. @Override
  31. public void run() {
  32. try {
  33. List<String> lstContent = json_parser();
  34. Message msg = handler.obtainMessage();
  35. msg.what = MSG_FINISH;
  36. msg.obj = lstContent;
  37. handler.sendMessage(msg);
  38. } catch (IOException e) {
  39. e.printStackTrace();
  40. } catch (JSONException e) {
  41. e.printStackTrace();
  42. }
  43. }
  44. }.start();
  45. }

如果需要将Json反序列化成类对象,或者将类对象序列化成Json格式文件,如下是一个帮助类:

  1. package com.hex.demoxml;
  2.  
  3. import android.util.Log;
  4.  
  5. import java.util.Collection;
  6. import java.lang.reflect.Array;
  7. import java.lang.reflect.Field;
  8. import java.lang.reflect.ParameterizedType;
  9. import java.lang.reflect.Type;
  10. import java.util.Collection;
  11. import org.json.JSONArray;
  12. import org.json.JSONException;
  13. import org.json.JSONObject;
  14. import org.json.JSONStringer;
  15.  
  16. /** JSON序列化辅助类 **/
  17. public class JsonHelper {
  18. private static final String TAG="TAG";
  19. /**
  20. * 将对象转换成Json字符串
  21. **/
  22. public static String toJSON(Object obj) {
  23. JSONStringer js = new JSONStringer();
  24. serialize(js, obj);
  25. return js.toString();
  26. }
  27.  
  28. /**
  29. * 序列化为JSON
  30. **/
  31. private static void serialize(JSONStringer js, Object o) {
  32. if (isNull(o)) {
  33. try {
  34. js.value(null);
  35. } catch (JSONException e) {
  36. e.printStackTrace();
  37. }
  38. return;
  39. }
  40.  
  41. Class<?> clazz = o.getClass();
  42. if (isObject(clazz)) { // 对象
  43. serializeObject(js, o);
  44. } else if (isArray(clazz)) { // 数组
  45. serializeArray(js, o);
  46. } else if (isCollection(clazz)) { // 集合
  47. Collection<?> collection = (Collection<?>) o;
  48. serializeCollect(js, collection);
  49. } else { // 单个值
  50. try {
  51. js.value(o);
  52. } catch (JSONException e) {
  53. e.printStackTrace();
  54. }
  55. }
  56. }
  57.  
  58. /**
  59. * 序列化数组
  60. **/
  61. private static void serializeArray(JSONStringer js, Object array) {
  62. try {
  63. js.array();
  64. for (int i = 0; i < Array.getLength(array); ++i) {
  65. Object o = Array.get(array, i);
  66. serialize(js, o);
  67. }
  68. js.endArray();
  69. } catch (Exception e) {
  70. e.printStackTrace();
  71. }
  72. }
  73.  
  74. /**
  75. * 序列化集合
  76. **/
  77. private static void serializeCollect(JSONStringer js, Collection<?> collection) {
  78. try {
  79. js.array();
  80. for (Object o : collection) {
  81. serialize(js, o);
  82. }
  83. js.endArray();
  84. } catch (Exception e) {
  85. e.printStackTrace();
  86. }
  87. }
  88.  
  89. /**
  90. * 序列化对象
  91. **/
  92. private static void serializeObject(JSONStringer js, Object obj) {
  93. try {
  94. js.object();
  95. for (Field f : obj.getClass().getFields()) {
  96. Object o = f.get(obj);
  97. js.key(f.getName());
  98. serialize(js, o);
  99. }
  100. js.endObject();
  101. } catch (Exception e) {
  102. e.printStackTrace();
  103. }
  104. }
  105.  
  106. /**
  107. * 反序列化简单对象
  108. *
  109. * @throws
  110. **/
  111. public static <T> T parseObject(JSONObject jo, Class<T> clazz) {
  112. Log.i(TAG, "parseObject: >>>>>>第二个开始");
  113. if (clazz == null || isNull(jo)) {
  114. Log.i(TAG, "parseObject: >>>>>>第二个parseObject");
  115. return null;
  116. }
  117.  
  118. T obj = createInstance(clazz);
  119. if (obj == null) {
  120. Log.i(TAG, "parseObject: >>>>>>创建实例为空");
  121. return null;
  122. }
  123. Log.i(TAG, "parseObject: >>>>>>属性长度"+clazz.getFields().length);
  124. Log.i(TAG, "parseObject: >>>>>>属性长度2"+clazz.getClass());
  125. for (Field f : clazz.getFields()) {
  126. Log.i(TAG, "parseObject: >>>>>>"+f.getName());
  127. setField(obj, f, jo);
  128. //Log.i(TAG, "parseObject: >>>>>>"+obj.);
  129. }
  130. Log.i(TAG, "parseObject: >>>>>返回obj"+obj.getClass());
  131. return obj;
  132. }
  133.  
  134. /**
  135. * 反序列化简单对象
  136. *
  137. * @throws
  138. **/
  139. public static <T> T parseObject(String jsonString, Class<T> clazz) {
  140. if (clazz == null || jsonString == null || jsonString.length() == 0) {
  141. Log.i(TAG, "parseObject: >>>>>>>null");
  142. return null;
  143. }
  144. Log.i(TAG, "parseObject: >>>>>>>not null");
  145. JSONObject jo = null;
  146. try {
  147. jo = new JSONObject(jsonString);
  148. } catch (JSONException e) {
  149. Log.i(TAG, "parseObject: >>>>>>转换json对象异常:"+e.getMessage());
  150. e.printStackTrace();
  151. }
  152.  
  153. if (isNull(jo)) {
  154. Log.i(TAG, "parseObject: >>>>>转换后为null");
  155. return null;
  156. }
  157. Log.i(TAG, "parseObject: >>>>>>进入下一步");
  158. return parseObject(jo, clazz);
  159. }
  160.  
  161. /**
  162. * 反序列化数组对象
  163. *
  164. * @throws
  165. **/
  166. public static <T> T[] parseArray(JSONArray ja, Class<T> clazz) {
  167. if (clazz == null || isNull(ja)) {
  168. return null;
  169. }
  170.  
  171. int len = ja.length();
  172. Log.i(TAG, "parseArray: >>>>>"+len);
  173. Log.i(TAG, "parseArray: >>>>>"+clazz.getName());
  174. @SuppressWarnings("unchecked")
  175. T[] array = (T[]) Array.newInstance(clazz, len);
  176.  
  177. for (int i = 0; i < len; ++i) {
  178. try {
  179. Object object=ja.get(i);
  180. if(isSingle(clazz)){
  181. Log.i(TAG, "parseArray: >>>>>:"+object.toString());
  182. array[i]=(T)object.toString();
  183. }else {
  184. JSONObject jo = ja.getJSONObject(i);
  185. Log.i(TAG, "parseArray: >>>>>jo:"+jo.toString());
  186. T o = parseObject(jo, clazz);
  187. Log.i(TAG, "parseArray: >>>>>o:" + o.toString());
  188. array[i] = o;
  189. }
  190. } catch (JSONException e) {
  191. e.printStackTrace();
  192. }
  193. }
  194.  
  195. return array;
  196. }
  197.  
  198. /**
  199. * 反序列化数组对象
  200. *
  201. * @throws
  202. **/
  203. public static <T> T[] parseArray(String jsonString, Class<T> clazz) {
  204. if (clazz == null || jsonString == null || jsonString.length() == 0) {
  205. return null;
  206. }
  207. JSONArray jo = null;
  208. try {
  209. jo = new JSONArray(jsonString);
  210. } catch (JSONException e) {
  211. e.printStackTrace();
  212. }
  213.  
  214. if (isNull(jo)) {
  215. return null;
  216. }
  217.  
  218. return parseArray(jo, clazz);
  219. }
  220.  
  221. /**
  222. * 反序列化泛型集合
  223. *
  224. * @throws
  225. **/
  226. @SuppressWarnings("unchecked")
  227. public static <T> Collection<T> parseCollection(JSONArray ja, Class<?> collectionClazz,
  228. Class<T> genericType) {
  229.  
  230. if (collectionClazz == null || genericType == null || isNull(ja)) {
  231. return null;
  232. }
  233.  
  234. Collection<T> collection = (Collection<T>) createInstance(collectionClazz);
  235.  
  236. for (int i = 0; i < ja.length(); ++i) {
  237. try {
  238. JSONObject jo = ja.getJSONObject(i);
  239. T o = parseObject(jo, genericType);
  240. collection.add(o);
  241. } catch (JSONException e) {
  242. e.printStackTrace();
  243. }
  244. }
  245.  
  246. return collection;
  247. }
  248.  
  249. /**
  250. * 反序列化泛型集合
  251. *
  252. * @throws
  253. **/
  254. public static <T> Collection<T> parseCollection(String jsonString, Class<?> collectionClazz,
  255. Class<T> genericType) {
  256. if (collectionClazz == null || genericType == null || jsonString == null
  257. || jsonString.length() == 0) {
  258. return null;
  259. }
  260. JSONArray jo = null;
  261. try {
  262. jo = new JSONArray(jsonString);
  263. } catch (JSONException e) {
  264. e.printStackTrace();
  265. }
  266.  
  267. if (isNull(jo)) {
  268. return null;
  269. }
  270.  
  271. return parseCollection(jo, collectionClazz, genericType);
  272. }
  273.  
  274. /**
  275. * 根据类型创建对象
  276. **/
  277. private static <T> T createInstance(Class<T> clazz) {
  278. if (clazz == null)
  279. return null;
  280. T obj = null;
  281. try {
  282. obj = clazz.newInstance();
  283. } catch (Exception e) {
  284. Log.i(TAG, "createInstance: >>>>>>创建实例异常");
  285. e.printStackTrace();
  286. }
  287. return obj;
  288. }
  289.  
  290. /**
  291. * 设定字段的值
  292. **/
  293. private static void setField(Object obj, Field f, JSONObject jo) {
  294. String name = f.getName();
  295. Class<?> clazz = f.getType();
  296. Log.i(TAG, "setField: >>>>>name:"+name);
  297. try {
  298. if (isArray(clazz)) { // 数组
  299. Log.i(TAG, "setField: >>>>>数组");
  300. Class<?> c = clazz.getComponentType();
  301. JSONArray ja = jo.optJSONArray(name);
  302. if (!isNull(ja)) {
  303. Log.i(TAG, "setField: >>>>>ja:"+ja.getString(0));
  304. Object array = parseArray(ja, c);
  305. f.set(obj, array);
  306. }else{
  307. Log.i(TAG, "setField: >>>>>数组为空");
  308. }
  309. } else if (isCollection(clazz)) { // 泛型集合
  310. Log.i(TAG, "setField: >>>>>泛型集合");
  311. // 获取定义的泛型类型
  312. Class<?> c = null;
  313. Type gType = f.getGenericType();
  314. if (gType instanceof ParameterizedType) {
  315. ParameterizedType ptype = (ParameterizedType) gType;
  316. Type[] targs = ptype.getActualTypeArguments();
  317. if (targs != null && targs.length > 0) {
  318. Type t = targs[0];
  319. c = (Class<?>) t;
  320. }
  321. }
  322.  
  323. JSONArray ja = jo.optJSONArray(name);
  324. if (!isNull(ja)) {
  325. Object o = parseCollection(ja, clazz, c);
  326. f.set(obj, o);
  327. }
  328. } else if (isSingle(clazz)) { // 值类型
  329. Log.i(TAG, "setField: >>>>>Single值类型");
  330. Object o = jo.opt(name);
  331. if (o != null) {
  332. f.set(obj, o);
  333. }
  334. } else if (isObject(clazz)) { // 对象
  335. Log.i(TAG, "setField: >>>>>Object对象:"+clazz);
  336. JSONObject j = jo.optJSONObject(name);
  337. if (!isNull(j)) {
  338.  
  339. Object o = parseObject(j, clazz);
  340. f.set(obj, o);
  341. }else{
  342. Log.i(TAG, "setField: >>>>>Object对象为null");
  343. }
  344. } else {
  345. Log.i(TAG, "setField: >>>>>未知类型:"+clazz);
  346. throw new Exception("unknow type!");
  347. }
  348. } catch (Exception e) {
  349. e.printStackTrace();
  350. }
  351. }
  352.  
  353. /**
  354. * 判断对象是否为空
  355. **/
  356. private static boolean isNull(Object obj) {
  357. if (obj instanceof JSONObject) {
  358. return JSONObject.NULL.equals(obj);
  359. }
  360. return obj == null;
  361. }
  362.  
  363. /**
  364. * 判断是否是值类型
  365. **/
  366. private static boolean isSingle(Class<?> clazz) {
  367. return isBoolean(clazz) || isNumber(clazz) || isString(clazz);
  368. }
  369.  
  370. /**
  371. * 是否布尔值
  372. **/
  373. public static boolean isBoolean(Class<?> clazz) {
  374. return (clazz != null)
  375. && ((Boolean.TYPE.isAssignableFrom(clazz)) || (Boolean.class
  376. .isAssignableFrom(clazz)));
  377. }
  378.  
  379. /**
  380. * 是否数值
  381. **/
  382. public static boolean isNumber(Class<?> clazz) {
  383. return (clazz != null)
  384. && ((Byte.TYPE.isAssignableFrom(clazz)) || (Short.TYPE.isAssignableFrom(clazz))
  385. || (Integer.TYPE.isAssignableFrom(clazz))
  386. || (Long.TYPE.isAssignableFrom(clazz))
  387. || (Float.TYPE.isAssignableFrom(clazz))
  388. || (Double.TYPE.isAssignableFrom(clazz)) || (Number.class
  389. .isAssignableFrom(clazz)));
  390. }
  391.  
  392. /**
  393. * 判断是否是字符串
  394. **/
  395. public static boolean isString(Class<?> clazz) {
  396. return (clazz != null)
  397. && ((String.class.isAssignableFrom(clazz))
  398. || (Character.TYPE.isAssignableFrom(clazz)) || (Character.class
  399. .isAssignableFrom(clazz)));
  400. }
  401.  
  402. /**
  403. * 判断是否是对象
  404. **/
  405. private static boolean isObject(Class<?> clazz) {
  406. return clazz != null && !isSingle(clazz) && !isArray(clazz) && !isCollection(clazz);
  407. }
  408.  
  409. /**
  410. * 判断是否是数组
  411. **/
  412. public static boolean isArray(Class<?> clazz) {
  413. return clazz != null && clazz.isArray();
  414. }
  415.  
  416. /**
  417. * 判断是否是集合
  418. **/
  419. public static boolean isCollection(Class<?> clazz) {
  420. return clazz != null && Collection.class.isAssignableFrom(clazz);
  421. }
  422. }

备注

沉舟侧畔千帆过,病树前头万木春。

一起学Android之Xml与Json解析的更多相关文章

  1. Android基础总结(12)——XML和JSON解析

    XML和JSON解析 在网络上传输数据时最常用的格式有两种:XML和JSON.本文主要就是学习如何对这两种常用的数据格式进行解析. 1.XML和JSON的定义 XML:扩展标记语言 (Extensib ...

  2. android基础---->XMl数据的解析

    在网络上传输数据时最常用的格式有两种,XML和JSON,下面首先学一下如何解析XML格式的数据,JSON的解析可以参见我的博客(android基础---->JSON数据的解析).解析XML 格式 ...

  3. Qt on Android: http下载与Json解析

    百度提供有查询 ip 归属地的开放接口,当你在搜索框中输入一个 ip 地址进行搜索,就会打开由 ip138 提供的百度框应用,你能够在框内直接输入 ip 地址查询.我查看了页面请求,提取出查询 ip ...

  4. XML与JSON解析

    [XML简介] XML在线校验工具: http://tool.oschina.net/codeformat/xml 可扩展标记语言(EXtensible Markup Language) 一种标记语言 ...

  5. Android之XML序列化和解析

    XML文件是一种常用的文件格式,可以用来存储与传递数据 ,本文是XML文件序列化与解析的一个简单示例 写文件到本地,并用XML格式存储 /** * 写xml文件到本地 */ private void ...

  6. python入门(十):XML和JSON解析

    一.python解析XML 1.xml.dom.*模块,它是W3C DOM API的实现,若需要处理DOM API则该模块很适合,注意xml.dom包里面有许多模块,须区分它们间的不同: 2.xml. ...

  7. golang的xml、json解析

    xml golang的xml处理主要应用Unmarshal.Marshal方法实现,解析一个xml到struct如下,首先是xml文件: <?xml version="1.0" ...

  8. 【Android】XML文件的解析

    1.首先我们可以在res包路径下创建一个raw包,然后在raw下创建一个email.xml 文件,并修改其内容如下: <?xml version="1.0" encoding ...

  9. android AndroidManifest.xml 属性详细解析

    一.关于AndroidManifest.xml AndroidManifest.xml 是每个android程序中必须的文件.它位于整个项目的根目录,描述了package中暴露的组件(activiti ...

随机推荐

  1. 解决zabbix监控因php问题导致图形界面中文乱码方法

    解决因编译php中添加了-enable-gd-jis-conv选项导致Zabbix监控系统图形界面中文乱码问题 现象: php编译参数: 说明: 如果PHP编译时启用–enable-gd-jis-co ...

  2. VMware kali虚拟机环境配置

    编译内核 (1)执行命令uname -r以查看内核版本. (2)执行命令apt-cache search linux-headers查看是否安装内核头文件. (3)  如果uname -r出现的内容在 ...

  3. Shell—详解$( )、$(( ))、``与${ }的区别

    https://www.jianshu.com/p/2237f029c385 https://www.cnblogs.com/chenpython123/p/11052276.html https:/ ...

  4. 集合系列 Map(十二):HashMap

    HashMap 是 Map 基于哈希散列算法的实现,其在 JDK1.7 中采用了数组+链表的数据结构.在 JDK1.8 中为了提高查询效率,采用了数组+链表+红黑树的数据结构.本文所有讲解均基于 JD ...

  5. laravel .env文件的使用

    umen 是 laravel 的衍生品,核心功能的使用和 laravel 都是一致的,但配置文件这一方面,lumen 在 laravel 的基础上增加了更简便的配置方式:lumen 采用了 DotEn ...

  6. 1、netty入门说明

    netty中的例子,基本模式都是:server -> Initializer -> Handler . 在server中去启动线程,打开端口,设置initializer,和一些启动的参数配 ...

  7. "(error during evaluation)" computed

    在vue-cli搭建的去哪网app项目中使用了  computed  计算属性 computed计算属性在chrome插件中的 vue devtools 插件中报错 应该显示出来 computed 属 ...

  8. MySQL数据库:多表连接查询

    多表连接查询 注意:使用连接技术建议将表经行重命名! # explain 检索连接是否达标 # 内连接 # 语法1 from 表1 inner join 表2 on 主键字段=外键字段 [where ...

  9. Java8特性Lambda表达式

    Lambda 表达式 简介: Lambda 表达式,也可称为闭包,它是推动 Java 8 发布的最重要新特性. Lambda 允许把函数作为一个方法的参数(函数作为参数传递进方法中). (parame ...

  10. 《Web Development with Go》Mangodb插入struct数据

    学习数据持久化. package main import ( "fmt" "log" "time" "gopkg.in/mgo.v ...