在前面的两讲中，我们讲解了JSON数据格式的一些基本知识,以及做一些小Demo,这一讲我们在前面的基础上来做一个综合的可扩展的Demo，主要是针对Android客户端解析服务端传递过来的JSON数据。整个Demo所作的操作如下图所示

1. 服务端

服务端我们需要用到的解析JSON的库是用org.json --> Java --> JSON-lib项目中的库json-lib-2.4-jdk15.jar,这个库还需要附带几个依赖包：commons-beanutils.jar, commons-httpclient.jar, commons- lang.jar, ezmorph.jar，morph-1.0.1.jar。具体的包我会放在源码的lib目录下,读者可以自己去下载。

查看这个项目的api文档:http://json-lib.sourceforge.net/apidocs/jdk15/index.html,我们主要使用的是JSON JSONArray JSONObject JSONSerializer 这几个类,JSONObject这个类可以发现它与org.json这个项目的用法很类似。

1) 先做一个服务端的小实验，就是在服务端实现对Java对象转换成JSON数据格式并且在控制台输出。

Person.java 普通的Person类

[java] view plaincopy

1. package com.json.domain;
2. public class Person {
3. private int id;
4. private String name;
5. private String address;
6. public Person(int id, String name, String address) {
7. super();
8. this.id = id;
9. this.name = name;
10. this.address = address;
11. }
12. public Person() {
13. // TODO Auto-generated constructor stub
14. }
15. public int getId() {
16. return id;
17. }
18. public void setId(int id) {
19. this.id = id;
20. }
21. public String getName() {
22. return name;
23. }
24. public void setName(String name) {
25. this.name = name;
26. }
27. public String getAddress() {
28. return address;
29. }
30. public void setAddress(String address) {
31. this.address = address;
32. }
33. }

JsonService.java 服务于Person,给Person对象赋予各种属性

[java] view plaincopy

1. package com.json.service;
2. import java.util.ArrayList;
3. import java.util.HashMap;
4. import java.util.List;
5. import java.util.Map;
6. import com.json.domain.Person;
7. public class JsonService {
8. public JsonService() {
9. // TODO Auto-generated constructor stub
10. }
11. public Person getPerson(){
12. Person person = new Person(23, "AHuier", "XIAMEN");
13. return person;
14. }
15. public List<Person> getListPerson(){
16. List<Person> list = new ArrayList<Person>();
17. Person person1 = new Person(1001, "AHuier1", "Beijing");
18. Person person2 = new Person(1002, "AHuier2", "shenzheng");
19. list.add(person1);
20. list.add(person2);
21. return list;
22. }
23. public List<String> getListString(){
24. List<String> list = new ArrayList<String>();
25. list.add("Hello");
26. list.add("World");
27. list.add("AHuier");
28. return list;
29. }
30. public List<Map<String, Object>> getListMaps(){
31. List<Map<String, Object>> listMap = new ArrayList<Map<String,Object>>();
32. Map<String, Object> map1 = new HashMap<String, Object>();
33. map1.put("color", "red");
34. map1.put("id", 01);
35. map1.put("name", "Polu");
36. listMap.add(map1);
37. Map<String, Object> map2 = new HashMap<String, Object>();
38. map2.put("id", 07);
39. map2.put("color", "green");
40. map2.put("name", "Zark");
41. listMap.add(map2);
42. return listMap;
43. }
44. }

JsonTools.java 工具类

[java] view plaincopy

1. package com.json.tools;
2. import net.sf.json.JSONObject;
3. /**
4. * @author xukunhui
5. * 工具类,这里专门处理Java对象转Json字符串的功能
6. */
7. public class JsonTools {
8. public JsonTools() {
9. // TODO Auto-generated constructor stub
10. }
11. /**
12. * @param key ： JSON 名值对中的的名字
13. * @param value ：JSON 名值对中的值,值可以有多种类型
14. * @return
15. */
16. // 接受对象转换为JSON数据格式并且作为字符串输出.
17. public static String createJsonString(String key, Object value){
18. JSONObject jsonObject = new JSONObject();
19. jsonObject.put(key, value);
20. return jsonObject.toString(); //就可以转换成Json数据格式
21. }
22. }

JsonTest.java 测试类

[java] view plaincopy

