Android 解析JSON數據格式
1、JSON數據格式
* JSON（JavaScript Object Notation）一種簡單的數據格式，比xml更輕巧。JSON是JavaScript原生格式，這意味著在JavaScript中處理JSON數據不需要任何特殊的API或工具包。
* JSON的規則很簡單：對象是一個無序的“‘名稱/值’對”集合。一個對象以“{”（左括號）開始，“}”（右括號）結束。每個“名稱”后跟一個“:”（冒號）；“‘名稱/值’對”之間使用“,”（逗號）分隔。
規則如下：
1. 映射用冒號（“：”）表示。名稱:值。
2. 并列的數據之間用逗號（“，”）分隔。
3. 映射的集合（對象）用大括號（“{}”）表示。
4. 并列數據的集合（數組）用方括號(“[]”)表示。
5. 元素值可具有的類型：string, number, object, array, true, false, null。
* 解析JSON
JSON 只是一種文本字符串。它被存儲在responseText屬性中
為了讀取存儲在responseText屬性中的 JSON 數據，需要根據JavaScript的eval語句。
函數eval會把一個字符串當作它的參數。然后這個字符串會被當作JavaScript代碼來執行。因為JSON的字符串就是由JavaScript代碼構成的，所以它本身是可執行的。
一、什么是json
json(Javascript Object Notation)是一種輕量級的數據交換格式，相比于xml這種數據交換格式來說，因為解析xml比較的復雜，而且需要編寫大段的代碼，所以客戶端和服 務器的數據交換格式往往通過json來進行交換。尤其是對于web開發來說，json數據格式在客戶端直接可以通過javascript來進行解析。
json一共有兩種數據結構，一種是以 (key/value)對形式存在的無序的jsonObject對象，一個對象以“{”（左花括號）開始，“}”（右花括號）結束。每個“名稱”后跟一個“:”（冒號）；“‘名稱/值’ 對”之間使用“,”（逗號）分隔。
例如：{"name": "xiaoluo"}， 這就是一個最簡單的json對象，對于這種數據格式，key值必須要是string類型，而對于value，則可以是string、number、object、array等數據類型：
另一種數據格式就是有序的value的集合，這種形式被稱為是jsonArray，數組是值（value）的有序集合。一個數組以“[”（左中括號）開始，“]”（右中括號）結束。值之間使用“,”（逗號）分隔。
更多的有關json數據格式可以參加json的官網，http://www.json.org/json-zh.html
json數據格式解析我自己分為兩種；
一種是普通的，一種是帶有數組形式的；
普通形式的：
服務器端返回的json數據格式如下：
{"userbean":{"Uid":"100196","Showname":"\u75af\u72c2\u7684\u7334\u5b50","Avtar":null,"State":1}}
分析代碼如下：
// TODO 狀態處理 500 200
int res = 0;
res = httpClient.execute(httpPost).getStatusLine().getStatusCode();
if (res == 200) {
/*
* 當返回碼為200時，做處理
* 得到服務器端返回json數據，并做處理
* */
HttpResponse httpResponse = httpClient.execute(httpPost);
StringBuilder builder = new StringBuilder();
BufferedReader bufferedReader2 = new BufferedReader(
new InputStreamReader(httpResponse.getEntity().getContent()));
String str2 = "";
for (String s = bufferedReader2.readLine(); s != null; s = bufferedReader2
.readLine()) {
builder.append(s);
}
Log.i("cat", ">>>>>>" + builder.toString());
JSONObject jsonObject = new JSONObject(builder.toString())
.getJSONObject("userbean");
String Uid;
String Showname;
String Avtar;
String State;
Uid = jsonObject.getString("Uid");
Showname = jsonObject.getString("Showname");
Avtar = jsonObject.getString("Avtar");
State = jsonObject.getString("State");
帶數組形式的：
服務器端返回的數據格式為：
{"calendar":
{"calendarlist":
[
{"calendar_id":"1705","title":"(\u4eb2\u5b50)ddssd","category_name":"\u9ed8\u8ba4\u5206\u7c7b","showtime":"1288927800","endshowtime":"1288931400","allDay":false},
{"calendar_id":"1706","title":"(\u65c5\u884c)","category_name":"\u9ed8\u8ba4\u5206\u7c7b","showtime":"1288933200","endshowtime":"1288936800","allDay":false}
]
}
}
分析代碼如下：
// TODO 狀態處理 500 200
int res = 0;
res = httpClient.execute(httpPost).getStatusLine().getStatusCode();
if (res == 200) {
/*
* 當返回碼為200時，做處理
* 得到服務器端返回json數據，并做處理
* */
HttpResponse httpResponse = httpClient.execute(httpPost);
StringBuilder builder = new StringBuilder();
BufferedReader bufferedReader2 = new BufferedReader(
new InputStreamReader(httpResponse.getEntity().getContent()));
String str2 = "";
for (String s = bufferedReader2.readLine(); s != null; s = bufferedReader2
.readLine()) {
builder.append(s);
}
Log.i("cat", ">>>>>>" + builder.toString());
/**
* 這里需要分析服務器回傳的json格式數據，
*/
JSONObject jsonObject = new JSONObject(builder.toString())
.getJSONObject("calendar");
JSONArray jsonArray = jsonObject.getJSONArray("calendarlist");
for(int i=0;i<jsonArray.length();i++){
JSONObject jsonObject2 = (JSONObject)jsonArray.opt(i);
CalendarInfo calendarInfo = new CalendarInfo();
calendarInfo.setCalendar_id(jsonObject2.getString("calendar_id"));
calendarInfo.setTitle(jsonObject2.getString("title"));
calendarInfo.setCategory_name(jsonObject2.getString("category_name"));
calendarInfo.setShowtime(jsonObject2.getString("showtime"));
calendarInfo.setEndtime(jsonObject2.getString("endshowtime"));
calendarInfo.setAllDay(jsonObject2.getBoolean("allDay"));
calendarInfos.add(calendarInfo);
}
總結，普通形式的只需用JSONObject ，帶數組形式的需要使用JSONArray 將其變成一個list。
2 JSON-lib
<1>JSON-lib 是一個java類庫
* 轉換javabeans,maps,collections,java arrays和XML成為json格式數據
轉換json格式數據成為javabeans 對象
* 需要jar包
jakarta commons-lang 2.5
jakarta commons-beanutils 1.8.0
jakarta commons-collections 3.2.1
jakarta commons-logging 1.1.1
ezmorph 1.0.6
注：Google的GSON和JSON-lib的功能基本上是一致的。
json06.html
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>form.html</title>
<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
<meta http-equiv="description" content="this is my page">
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body>
<select id="province" name="province">
<option value="">請選擇....</option>
</select>
<select id="city" name="city">
<option value="">請選擇.....</option>
</select>
</body>
<script language="JavaScript">
window.onload = function(){
var xhr = createXmlHttpRequest();
xhr.onreadystatechange = function(){
if(xhr.readyState==4){
if(xhr.status==200){
var data = xhr.responseText;
alert(data);
/*
* ajax模型中，使用eval()函數將接收到的文本內容轉換成json數據格式
* * 利用"()"將要轉換的內容包裝，eval()函數會強行將其轉換成json數據格式
* * 不用"()"將要轉換的內容包裝，eval()函數會將"{}"解釋為空的語句塊
*/
var json = eval("("+data+")");
for(var i=0;i<json.length;i++){
var provinceValue = json[i].province;
}
}
}
}
xhr.open("get","../jsonServlet",true);
xhr.send(null);
}
function createXmlHttpRequest(){
var xmlHttp;
try{ //Firefox, Opera 8.0+, Safari
xmlHttp=new XMLHttpRequest();
}catch (e){
try{ //Internet Explorer
xmlHttp=new ActiveXObject("Msxml2.XMLHTTP");
}catch (e){
try{
xmlHttp=new ActiveXObject("Microsoft.XMLHTTP");
}catch (e){}
}
}
return xmlHttp;
}
</script>
</html>
JsonServlet.java
public class JsonServlet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType( "text/html;charset=utf-8");
PrintWriter out = response.getWriter();
// String json = "[{'province':'吉林省'},{'province':'遼寧省'},{'province':'山東省'}]";
//模擬查詢數據庫
List<Province> list = new ArrayList<Province>();
Province p1 = new Province(1, "吉林省" );
Province p2 = new Province(1, "遼寧省" );
Province p3 = new Province(1, "山東省" );
list.add(p1);
list.add(p2);
list.add(p3);
JSONArray json = JSONArray. fromObject(list);
out.println(json.toString());
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType( "text/html");
PrintWriter out = response.getWriter();
doGet(request, response);
}
}
JsonUtil.java
public class JsonUtil {
* 將數組轉換成String類型的JSON數據格式
public static String array2json(Object[] objects){
JSONArray jsonArray = JSONArray. fromObject(objects);
return jsonArray.toString();
}
* 將list集合轉換成String類型的JSON數據格式
public static String list2json(List list){
JSONArray jsonArray = JSONArray. fromObject(list);
return jsonArray.toString();
}
* 將map集合轉換成String類型的JSON數據格式
public static String map2json(Map map){
JSONObject jsonObject = JSONObject. fromObject(map);
return jsonObject.toString();
}
* 將Object對象轉換成String類型的JSON數據格式
public static String object2json(Object object){
JSONObject jsonObject = JSONObject. fromObject(object);
return jsonObject.toString();
}
* 將XML數據格式轉換成String類型的JSON數據格式
public static String xml2json(String xml){
JSONArray jsonArray = (JSONArray) new XMLSerializer().read(xml);
return jsonArray.toString();
}
* 除去不想生成的字段（特別適合去掉級聯的對象）
public static JsonConfig configJson(String[] excludes) {
JsonConfig jsonConfig = new JsonConfig();
jsonConfig.setExcludes(excludes);
jsonConfig.setIgnoreDefaultExcludes( true);
jsonConfig.setCycleDetectionStrategy(CycleDetectionStrategy. LENIENT);
return jsonConfig;
}
}
二、解析json數據格式
這里將使用兩種json的解析庫來對我們的json數據格式進行解析以及生成我們的json數據格式。
1.json-lib(http://json-lib.sourceforge.net/)
使用json-lib來進行解析，我們需要引入第三方的包，因為json-lib分為了兩個版本，一個版本是針對于jdk1.3的，一個版本是針對于jdk1.5的，這里我們下載jdk1.5的這個json-lib包，其中還需要引入其他的幾個jar包：
下載好這幾個jar包后，加入到classpath中即可。我們來看看json-lib給我們提供的API。
我 們最常用的兩個類就是 JSONObject和JSONArray這兩個類，分別代表了json對象和json數組，這兩個類都實現了 JSON 這個接口，下面我們通過幾個小例子來看看如何將我們常見的幾種數據格式轉換成我們的json對象(我們一般稱之為JSON數據的序列化)以及再將json 對象在轉換成我們的數據格式(稱之為反序列化)。
①簡單的javabean的序列化和反序列化
public class Person
{
private int id;
private String name;
private String address;
public Person()
{
}
public int getId()
{
return id;
}
public void setId(int id)
{
this.id = id;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public String getAddress()
{
return address;
}
public void setAddress(String address)
{
this.address = address;
}
public Person(int id, String name, String address)
{
super();
this.id = id;
this.name = name;
this.address = address;
}
@Override
public String toString()
{
return "Person [id=" + id + ", name=" + name + ", address=" + address
+ "]";
}
}
首先我們定義一個簡單的javabean對象，然后將一個Person對象轉換成json對象，然后再將這個json對象反序列化成我們的Person對象。
我們先定義一個JsonTools類，這個類有兩個靜態方法，我們可以通過這兩個方法來得到一個JSON類型的字符串對象，以及一個JSON對象
public class JsonTools
{
/**
* 得到一個json類型的字符串對象
* @param key
* @param value
* @return
*/
public static String getJsonString(String key, Object value)
{
JSONObject jsonObject = new JSONObject();
//put和element都是往JSONObject對象中放入 key/value 對
// jsonObject.put(key, value);
jsonObject.element(key, value);
return jsonObject.toString();
}
/**
* 得到一個json對象
* @param key
* @param value
* @return
*/
public static JSONObject getJsonObject(String key, Object value)
{
JSONObject jsonObject = new JSONObject();
jsonObject.put(key, value);
return jsonObject;
}
}
我 們可以直接通過 JSONObject jsonObject = new JSONObject(); 這個方法就可以得到一個json對象，然后通過element()或者是put()方法來給我們的json對象添加key/value對。我們先來看看第 一個例子，實現一個簡單的Person對象和json對象的轉換
Person person = new Person(1, "xiaoluo", "廣州"); // 將Person對象轉換成一個json類型的字符串對象
String personString = JsonTools.getJsonString("person", person);
System.out.println(personString.toString());
我們看看控制臺的輸出：
、
{"person":{"address":"廣州","id":1,"name":"xiaoluo"}}
整個外面的大括號是一個json對象，里面有一對key/value，其中里面的{"address":"廣州","id":1,"name":"xiaoluo"}就是我們轉換成的json字符串對象
再來看看如何將json對象轉換成我們的bean對象
JSONObject jsonObject = JsonTools.getJsonObject("person", person); // 通過JSONObject的toBean方法可以將json對象轉換成一個javabean
JSONObject personObject = jsonObject.getJSONObject("person");
Person person2 = (Person) JSONObject.toBean(personObject, Person.class);
System.out.println(person2);
Person [id=1, name=xiaoluo, address=廣州]
②轉換List<Person>類型的對象
、
<p>@Test</p>
public void testPersonsJson()
{
List<Person> persons = new ArrayList<Person>();
Person person = new Person(1, "xiaoluo", "廣州");
Person person2 = new Person(2, "android", "上海");
persons.add(person);
persons.add(person2);
String personsString = JsonTools.getJsonString("persons", persons);
System.out.println(personsString);
JSONObject jsonObject = JsonTools.getJsonObject("persons", persons);
// List<Person>相當于一個JSONArray對象
JSONArray personsArray = (JSONArray)jsonObject.getJSONArray("persons");
List<Person> persons2 = (List<Person>) personsArray.toCollection(personsArray, Person.class);
System.out.println(persons2);
}
{"persons":[{"address":"廣州","id":1,"name":"xiaoluo"},{"address":"上海","id":2,"name":"android"}]}
[Person [id=1, name=xiaoluo, address=廣州], Person [id=2, name=android, address=上海]]
③List<Map<String, String>>類型的json對象轉換
<p>@Test</p>
public void testMapJson()
{
List<Map<String, String>> list = new ArrayList<Map<String, String>>();
Map<String, String> map1 = new HashMap<String, String>();
map1.put("id", "001");
map1.put("name", "xiaoluo");
map1.put("age", "20");
Map<String, String> map2 = new HashMap<String, String>();
map2.put("id", "002");
map2.put("name", "android");
map2.put("age", "33");
list.add(map1);
list.add(map2);
String listString = JsonTools.getJsonString("list", list);
System.out.println(listString);
JSONObject jsonObject = JsonTools.getJsonObject("list", list);
JSONArray listArray = jsonObject.getJSONArray("list");
List<Map<String, String>> list2 = (List<Map<String, String>>) listArray.toCollection(listArray, Map.class);
System.out.println(list2);
}
{"list":[{"id":"001","age":"20","name":"xiaoluo"},{"id":"002","age":"33","name":"android"}]}
[{id=001, name=xiaoluo, age=20}, {id=002, name=android, age=33}]
通過上面的例子，我們可以了解了如何通過json-lib這個解析庫來實現javabean、List、Map等數據和json數據的互相轉換
2.gson(http://code.google.com/p/google-gson/)
下面我們來看看Google提供的gson這個json解析庫，同樣我們需要去下載gson這個jar包，導入到我們的項目中
使 用gson，我們可以非常輕松的實現數據對象和json對象的相互轉化，其中我們最常用的就是兩個方法，一個是fromJSON()，將json對象轉換 成我們需要的數據對象，另一個是toJSON()，這個就是將我們的數據對象轉換成json對象。下面我們也通過一個綜合的例子來看看gson的使用方 法：
public class JsonService
{
public Person getPerson()
{
Person person = new Person(1, "xiaoluo", "廣州");
return person;
}
public List<Person> getPersons()
{
List<Person> persons = new ArrayList<Person>();
Person person = new Person(1, "xiaoluo", "廣州");
Person person2 = new Person(2, "android", "上海");
persons.add(person);
persons.add(person2);
return persons;
}
public List<String> getString()
{
List<String> list = new ArrayList<String>();
list.add("廣州");
list.add("上海");
list.add("北京");
return list;
}
public List<Map<String, String>> getMapList()
{
List<Map<String, String>> list = new ArrayList<Map<String, String>>();
Map<String, String> map1 = new HashMap<String, String>();
map1.put("id", "001");
map1.put("name", "xiaoluo");
map1.put("age", "20");
Map<String, String> map2 = new HashMap<String, String>();
map2.put("id", "002");
map2.put("name", "android");
map2.put("age", "33");
list.add(map1);
list.add(map2);
return list;
}
}
public static void main(String[] args)
{
Gson gson = new Gson();
JsonService jsonService = new JsonService();
Person person = jsonService.getPerson();
System.out.println("person: " + gson.toJson(person));
// 對于Object類型，使用 fromJson(String, Class)方法來將Json對象轉換成Java對象
Person person2 = gson.fromJson(gson.toJson(person), Person.class);
System.out.println(person2);
System.out.println("------------------------------------------------");
List<Person> persons = jsonService.getPersons();
System.out.println("persons: " + gson.toJson(persons));
/*
* 對于泛型對象，使用fromJson(String, Type)方法來將Json對象轉換成對應的泛型對象
* new TypeToken<>(){}.getType()方法
*/
List<Person> persons2 = gson.fromJson(gson.toJson(persons), new TypeToken<List<Person>>(){}.getType());
System.out.println(persons2);
System.out.println("------------------------------------------------");
List<String> list = jsonService.getString();
System.out.println("String---->" + gson.toJson(list));
List<String> list2 = gson.fromJson(gson.toJson(list), new TypeToken<List<String>>(){}.getType());
System.out.println("list2---->" + list2);
System.out.println("------------------------------------------------");
List<Map<String, String>> listMap = jsonService.getMapList();
System.out.println("Map---->" + gson.toJson(listMap));
List<Map<String, String>> listMap2 = gson.fromJson(gson.toJson(listMap), new TypeToken<List<Map<String, String>>>(){}.getType());
System.out.println("listMap2---->" + listMap2);
System.out.println("------------------------------------------------");
}
看看控制臺的輸出：
person: {"id":1,"name":"xiaoluo","address":"廣州"}
Person [id=1, name=xiaoluo, address=廣州]
------------------------------------------------
persons: [{"id":1,"name":"xiaoluo","address":"廣州"},{"id":2,"name":"android","address":"上海"}]
[Person [id=1, name=xiaoluo, address=廣州], Person [id=2, name=android, address=上海]]
------------------------------------------------
String---->["廣州","上海","北京"]
list2---->[廣州, 上海, 北京]
------------------------------------------------
Map---->[{"id":"001","age":"20","name":"xiaoluo"},{"id":"002","age":"33","name":"android"}]
listMap2---->[{id=001, age=20, name=xiaoluo}, {id=002, age=33, name=android}]
------------------------------------------------
三、在Android客戶端解析服務器端的json數據
下面我們來完成一個綜合的例子，Android客戶端通過一個AsyncTask異步任務請求服務器端的某些數據，然后在解析完這些數據后，將得到的數據內容更新到我們的Spinner這個UI控件當中。
我們首先來看下服務器端的代碼：
<p>@WebServlet("/CityServlet")</p>
public class CityServlet extends HttpServlet
{
private static final long serialVersionUID = 1L;
public CityServlet()
{
super();
}
protected void doGet(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException
{
this.doPost(request, response);
}
protected void doPost(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException
{
response.setContentType("text/html;charset=utf-8");
request.setCharacterEncoding("utf-8");
response.setCharacterEncoding("utf-8");
PrintWriter writer = response.getWriter();
String type = request.getParameter("type");
if("json".equals(type))
{
List<String> cities = new ArrayList<String>();
cities.add("廣州");
cities.add("上海");
cities.add("北京");
cities.add("湖南");
Map<String, List<String>> map = new HashMap<String, List<String>>();
map.put("cities", cities);
String citiesString = JSON.toJSONString(map);
writer.println(citiesString);
}
writer.flush();
writer.close();
}
}
如果客戶端請求的參數是type=json，則響應給客戶端一個json數據格式
接著來看看客戶端的代碼，首先看看客戶端的布局文件，其實就是一個按鈕和一個Spinner控件，當點擊按鈕后，通過http協議請求服務器端的數據，然后在接收到后再更新我們的Spinner控件的數據
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent" >
<TextView
android:id="@+id/textView1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentLeft="true"
android:layout_alignParentTop="true"
android:layout_marginLeft="64dp"
android:layout_marginTop="64dp"
android:textSize="20sp"
android:text="城市" />
<Spinner
android:id="@+id/spinner"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignTop="@id/textView1"
android:layout_toRightOf="@id/textView1"/>
<Button
android:id="@+id/button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignLeft="@+id/textView1"
android:layout_below="@+id/spinner"
android:layout_marginLeft="22dp"
android:layout_marginTop="130dp"
android:text="加載數據" />
</RelativeLayout>
在Android客戶端寫一個解析json數據格式的類：
public class JsonUtils
{
/**
* @param citiesString 從服務器端得到的JSON字符串數據
* @return 解析JSON字符串數據，放入List當中
*/
public static List<String> parseCities(String citiesString)
{
List<String> cities = new ArrayList<String>();
try
{
JSONObject jsonObject = new JSONObject(citiesString);
JSONArray jsonArray = jsonObject.getJSONArray("cities");
for(int i = 0; i < jsonArray.length(); i++)
{
cities.add(jsonArray.getString(i));
}
}
catch (Exception e)
{
e.printStackTrace();
}
return cities;
}
}
當然我們的HttpUtils類也不可少：
public class HttpUtils
{
/**
* @param path 請求的服務器URL地址
* @param encode 編碼格式
* @return 將服務器端返回的數據轉換成String
*/
public static String sendPostMessage(String path, String encode)
{
String result = "";
HttpClient httpClient = new DefaultHttpClient();
try
{
HttpPost httpPost = new HttpPost(path);
HttpResponse httpResponse = httpClient.execute(httpPost);
if(httpResponse.getStatusLine().getStatusCode() == HttpStatus.SC_OK)
{
HttpEntity httpEntity = httpResponse.getEntity();
if(httpEntity != null)
{
result = EntityUtils.toString(httpEntity, encode);
}
}
}
catch (Exception e)
{
e.printStackTrace();
}
finally
{
httpClient.getConnectionManager().shutdown();
}
return result;
}
}
最后來看看我們的MainActivity類：
public class MainActivity extends Activity
{
private Spinner spinner;
private Button button;
private ArrayAdapter<String> adapter;
private ProgressDialog dialog;
private final String CITY_PATH_JSON = "http://172.25.152.34:8080/httptest/CityServlet?type=json";
@Override
protected void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
spinner = (Spinner)findViewById(R.id.spinner);
button = (Button)findViewById(R.id.button);
dialog = new ProgressDialog(MainActivity.this);
button.setOnClickListener(new OnClickListener()
{
@Override
public void onClick(View v)
{
dialog.setTitle("提示信息");
dialog.setMessage("loading......");
dialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);
dialog.setCancelable(false);
new MyAsyncTask().execute(CITY_PATH_JSON);
}
});
}
public class MyAsyncTask extends AsyncTask<String, Void, List<String>>
{
@Override
protected void onPreExecute()
{
dialog.show();
}
@Override
protected List<String> doInBackground(String... params)
{
List<String> cities = new ArrayList<String>();
String citiesString = HttpUtils.sendPostMessage(params[0], "utf-8");
// 解析服務器端的json數據
cities = JsonUtils.parseCities(citiesString);return cities;
}
@Override
protected void onPostExecute(List<String> result)
{
adapter = new ArrayAdapter<String>(MainActivity.this, android.R.layout.simple_spinner_item, result);
adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
spinner.setAdapter(adapter);
dialog.dismiss();
}
}
@Override
public boolean onCreateOptionsMenu(Menu menu)
{
getMenuInflater().inflate(R.menu.main, menu);
return true;
}
}
當然別往了開啟我們的網絡授權
<uses-permission android:name="android.permission.INTERNET"/>
最后我們來看看效果圖：
這樣我們就完成了客戶端與服務器端通過json來進行數據的交換
總結：本篇隨筆主要講解了JSON這種輕量級的數據交換格式的概念，以及講解了兩種解析json數據的解析類(json-lib以及gson)，最后通過一個小例子實現了在Android客戶端和服務器端使用json這種數據格式來進行數據的交換。