Android中的JSON解析方式：json; Gson ; Fastjson

最新推荐文章于 2023-04-04 18:23:30 发布

qi_ruihua

最新推荐文章于 2023-04-04 18:23:30 发布

阅读量3.2k

点赞数

分类专栏： Android

本文链接：https://blog.csdn.net/qi_ruihua/article/details/22050389

版权

Android 专栏收录该内容

60 篇文章 0 订阅

订阅专栏

本文主要介绍Json数据的解析
----a，json数据的介绍
----b，json数据的解析
----c，gson数据的解析，谷歌公司的一种格式
----d，fastjson数据的解析，阿里巴巴的一种格式

通过本文的学习能掌握json数据格式的解析，为以后json格式数据的解析做到熟练于心。

Json的全称：JavaScript Object Notation

JSON的定义：
一种轻量级的数据交换格式，具有良好的可读和便于快速编写的特性。业内主流技术为其提供了完整的解决方案（有点类似于正则表达式，获得了当今大部分语言的支持），从而可以在不同平台间进行数据交换。JSON采用兼容性很高的文本格式，同时也具备类似于C语言体系的行为。 – Json.org

Json建构于两种结构：
“名称/值”对的集合（A collection of name/value pairs）。不同的语言中，它被理解为对象（object），纪录（record），结构（struct），字典（dictionary），哈希表（hash table），有键列表（keyed list），或者关联数组（associative array）。
值的有序列表（An ordered list of values）。在大部分语言中，它被理解为数组（array）

JSON对象是一个无序的“‘名称/值’对”集合。
一个对象以“{”（左括号）开始，“}”（右括号）结束。
每个“名称”后跟一个“:”（冒号）；“‘名称/值’ 对”之间使用“,”（逗号）分隔。
如： {
“name”:”jackson”,
“age”:100
}

数组是值（value）的有序集合。一个数组以“[”（左中括号）开始，“]”（右中括号）结束。值之间使用“,”（逗号）分隔
如：{
“students”:
[
{“name”:”jackson”,“age”:100},
{“name”:”michael”,”age”:51}
]
}

一。谷歌GSON技术的介绍

Gson这个Java类库可以把Java对象转换成JSON，也可以把JSON字符串转换成一个相等的Java对象。

Gson支持任意复杂Java对象包括没有源代码的对象。

二。阿里巴巴FastJson技术的介绍

FastJson是一个Json处理工具包，包括“序列化”和“反序列化”两部分，它具备如下特征：

速度最快，测试表明，fastjson具有极快的性能，超越任其他的Java Json parser。包括自称最快的JackJson。

功能强大，完全支持Java Bean、集合、Map、日期、Enum，支持范型，支持自省。

无依赖，能够直接运行在Java SE 5.0以上版本

支持Android。

开源 (Apache 2.0)

三。JSON Vs XML
1.JSON和XML的数据可读性基本相同

2.JSON和XML同样拥有丰富的解析手段

3.JSON相对于XML来讲，数据的体积小

4.JSON与JavaScript的交互更加方便

5.JSON对数据的描述性比XML较差

6.JSON的速度要远远快于XML

四。android2.3提供的json解析类

android的json解析部分都在包org.json下，主要有以下几个类：

JSONObject：可以看作是一个json对象,这是系统中有关JSON定义的基本单元，其包含一对儿(Key/Value)数值。它对外部(External：应用toString()方法输出的数值)调用的响应体现为一个标准的字符串（例如：{"JSON": "Hello, World"}，最外被大括号包裹，其中的Key和Value被冒号":"分隔）。其对于内部(Internal)行为的操作格式略微，例如：初始化一个JSONObject实例，引用内部的put()方法添加数值：new JSONObject().put("JSON", "Hello, World!")，在Key和Value之间是以逗号","分隔。Value的类型包括：Boolean、JSONArray、JSONObject、Number、String或者默认值JSONObject.NULL object 。

JSONStringer：json文本构建类，根据官方的解释，这个类可以帮助快速和便捷的创建JSON text。其最大的优点在于可以减少由于格式的错误导致程序异常，引用这个类可以自动严格按照JSON语法规则（syntax rules）创建JSON text。每个JSONStringer实体只能对应创建一个JSON text。。其最大的优点在于可以减少由于格式的错误导致程序异常，引用这个类可以自动严格按照JSON语法规则（syntax rules）创建JSON text。每个JSONStringer实体只能对应创建一个JSON text。