1. package com.json.test;
2. import com.json.domain.Person;
3. import com.json.service.JsonService;
4. import com.json.tools.JsonTools;
5. /**
6. * @author xukunhui
7. * 测试类，利用JSON讲Java对象转换成JSON数据格式，并且在控制台中输出
8. */
9. public class JsonTest {
10. public JsonTest() {
11. // TODO Auto-generated constructor stub
12. }
13. /**
14. * @param args
15. */
16. public static void main(String[] args) {
17. // TODO Auto-generated method stub
18. String msg = "";
19. JsonService service = new JsonService();
20. // 带有三个属性的person对象
21. Person person = service.getPerson();
22. msg = JsonTools.createJsonString("person", person);
23. System.out.println(msg);
24. System.out.println("------------------------------");
25. // List中存放两个person对象,这两个对象有各自的三个属性
26. msg = JsonTools.createJsonString("persons", service.getListPerson());
27. System.out.println(msg);
28. System.out.println("------------------------------");
29. // List中存放三个字符串
30. msg = JsonTools.createJsonString("listString", service.getListString());
31. System.out.println(msg);
32. System.out.println("------------------------------");
33. // List中存放两个Map，两个Map中分别存放三个不同的属性
34. msg = JsonTools.createJsonString("listMap", service.getListMaps());
35. System.out.println(msg);
36. }
37. }

编译执行结果：

{"person":{"address":"XIAMEN","id":23,"name":"AHuier"}}
------------------------------
{"persons":[{"address":"Beijing","id":1001,"name":"AHuier1"},{"address":"shenzheng","id":1002,"name":"AHuier2"}]}
------------------------------
{"listString":["Hello","World","AHuier"]}
------------------------------
{"listMap":[{"id":1,"color":"red","name":"Polu"},{"id":7,"color":"green","name":"Zark"}]}

【说明】：从这里可以发现在服务端利用JSON很方便的将Java对象转换成JSON数据格式。

【注意】：我们这边需要给加一个person的标示符，作为最外面的一个对象的名,我们在客户端解析数据的时候，其实不加person的标示符也是可以的，但是这样写的目的是把原有的对象转换成JSON数据格式之后，我们在外层再给予封装一层对象，便于后续利用外层的这个对象进行解析。如下图所示：

2) 现在我们将服务端的项目部署到Tomcat服务器(如何部署可以参考前面几篇博文),然后通过在浏览器的地址栏中传递不同的action值来获取相应的JSON数据格式,这样的话浏览器也会显示出请求服务解析好的JSON数据格式。实现好这一步骤之后,我们在服务端的工作也完成了。服务端的项目结构图如下所示：

JsonAction.java  Servlet类,处理根浏览器客户端通过不同的参数请求返回JSON数据。

[java] view plaincopy

1. package com.json.action;
2. import java.io.IOException;
3. import java.io.PrintWriter;
4. import java.nio.charset.Charset;
5. import javax.servlet.ServletException;
6. import javax.servlet.http.HttpServlet;
7. import javax.servlet.http.HttpServletRequest;
8. import javax.servlet.http.HttpServletResponse;
9. import com.json.service.JsonService;
10. import com.json.tools.JsonTools;
11. /**
12. * @author xukunhui
13. * Servlet类,处理根浏览器客户端通过不同的参数请求返回JSON数据。
14. */
15. public class JsonAction extends HttpServlet {
16. private JsonService service;
17. /**
18. * Constructor of the object.
19. */
20. public JsonAction() {
21. super();
22. }
23. /**
24. * Destruction of the servlet. <br>
25. */
26. public void destroy() {
27. super.destroy(); // Just puts "destroy" string in log
28. // Put your code here
29. }
30. /**
31. * The doGet method of the servlet. <br>
32. *
33. * This method is called when a form has its tag value method equals to get.
34. *
35. * @param request the request send by the client to the server
36. * @param response the response send by the server to the client
37. * @throws ServletException if an error occurred
38. * @throws IOException if an error occurred
39. */
40. public void doGet(HttpServletRequest request, HttpServletResponse response)
41. throws ServletException, IOException {
42. doPost(request, response);
43. }
44. /**
45. * The doPost method of the servlet. <br>
46. *
47. * This method is called when a form has its tag value method equals to post.
48. *
49. * @param request the request send by the client to the server
50. * @param response the response send by the server to the client
51. * @throws ServletException if an error occurred
52. * @throws IOException if an error occurred
53. */
54. public void doPost(HttpServletRequest request, HttpServletResponse response)
55. throws ServletException, IOException {
56. response.setContentType("text/html; Charset=utf-8");
57. request.setCharacterEncoding("utf-8");
58. response.setCharacterEncoding("utf-8");
59. PrintWriter out = response.getWriter();
60. /*
61. * 如果是以下这种方式直接在浏览器地址栏中用  http://192.168.0.112:8080/JsonProject/servlet/JsonAction 请求即可
62. * String jsonString = JsonTools.createJsonString("person", service.getListPerson());
63. * out.print(jsonString); // 从服务端提取数据,并且输出的浏览器客户端。
64. */
65. // 根据不同的参数输出不同的JSON数据
66. String jsonString = "";
67. String action_flag = request.getParameter("action_flag");
68. if(action_flag.equals("person")) {
69. jsonString = JsonTools.createJsonString("person", service.getPerson());
70. } else if(action_flag.equals("persons")){
71. jsonString = JsonTools.createJsonString("persons", service.getListPerson());
72. } else if(action_flag.equals("listString")) {
73. jsonString = JsonTools.createJsonString("listString", service.getListString());
74. } else if(action_flag.equals("listMap")){
75. jsonString = JsonTools.createJsonString("listMap", service.getListMaps());
76. }
77. out.print(jsonString);
78. out.flush();
79. out.close();
80. }
81. /**
82. * Initialization of the servlet. <br>
83. *
84. * @throws ServletException if an error occurs
85. */
86. public void init() throws ServletException {
87. // Put your code here
88. service = new JsonService();
89. }
90. }

