Android：JSON 简介 & 解析方式 讲解（Gson、AS自带org.json、Jac... - 简书
Android：JSON 简介 & 解析方式 讲解（Gson、AS自带org.json、Jackson）
现今最主流的数据交换格式 非 JSON莫属
今天，我将全面介绍 JSON & 解析方式（Gson、AS自带org.json、Jackson），希望你们会喜欢
同样 作为主流的数据交换格式 XML，有兴趣的读者请看文章：
1个JSON文件里含多个数据，这些数据 以 JSON值 的形式 存在
// JSON实例
｛"skill":{
"name":"html",
"year":"5"
"name":"ht",
"year":"4"
"database":[
"name":"h",
"year":"2"
1个JSON值的内容形式可以是：”名称 - 值“对、数组 或 对象，下面将详细说明
3. 解析方式
Android 解析 JSON数据的方式 类似 XML解析，主要分为2大类：
下面，我将详细介绍每种方式
3.1 Android Studio自带org.json解析
解析原理：基于文档驱动
类似于XML的DOM解析方式
解析流程：把全部文件读入到内存中 -&& 遍历所有数据 -&& 根据需要检索想要的数据
// 创建需解析的JSON数据：student.json
// 将该文件放入到本地assets文件夹里
"student":[
{"id":1,"name":"小明","sex":"男","age":18,"height":175},
{"id":2,"name":"小红","sex":"女","age":19,"height":165},
{"id":3,"name":"小强","sex":"男","age":20,"height":185}
"cat":"it"
// 具体解析
import android.os.B
import org.json.JSONA
import org.json.JSONE
import org.json.JSONO
import java.io.BufferedR
import java.io.IOE
import java.io.InputS
import java.io.InputStreamR
public class MainActivity extends AppCompatActivity {
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
EntityStudent student = new EntityStudent();
//从assets获取json文件
InputStreamReader isr = new InputStreamReader(this.getClass().getClassLoader().getResourceAsStream("assets/" + "student.json"));
//字节流转字符流
BufferedReader bfr = new BufferedReader(isr);
StringBuilder stringBuilder = new StringBuilder();
while ((line = bfr.readLine())!=null){
stringBuilder.append(line);
}//将JSON数据转化为字符串
JSONObject root = new JSONObject(stringBuilder.toString());
//根据键名获取键值信息
System.out.println("root:"+root.getString("cat"));
JSONArray array = root.getJSONArray("student");
for (int i = 0;i & array.length();i++)
JSONObject stud = array.getJSONObject(i);
System.out.println("------------------");
System.out.print("id="+stud.getInt("id")+ ","));
System.out.print("name="+stud.getString("name")+ ","));
System.out.print("sex="+stud.getString("sex")+ ","));
System.out.print("age="+stud.getInt("age")+ ","));
System.out.println("height="+stud.getInt("height")+ ","));
bfr.close();
isr.close();
is.close();//依次关闭流
} catch (IOException e) {
e.printStackTrace();
} catch (JSONException e) {
e.printStackTrace();
3.2 Gson解析
Google的开源库
解析原理：基于事件驱动
解析流程：根据所需取的数据 建立1个对应于JSON数据的JavaBean类，即可通过简单操作解析出所需数据
步骤1：创建一个与JSON数据对应的JavaBean类（用作存储需要解析的数据）
Gson解析的关键 = 根据JSON数据 写出一个对应的JavaBean，规则是：
下面用2个例子说明 如何通过JSON文档创建JavaBean类
* 简单转换
// JSON数据1
String json = "{\"id\":1,\"name\":\"小明\",\"sex\":\"男\",\"age\":18,\"height\":175}";
// 对应的JavaBean类
public class EntityStudent {
public void setId(int id){
public void setName(String name){
this.name =
public void setSex(String sex){
this.sex =
public void setAge(int age){
this.age =
public void setHeight(int height){
this.height =
public int getId(){
public String getName(){
public String getSex(){
public int getAge(){
public int getHeight(){
public void show(){
System.out.print("id=" + id + ",");
System.out.print("name=" + name+",");
System.out.print("sex=" + sex+",");
System.out.print("age=" + age+",");
System.out.println("height=" + height + ",");
* 复杂转换
// JSON数据2（具备嵌套）
{"translation":["车"],
"phonetic":"kɑ:",
"explains":["n. 汽车；车厢","n. (Car)人名；(土)贾尔；(法、西)卡尔；(塞)察尔"]},
"query":"car",
"errorCode":0,
"web":[{"value":["汽车","车子","小汽车"],"key":"Car"},
{"value":["概念车","概念车","概念汽车"],"key":"concept car"},
{"value":["碰碰车","碰撞用汽车","碰碰汽车"],"key":"bumper car"}]
// 对应的复杂的JSON数据对应的JavaBean类
public class student {
public String[]
//["车"]数组
//basic对象里面嵌套着对象，创建一个basic内部类对象
static class basic{
//建立内部类
public String[]
public int errorC
public List&wb&
//web是一个对象数组，创建一个web内部类对象
public static class wb{
public String[]
public void show(){
//输出数组
for (int i = 0;i&translation.i++)
System.out.println(translation[i]);
//输出内部类对象
System.out.println(basic.phonetic);
//输出内部类数组
for (int i = 0;i&basic.explains.i++){
System.out.println(basic.explains[i]);
System.out.println(query);
System.out.println(errorCode);
for (int i = 0;i&web.size();i++){
for(int j = 0; j&web.get(i).value.j++)
System.out.println(web.get(i).value[j]);
System.out.println(web.get(i).key);
若觉得转换过于复杂，请直接使用工具：
步骤2：导入GSON库
在Android Gradle导入依赖
dependencies {
compile 'com.google.code.gson:gson:2.3.1'
步骤3：使用Gson进行解析
public class MainActivity extends AppCompatActivity {
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// 1. 创建Gson对象
Gson gson = new Gson();
// 2. 创建JavaBean类的对象
Student student = new EntityStudent();
// 3. 使用Gson解析：将JSON数据转为单个类实体
String json = "{\"id\":1,\"name\":\"小明\",\"sex\":\"男\",\"age\":18,\"height\":175}";
student = gson.fromJson(json,Student.class);
// 解析：JavaBean对象 = gson.fromJson(son,javaBean类类名.class);
// 4. 调用student方法展示解析的数据
student.show();
// 5. 将Java集合转换为json
String json2 = gson.toJson(List);
System.out.println(json2);
3.3 Jackson解析
解析原理：基于事件驱动
解析过程：
类似 GSON，先创建1个对应于JSON数据的JavaBean类，再通过简单操作即可解析
与 Gson解析不同的是：GSON可按需解析，即创建的JavaBean类不一定完全涵盖所要解析的JSON数据，按需创建属性；但Jackson解析对应的JavaBean必须把Json数据里面的所有key都有所对应，即必须把JSON内的数据所有解析出来，无法按需解析
但Jackson的解析速度、效率都 高于 GSON
步骤1：建立Json数据对应的javaBean（规则同GSON）
// 创建需解析的JSON数据：student.json
// 将该文件放入到本地assets文件夹里
{"student":
{"id":1,"name":"小明","sex":"男","age":18,"height":175,"date":[]},
{"id":2,"name":"小红","sex":"女","age":19,"height":165,"date":[]},
{"id":3,"name":"小强","sex":"男","age":20,"height":185,"date":[]}
"grade":"2"
// JavaBean类
class test {
List&stu& student = new ArrayList&stu&();
public void setStudent(List&stu& student){
this.student =
public List&stu& getStudent(){
public void setGrade(int grade){
this.grade =
public int getGrade(){
private static class stu {
public void setId(int id){
public int getId(){
public void setName(String name){
this.name =
public String getName(){
public void setSex(String sex){
this.sex =
public String getSex(){
public void
setAge(int age){
this.age =
public int getAge(){
public void setHeight(int height){
this.height =
public int getHeight(){
public void setDate(int[] date){
this.date =
public int[] getDate(){
public String tostring(){
String str = "";
for (int i = 0;i&student.size();i++){
str += student.get(i).getId() + " " + student.get(i).getName() + " " + student.get(i).getSex() + " " + student.get(i).getAge() + " " + student.get(i).getHeight() ;
for (int j = 0;j&student.get(i).getDate().j++) {
str += student.get(i).getDate()[j]+ " " ;
str += "\n";
str += "\n"+getGrade();
步骤2：利用Jackson方法进行解析
public class MainActivity extends AppCompatActivity {
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
ObjectMapper objectMapper = new ObjectMapper();
// 1. //从assets获取json文件
InputStreamReader isr = new InputStreamReader(this.getClass().getClassLoader().getResourceAsStream("assets/" + "student.json"),"utf-8");
BufferedReader bfr = new BufferedReader(isr);
StringBuilder stringBuilder = new StringBuilder();
while ((line = bfr.readLine())!=null){
stringBuilder.append(line);
// 2. 将JSON数据转化为字符串
System.out.println(stringBuilder.toString());
System.out.println(tes.tostring());
} catch (IOException e) {
e.printStackTrace();
4. 解析方式对比
5. 与XML解析对比
对于 同样作为主流的数据交换格式XML来说，二者对比如下：
总的来说，相比于 XML，JSON大小更小、解析方法更简单、解析速度更快。所以，JSON一定是你在数据交换格式选型中的首选
本文全面介绍了现今主流的数据传输格式：JSON
关于另外1种主流的数据传输格式 XML，具体请看文章
下面我将继续对 Android中的知识进行深入讲解 ，有兴趣可以继续关注
请点赞！因为你的鼓励是我写作的最大动力！
相关文章阅读
欢迎关注的简书！
不定期分享关于安卓开发的干货，追求短、平、快，但却不缺深度。
简书认证作者、CSDN签约作者、稀土掘金专栏作者
定位：分享 Android开发 干货
Github：https://github.com/Carson-Ho
转载：http://www.jianshu.com/p/b87fee2f7a23 前言 今天，我们来介绍现今主流的数据交换格式-JSON！同样作为主流为数据交换格式-XML，如果有兴趣可以阅读我写的XML及其DOM、SAX、PULL解析方法和对比 目录 定义 JavaScr...
用两张图告诉你，为什么你的 App 会卡顿? - Android - 掘金Cover 有什么料？ 从这篇文章中你能获得这些料： 知道setContentView()之后发生了什么？ ... Android 获取 View 宽高的常用正确方式，避免为零 - 掘金相信有很多朋友...
用两张图告诉你，为什么你的 App 会卡顿? - Android - 掘金 Cover 有什么料？ 从这篇文章中你能获得这些料： 知道setContentView()之后发生了什么？ ... Android 获取 View 宽高的常用正确方式，避免为零 - 掘金 相信有很多...
什么是Json JavaScript Object Notation，JavaScript的对象表示法，是一种轻量级的文本数据交换格式。 作用 用于数据的标记、存储和传输。 特点 轻量级的文本数据交换格式 独立于语言和平台，具有广泛性 具有自我描述性 读写速度快、解析简单 ...
本文系统介绍，JSON解析的成长史，未经允许，禁止转载。JSON是一种轻量级的数据格式，一般用于数据交互 Android交互数据主要有两种方式：Json和Xml，Xml格式的数据量要比Json格式略大，为了节省流量，减轻服务器压力，目前绝大多数公司都使用Json交互。 目录...
看到阅读量为0我也就放心了，煽情，矫情都是我的真情。
自我的吐槽
2017年，过完年了，今天已经上班第二天了，坐在公司里里面，回想自己这大半年的测试之路，感觉自己什么还都不会。一直在说学习自动化测试，可是呢，到现在为止，一直都没有真正的静下心来去学习。
工作中，总是会给自己找理由说...
OS MBP + OSX + VM Fushion + Ubuntu 12.04 LTS Shell Terminal + Zsh + Tmux 安装 Zsh Tmux 编辑器 Vim vimrc 及 插件(from @dennis_yuan) 重新编译 vim 安装 Vu...
面前的一杯白酒 顷刻入喉 缠绕遍身的寒冷 瞬间泄露 全世界的温暖都在等候 浸入我的心头 酝量一冬天的想象 就是与你碰杯 何曾想 今夜的酒杯 如此沉坠 醉的我 醉眼相望 醉我的是 你侧身的脸庞 醉的我 影只行单 醉我的是 我落空的预想 我坐在台阶 莫名的唠叨 伴着烟熏 酒气围...
该活动为微博大转盘活动，高中奖率。 活动时间：- 奖品设置： 一等奖：包邮寄送《社群营销》书籍一本； 二等奖：免费赠送价值299的《从0开始做新媒体》微课课程； 三等奖：精美PPT模板。 快点击参与吧！ 手快有，手慢无哦~ 我知道你们爱学...老罗Android开发视频教程（6） - 解析JSON数据
- 爱酷学习网，免费高清视频教程在线观看
Begin to Learn
Descritpion
Android解析Json数据，其实Android内置了解析Json的程序库，但是还有更简单的办法，那就是使用Google的Gson库。
Update Completed
请输入正确的邮件（格式：xxx@xxx.xx）
必须填本条信息！Android关于JSON数据解析 - Sun‘刺眼的博客 - 博客园
随笔 - 732, 文章 - 0, 评论 - 44, 引用 - 0
一、什么是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的官网，
二、解析json数据格式
这里将使用两种json的解析库来对我们的json数据格式进行解析以及生成我们的json数据格式。
1.json-lib()
使用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
public Person()
public int getId()
public void setId(int id)
public String getName()
public void setName(String name)
this.name =
public String getAddress()
public void setAddress(String address)
this.address =
public Person(int id, String name, String address)
this.name =
this.address =
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
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
public static JSONObject getJsonObject(String key, Object value)
JSONObject jsonObject = new JSONObject();
jsonObject.put(key, value);
return jsonO
我们可以直接通过&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&类型的对象
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对象转换
　　 @Test
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数据的互相转换
下面我们来看看Google提供的gson这个json解析库，同样我们需要去下载gson这个jar包，导入到我们的项目中
使用gson，我们可以非常轻松的实现数据对象和json对象的相互转化，其中我们最常用的就是两个方法，一个是fromJSON()，将json对象转换成我们需要的数据对象，另一个是toJSON()，这个就是将我们的数据对象转换成json对象。下面我们也通过一个综合的例子来看看gson的使用方法：
public class JsonService
public Person getPerson()
Person person = new Person(1, "xiaoluo", "广州");
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);
public List&String& getString()
List&String& list = new ArrayList&String&();
list.add("广州");
list.add("上海");
list.add("北京");
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);
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控件当中。
我们首先来看下服务器端的代码：
@WebServlet("/CityServlet")
public class CityServlet extends HttpServlet
private static final long serialVersionUID = 1L;
public CityServlet()
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/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" &
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="城市" /&
android:id="@+id/spinner"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignTop="@id/textView1"
android:layout_toRightOf="@id/textView1"/&
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字符串数据
解析JSON字符串数据，放入List当中
public static List&String& parseCities(String citiesString)
List&String& cities = new ArrayList&String&();
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();
当然我们的HttpUtils类也不可少：
public class HttpUtils
* @param path
请求的服务器URL地址
* @param encode
将服务器端返回的数据转换成String
public static String sendPostMessage(String path, String encode)
String result = "";
HttpClient httpClient = new DefaultHttpClient();
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();
httpClient.getConnectionManager().shutdown();
最后来看看我们的MainActivity类：
public class MainActivity extends Activity
private ArrayAdapter&String&
private ProgressD
private final String CITY_PATH_JSON = "http://172.25.152.34:8080/httptest/CityServlet?type=json";
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()
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&&
protected void onPreExecute()
dialog.show();
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
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();
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这种数据格式来进行数据的交换。