JSONArray：它代表一组有序的数值。将其转换为String输出(toString)所表现的形式是用方括号包裹，数值以逗号”,”分隔（例如： [value1,value2,value3]，大家可以亲自利用简短的代码更加直观的了解其格式）。这个类的内部同样具有查询行为， get()和opt()两种方法都可以通过index索引返回指定的数值，put()方法用来添加或者替换数值。同样这个类的value类型可以包括：Boolean、JSONArray、JSONObject、Number、String或者默认值JSONObject.NULL object。

JSONTokener：json解析类
JSONException：json中用到的异常

首先建立一个公共的Bean

[java]view plaincopy 
     
   
 package com.qianfeng.domain;   
    
 public class Person {   
    
     private int age;   
     private String name;   
    
     public Person(int age, String name) {   
         super();   
         this.age = age;   
         this.name = name;   
     }   
     @Override   
     public String toString() {   
         return "Person [age=" + age + ", name=" + name + "]";   
     }   
    
     public int getAge() {   
         return age;   
     }   
    
     public void setAge(int age) {   
         this.age = age;   
     }   
    
     public String getName() {   
         return name;   
     }   
    
     public void setName(String name) {   
         this.name = name;   
     }   
    
     public Person() {   
         // TODO Auto-generated constructor stub   
     }   
    
 }   

第一种方式：

Json方式：

[java]view plaincopy 
     
   
 public class JsonList {   
    
     public JsonList() {   
         // TODO Auto-generated constructor stub   
     }   
    
     public static List<Person> getList() {   
         List<Person> list = new ArrayList<Person>();   
         list.add(new Person(1002,"李四2"));   
         list.add(new Person(1003,"李四3"));   
         list.add(new Person(1001,"李四1"));   
         return list;   
     }   
     public static Person getPerson(){   
         return new Person(1002,"李四2");    
     }   
 }   

[java]view plaincopy 
     
   
 import net.sf.json.JSON;   
 import net.sf.json.JSONArray;   
 import net.sf.json.JSONObject;   
 import net.sf.json.JSONSerializer;   
    
 public class JsonTools {   
    
     public JsonTools() {   
         // TODO Auto-generated constructor stub   
     }   
    
     public static String getString(Person person) {   
         JSON json = JSONSerializer.toJSON(JsonList.getPerson());   
         return json.toString();   
     }   
    
     /**  
      *   
      * @param msgString  
      * @return  
      */   
     public static Person getPerson(String msgString) {   
         Person person = new Person();   
         JSONArray array = new JSONArray();   
         array.add(msgString);   
         JSONObject obj = array.getJSONObject(0);   
         // System.out.println(obj.get("age"));   
         // System.out.println(obj.get("name"));   
         person.setAge(obj.getInt("age"));   
         person.setName(obj.getString("name"));   
         return person;   
     }   
    
     public static String getListString(List<Person> listPersons) {   
         JSON json = JSONSerializer.toJSON(listPersons);   
         return json.toString();   
     }   
    
        
     /**  
      * 将一个json格式的字符串转换成行对应的对象  
      * @param str  
      * @return  
      */   
     public static List<Person> getPersons(String str) {   
         List<Person> list = new ArrayList<Person>();   
         JSONArray array = new JSONArray();   
         array.add(str);   
         JSONArray array2 = array.getJSONArray(0);   
         for (int i = 0; i <array2.size(); i++) {   
             JSONObject jsonObject =  array2.getJSONObject(i);   
             Person person = new Person();   
             person.setAge(jsonObject.getInt("age"));   
             person.setName(jsonObject.getString("name"));   
             list.add(person);   
         }   
         return list;   
     }   
     /**  
      * @param args  
      */   
     public static void main(String[] args) {   
         // TODO Auto-generated method stub   
         // JSON json = JSONSerializer.toJSON(JsonList.getList());   
         // System.out.println(getString(new Person(23,"jack")));   
         // System.out.println(getPerson("{'age':1002,'name':'李四2'}").toString());   
         // System.out.println(getListString(JsonList.getList()));   
         String msgString = "[{'age':1002,'name':'李四2'},{'age':1003,'name':'李四3'},{'age':1001,'name':'李四1'}]";   
         List<Person> lPersons = getPersons(msgString);   
         for(Person p:lPersons){   
             System.out.println(p.toString());   
         }   
     }   
 }   

第二种方式：

Gson方式