程序执行,在浏览器地址栏中输入与浏览器显示如下：

输入： http://192.168.0.112:8080/JsonProject/servlet/JsonAction?action_flag=person
输出： {"person":{"address":"XIAMEN","id":23,"name":"AHuier"}}

输入：http://192.168.0.112:8080/JsonProject/servlet/JsonAction?action_flag=persons
输出： {"persons":[{"address":"Beijing","id":1001,"name":"AHuier1"},{"address":"shenzheng","id":1002,"name":"AHuier2"}]}

输入：http://192.168.0.112:8080/JsonProject/servlet/JsonAction?action_flag=listString
输出： {"listString":["Hello","World","AHuier"]}

输入：http://192.168.0.112:8080/JsonProject/servlet/JsonAction?action_flag=listMap
输出： {"listMap":[{"id":1,"color":"red","name":"Polu"},{"id":7,"color":"green","name":"Zark"}]}

【备注】：自此，我们服务端模块的内容已经实现的差不多了,在服务端我们通常还结合JDBC进行操作。可以把JDBC的数据提取出来,提取出来的肯定是单条记录，或者是某一个集合。也就是服务端从JDBC数据库中提取到数据只要转换成JSON的数据格式后提供客户端进行显示。如下图所示：

2. 客户端

上面我们已经写好了服务端的代码,现在我们开始进行Android客户端的操作。JSON的解析有一个规则就是服务端把对象转换成一个JSON的数据格式，而客户端需要把JSON格式换成对象,客户端主要是通过Http协议向服务端发出请求获得服务端的JSON数据。

客户端项目结构如下图所示：

1. 客户端需要通过网络去向服务端请求数据,所以需要在 manifest.xml 清单文件中定义好访问网络的属性

[html] view plaincopy

1. <!-- add permission of access Internet -->
2. <uses-permission android:name="android.permission.INTERNET"/>

2. HttpUtils.java 负责从服务器请求获取到JSON数据格式的字符串

[java] view plaincopy

1. package com.android.jsonproject.http;
2. import java.io.ByteArrayOutputStream;
3. import java.io.InputStream;
4. import java.net.HttpURLConnection;
5. import java.net.URL;
6. /**
7. * @author xukunhui 从服务器请求获取到JSON数据格式的字符串
8. */
9. public class HttpUtils {
10. public HttpUtils() {
11. // TODO Auto-generated constructor stub
12. }
13. public static String getJsonContent(String url_path) {
14. try {
15. URL url = new URL(url_path);
16. HttpURLConnection connection = (HttpURLConnection) url.openConnection();
17. connection.setConnectTimeout(3000); // 请求超时时间3s
18. connection.setRequestMethod("GET");
19. connection.setDoInput(true);
20. int code = connection.getResponseCode(); // 返回状态码
21. if (code == 200) {
22. // 或得到输入流，此时流里面已经包含了服务端返回回来的JSON数据了,此时需要将这个流转换成字符串
23. return changeInputStream(connection.getInputStream());
24. }
25. } catch (Exception e) {
26. // TODO: handle exception
27. }
28. return "";
29. }
30. private static String changeInputStream(InputStream inputStream) {
31. // TODO Auto-generated method stub
32. String jsonString = "";
33. ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
34. int length = 0;
35. byte[] data = new byte[1024];
36. try {
37. while (-1 != (length = inputStream.read(data))) {
38. outputStream.write(data, 0, length);
39. }
40. // inputStream流里面拿到数据写到ByteArrayOutputStream里面,
41. // 然后通过outputStream.toByteArray转换字节数组，再通过new String()构建一个新的字符串。
42. jsonString = new String(outputStream.toByteArray());
43. } catch (Exception e) {
44. // TODO: handle exception
45. }
46. return jsonString;
47. }
48. }

