android：服务器与客户端的双向开发

【Android 开发】: Android客户端与服务端之间使用JSON交互数据。

分类： 【Android 开发】

Android java web JSON http协议 服务端

    在前面的两讲中，我们讲解了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 plain copy

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

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

[java]  view plain copy

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

JsonTools.java 工具类

[java]  view plain copy

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

JsonTest.java 测试类

[java]  view plain copy

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

编译执行结果：

{"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 plain copy

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

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

输入： 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 plain copy

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

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

[java]  view plain copy

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

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

[java]  view plain copy

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

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

[java]  view plain copy

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

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

[java]  view plain copy

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的数据格式的解析,敬请关注。