[java]view plaincopy 
     
   
 import java.util.ArrayList;   
 import java.util.HashMap;   
 import java.util.List;   
 import java.util.Map;   
 import com.android.domain.Person;   
 import com.google.gson.Gson;   
 import com.google.gson.reflect.TypeToken;   
    
 public class GsonTools {   
    
     public GsonTools() {   
         // TODO Auto-generated constructor stub   
     }   
    
     public static String createGsonString(Object object) {   
         Gson gson = new Gson();   
         String gsonString = gson.toJson(object);   
         return gsonString;   
     }   
    
     public static <T> T changeGsonToBean(String gsonString, Class<T> cls) {   
         Gson gson = new Gson();   
         T t = gson.fromJson(gsonString, cls);   
         return t;   
     }   
    
     public static <T> List<T> changeGsonToList(String gsonString, Class<T> cls) {   
         Gson gson = new Gson();   
         List<T> list_person = gson.fromJson(gsonString,   
                 new TypeToken<List<T>>() {   
                 }.getType());   
         return list_person;   
     }   
    
     public static List<Map<String, Object>> changeGsonToListMaps(String gsonString) {   
         List<Map<String, Object>> list = null;   
         Gson gson = new Gson();   
         list = gson.fromJson(gsonString,   
                 new TypeToken<List<Map<String, Object>>>() {   
                 }.getType());   
         return list;   
     }   
    
     /**  
      * @param args  
      */   
     public static void main(String[] args) {   
         // TODO Auto-generated method stub   
         // Person person1 = new Person("张三1", 24, "北京1");   
         // Person person2 = new Person("张三2", 23, "北京2");   
         // List<Person> list = new ArrayList<Person>();   
         // list.add(person1);   
         // list.add(person2);   
         //   
         // String gsonString = createGsonString(list);   
         // System.out.println(gsonString);   
         // Gson gson = new Gson();   
         // List<Person> list_person = changeGsonToList(gsonString,Person.class);   
         // System.out.println(list_person.toString());   
         // Person pp = changeGsonToBean(gsonString,Person.class);   
         // System.out.println(pp);   
         List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();   
         Map<String, Object> map = new HashMap<String, Object>();   
         map.put("name", "jack");   
         map.put("age", 23);   
         Map<String, Object> map2 = new HashMap<String, Object>();   
         map2.put("name", "rose");   
         map2.put("age", 24);   
         list.add(map);   
         list.add(map2);   
         String gsonString = createGsonString(list);   
         System.out.println(gsonString);   
         List<Map<String, Object>> list2 = changeGsonToListMaps(gsonString);   
         System.out.println(list2.toString());   
     }   
    
 }   

第三种方式：

fastJosn方式

[java]view plaincopy 
     
   
 import java.util.ArrayList;   
 import java.util.HashMap;   
 import java.util.List;   
 import java.util.Map;   
    
 import com.alibaba.fastjson.JSON;   
 import com.alibaba.fastjson.TypeReference;   
 import com.alibaba.fastjson.asm.Type;   
 import com.alibaba.fastjson.util.TypeUtils;   
    
 public class FastJsonTools {   
    
     public FastJsonTools() {   
         // TODO Auto-generated constructor stub   
     }   
    
     public static String createJsonString(Object object) {   
         String jsonString = JSON.toJSONString(object);   
         return jsonString;   
     }   
    
     public static <T> T createJsonBean(String jsonString, Class<T> cls) {   
         T t = JSON.parseObject(jsonString, cls);   
         return t;   
     }   
    
     public static <T> List<T> createJsonToListBean(String jsonString,   
             Class<T> cls) {   
         List<T> list = null;   
         list = JSON.parseArray(jsonString, cls);   
         return list;   
     }   
    
     /**  
      * @param jsonString  
      * @return  
      */   
     public static List<Map<String, Object>> createJsonToListMap(   
             String jsonString) {   
         List<Map<String, Object>> list2 = JSON.parseObject(jsonString,   
                 new TypeReference<List<Map<String, Object>>>() {   
                 });   
         return list2;   
     }   
    
     /**  
      * @param args  
      */   
     public static void main(String[] args) {   
         // TODO Auto-generated method stub   
         // Person person1 = new Person("张三1", 24, "北京1");   
         // Person person2 = new Person("张三2", 23, "北京2");   
         // List<Person> list = new ArrayList<Person>();   
         // list.add(person1);   
         // list.add(person2);   
         List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();   
         Map<String, Object> map = new HashMap<String, Object>();   
         map.put("name", "jack");   
         map.put("age", 23);   
         Map<String, Object> map2 = new HashMap<String, Object>();   
         map2.put("name", "rose");   
         map2.put("age", 24);   
         list.add(map);   
         list.add(map2);   
    
         String jsonString = JSON.toJSONString(list);   
         System.out.println(jsonString);   
         // JSON.parseArray(arg0, arg1)   
         List<Map<String, Object>> list2 = JSON.parseObject(jsonString,   
                 new TypeReference<List<Map<String, Object>>>() {   
                 });   
         // List<Person> lists = JSON.parseArray(arg0, arg1);   
         System.out.println(list2.toString());   
    
     }   
    
 }   