3. JSONTools.java 完成对从服务端请求获得的JSON数据的解析成指定的对象.

[java] view plaincopy

1. package com.android.jsonproject.json;
2. import java.util.ArrayList;
3. import java.util.HashMap;
4. import java.util.Iterator;
5. import java.util.List;
6. import java.util.Map;
7. import org.json.JSONArray;
8. import org.json.JSONObject;
9. import com.android.jsonproject.domain.Person;
10. /**
11. * @author xukunhui
12. * 完成对从服务端请求获得的JSON数据的解析成指定的对象.
13. */
14. public class JSONTools {
15. public JSONTools() {
16. // TODO Auto-generated constructor stub
17. }
18. // 此时从服务端取下来的数据是：{"person":{"address":"XIAMEN","id":23,"name":"AHuier"}}
19. public static Person getPerson(String key, String jsonString){
20. Person person = new Person();
21. try {
22. // 在Android官方文档中，org.json 这是Android提供给我们的解析json数据格式的包，
23. // 我们比较常用的是JSONArray 和 JSONObject这个两个类
24. JSONObject jsonObject = new JSONObject(jsonString);
25. JSONObject personObject = jsonObject.getJSONObject(key);
26. person.setId(personObject.getInt("id"));
27. person.setAddress(personObject.getString("address"));
28. person.setName(personObject.getString("name"));
29. } catch (Exception e) {
30. // TODO: handle exception
31. }
32. return person;
33. }
34. //{"persons":[{"address":"Beijing","id":1001,"name":"AHuier1"},{"address":"shenzheng","id":1002,"name":"AHuier2"}]}
35. public static List<Person> getPersons(String key, String jsonString){
36. List<Person> list = new ArrayList<Person>();
37. try {
38. JSONObject jsonObject = new JSONObject(jsonString);
39. //返回json的数组
40. JSONArray jsonArray = jsonObject.getJSONArray(key);
41. for(int i = 0; i < jsonArray.length(); i++){
42. JSONObject jsonObject2 = jsonArray.getJSONObject(i);
43. Person person = new Person();
44. person.setId(jsonObject2.getInt("id"));
45. person.setName(jsonObject2.getString("name"));
46. person.setAddress(jsonObject2.getString("address"));
47. list.add(person);
48. }
49. } catch (Exception e) {
50. // TODO: handle exception
51. }
52. return list;
53. }
54. //{"listString":["Hello","World","AHuier"]}
55. public static List<String> getListString(String key, String jsonString){
56. List<String> listString = new ArrayList<String>();
57. try {
58. JSONObject jsonObject = new JSONObject(jsonString);
59. //返回JSON的数组
60. JSONArray jsonArray = jsonObject.getJSONArray(key);
61. for(int i = 0; i < jsonArray.length(); i++){
62. String msg = jsonArray.getString(i);
63. listString.add(msg);
64. }
65. } catch (Exception e) {
66. // TODO: handle exception
67. }
68. return listString;
69. }
70. // 此时从服务端取下来的数据是：{"listMap":[{"id":1,"color":"red","name":"Polu"},{"id":7,"color":"green","name":"Zark"}]}
71. public static List<Map<String, Object>> getListMaps(String key, String jsonString){
72. List<Map<String, Object>> listMap = new ArrayList<Map<String, Object>>();
73. try {
74. JSONObject jsonObject = new JSONObject(jsonString);
75. JSONArray jsonArray = jsonObject.getJSONArray(key);
76. for(int i = 0; i < jsonArray.length(); i++){
77. JSONObject jsonObject2 = jsonArray.getJSONObject(i);
78. Map<String, Object> map = new HashMap<String, Object>();
79. // 通过org.json中的迭代器来取Map中的值。
80. Iterator<String> iterator = jsonObject2.keys();
81. while(iterator.hasNext()) {
82. String jsonKey = iterator.next();
83. Object jsonValue = jsonObject2.get(jsonKey);
84. //JSON的值是可以为空的，所以我们也需要对JSON的空值可能性进行判断。
85. if(jsonValue == null){
86. jsonValue = "";
87. }
88. map.put(jsonKey, jsonValue);
89. }
90. listMap.add(map);
91. }
92. } catch (Exception e) {
93. // TODO: handle exception
94. }
95. return listMap;
96. }
97. }

4. Person.java 配合客户端将JSON数据转换成Java对象,服务端有Person对象,所以客户端需要相应的Person对象

[java] view plaincopy

1. package com.android.jsonproject.domain;
2. public class Person {
3. private int id;
4. private String name;
5. private String address;
6. public Person(int id, String name, String address) {
7. super();
8. this.id = id;
9. this.name = name;
10. this.address = address;
11. }
12. public Person() {
13. // TODO Auto-generated constructor stub
14. }
15. @Override
16. public String toString() {
17. return "Person [id=" + id + ", name=" + name + ", address=" + address + "]";
18. }
19. public int getId() {
20. return id;
21. }
22. public void setId(int id) {
23. this.id = id;
24. }
25. public String getName() {
26. return name;
27. }
28. public void setName(String name) {
29. this.name = name;
30. }
31. public String getAddress() {
32. return address;
33. }
34. public void setAddress(String address) {
35. this.address = address;
36. }
37. }

5. Android 客户端主界面代码,这里主要是定义四个按钮分别处理解析不同类型的JSON数据格式,布局文件这里不再贴出.

[java] view plaincopy

1. @Override
2. public void onClick(View v) {
3. // TODO Auto-generated method stub
4. switch (v.getId()) {
5. case R.id.person:
6. String path = "http://192.168.0.112:8080/JsonProject/servlet/JsonAction?action_flag=person";
7. String jsonString = HttpUtils.getJsonContent(path);
8. Log.i(TAG, "The jsonString:" + jsonString);
9. Person person = JSONTools.getPerson("person", jsonString);
10. Log.i(TAG, "The person:" + person.toString());
11. break;
12. case R.id.persons:
13. String path2 = "http://192.168.0.112:8080/JsonProject/servlet/JsonAction?action_flag=persons";
14. String jsonString2 = HttpUtils.getJsonContent(path2);
15. Log.i(TAG, "The jsonString:" + jsonString2);
16. List<Person> list2 = JSONTools.getPersons("persons", jsonString2);
17. Log.i(TAG, "The persons:" + list2.toString());
18. break;
19. case R.id.liststring:
20. String path3 = "http://192.168.0.112:8080/JsonProject/servlet/JsonAction?action_flag=listString";
21. String jsonString3 = HttpUtils.getJsonContent(path3);
22. Log.i(TAG, "The jsonString:" + jsonString3);
23. List<String> list3 = JSONTools.getListString("listString", jsonString3);
24. Log.i(TAG, "The listString:" + list3.toString());
25. break;
26. case R.id.listmap:
27. String path4 = "http://192.168.0.112:8080/JsonProject/servlet/JsonAction?action_flag=listMap";
28. String jsonString4 = HttpUtils.getJsonContent(path4);
29. Log.i(TAG, "The jsonString:" + jsonString4);
30. List<Map<String, Object>> list4 = JSONTools.getListMaps("listMap", jsonString4);
31. Log.i(TAG, "The listMap:" + list4.toString());
32. break;
33. }
34. }

客户端编译执行结果：

1. 点击解析person数据按钮

2. 点击解析List嵌套person数据

3. 点击List嵌套String数据

4. 点击List嵌套Map数据

自此，Android客户端与服务之间的JSON数据交互的Demo就完成了,下面附上源代码,读者可以自行编译执行

服务端： MyEclipse + Tomcat + Servlet

客户端： Eclipse + Android(模拟器和真机都可以，但是必须保证通过IP地址可以访问)

源码下载：http://download.csdn.net/detail/xukunhui2/6546095

服务端(符JSON开源项目包路径：JsonProject\WebRoot\WEB-INF\lib)：

客户端：http://download.csdn.net/detail/xukunhui2/6546117

接下去，我们会学习一下google-gson的数据格式的解析,敬请关注。