示例下载

参考网址

json官网

google-gson

博客一

=======================================================================================================================

0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

[java]view plaincopy 
     
   
 /**    
          * 获取"数组形式"的JSON数据，    
          * @param path  网页路径    
          * @return  返回JSONArray    
          * @throws Exception    
           */     
         public static String getJSONArray(String path) throws Exception {   
                 String json = null;   
                 URL url = new URL(path);   
                 // 利用HttpURLConnection对象,我们可以从网络中获取网页数据.   
                 HttpURLConnection conn = (HttpURLConnection) url.openConnection();   
                 // 单位是毫秒，设置超时时间为5秒   
                 conn.setConnectTimeout(5 * 1000);    
                 // HttpURLConnection是通过HTTP协议请求path路径的，所以需要设置请求方式,可以不设置，因为默认为GET   
                 conn.setRequestMethod("GET");    
                 if (conn.getResponseCode() == 200) {// 判断请求码是否是200码，否则失败   
                            
                         InputStream is = conn.getInputStream(); // 获取输入流   
                         byte[] data = readStream(is); // 把输入流转换成字符数组   
                         json = new String(data); // 把字符数组转换成字符串   
 //                        JSONArray jsonArray = new JSONArray(json);// 用android提供的框架JSONArray读取JSON数据，转换成Array   
                 }   
                 return json;   
         }   

该方法返回解析到的json数据（例：[{"ID":11,"uid":67,"carNo":"豫A000V1"},{"ID":12,"uid":67,"carNo":"豫A9E592"},{"ID":16,"uid":67,"carNo":"豫A1E238"}]）
然后就可以解析你想要的字段了

[java]view plaincopy 
     
   
 JSONArray jsonArray = new JSONArray(carIdJSON);   
                                         for (int i = 0; i < jsonArray.length(); i++) {   
                                                 JSONObject jsonObject = jsonArray.getJSONObject(i);   
     jsonObject.getString("carNo");   
     jsonObject.getString("ID");   
    
                                         }   

有解析就有上传了（POST上传），json的上传要用NameValuePairs，大家可以查看jdk关于NameValuePairs的解释
NameValuePairs只能传String类型的值

nameValuePairs.add(new BasicNameValuePair("xxx", xxx));

复制代码

可以上传很多字段（按需求上传就行了）

下面就是上传的方法

// 1. 使用POST方式时，传递参数必须使用NameValuePair数组
// 2. 使用GET方式时，通过URL传递参数，注意写法
// 3. 通过setEntity方法来发送HTTP请求
// 4. 通过DefaultHttpClient 的 execute方法来获取HttpResponse
// 5. 通过getEntity()从Response中获取内容
public static int httpPostData(String urlString,List<NameValuePair> nameValuePairs){
HttpClient httpclient = new DefaultHttpClient();
HttpPost httppost = new HttpPost(urlString);
try{
httppost.setEntity(new UrlEncodedFormEntity(nameValuePairs));
HttpResponse response = httpclient.execute(httppost);
int statusCode = response.getStatusLine().getStatusCode();
return statusCode;
}catch(Exception e){
e.printStackTrace();
}
return 0;
}

复制代码

方法返回请求服务器，返回的响应参数
200成功
200服务器出错
404服务器没响应（服务器有问题）

http://www.eoeandroid.com/forum.php?mod=viewthread&tid=165428&reltid=227908&pre_thread_id=0&pre_pos=2&ext=CB

http://www.eoeandroid.com/forum.php?mod=viewthread&tid=276713

qi_ruihua

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Android中的JSON解析方式：json; Gson ; Fastjson

本文主要介绍Json数据的解析----a，json数据的介绍----b，json数据的解析----c，gson数据的解析，谷歌公司的一种格式----d，fastjson数据的解析，阿里巴巴的一种格式通过本文的学习能掌握json数据格式的解析，为以后json格式数据的解析做到熟练于心。Json的全称：JavaScript Object Notation
复制链接

扫一扫