Android进阶笔记17：3种JSON解析工具（org.json、fastjson、gson）

2023-01-31 21:09:14

一、 目前解析json有三种工具：org.json（Java常用的解析），fastjson（阿里巴巴工程师开发的），Gson（Google官网出的），其中解析速度最快的是Gson。

3种json工具下载目录为：http://download.csdn.net/detail/hebao5201314/9491742

二、org.json是Java常用的JSON数据解析，主要提供JSONObject和JSONArray类，现在就各个类的使用解释如下。 

1、准备工作：

（1）在使用org.json之前，我们应该先从该网址 https://github.com/douglascrockford/JSON-java下载org.json源码，并将源码其加入到Eclipse中，即可调用。 

（2）查看相关的API文档，访问：https://github.com/douglascrockford/JSON-java 。 

2、org.json的使用：

（1）JSONObject：

  • 是一个无序的键/值对集合。

  • 它的表现形式是一个包裹在花括号的字符串，键和值之间使用冒号隔开，键值和键值之间使用逗号隔开。

  • 内在形式是一个使用get()和opt()方法通过键来访问值，和使用put()方法通过键来添加或者替代值的对象。

  • 值可以是任何这些类型：Boolean,JSONArray,JSONObject,Number和String，或者JOSONObject.NULL对象。

 代码演示如下： 

 public static void jsonObjectTest() {

     JSONObject jsonobj = new JSONObject("{'name':'xiazdong','age':20}");

     String name = jsonobj.getString("name");

     int age = jsonobj.getInt("age");

     System.out.println("name = " + name + ",age = " + age);

 }

注：JSONObject有很多optXXX方法，比如optBoolean, optString, optInt... 

他们的意思是，如果这个jsonObject有这个属性，则返回这个属性，否则返回一个默认值。 

（2）JSONArray： 

  • 是一个有序的序列值。

  • 它的表现形式是一个包裹在方括号的字符串，值和值之间使用逗号隔开。

  • 内在形式是一个使用get()和opt()方法通过索引来访问值，和使用put()方法来添加或修改值的对象。

  • 值可以是任何这些类型：Boolean,JSONArray,JSONObject,Number,和String，或者JSONObject.NULL对象。

代码演示如下： 

 public static void jsonArrayTest() {

     JSONArray jsonarray = new JSONArray("[{'name':'xiazdong','age':20},{'name':'xzdong','age':15}]");

     for (int i = 0; i < jsonarray.length(); i++) {

             JSONObject jsonobj = jsonarray.getJSONObject(i);

             String name = jsonobj.getString("name");

             int age = jsonobj.getInt("age");

             System.out.println("name = " + name + ",age = " + age);

     }

 }

嵌套的JSONObject和JSONArray代码演示如下： 

 public static void jsonObjectAndArrayTest() {

     String jsonstring = "{'name':'xiazdong','age':20,'book':['book1','book2']}";

     JSONObject jsonobj = new JSONObject(jsonstring); 

     String name = jsonobj.getString("name");

     System.out.println("name" + ":" + name); 

     int age = jsonobj.getInt("age");

     System.out.println("age" + ":" + age); 

     JSONArray jsonarray = jsonobj.getJSONArray("book");

     for (int i = 0; i < jsonarray.length(); i++) {

             String book = jsonarray.getString(i);

             System.out.println("book" + i + ":" + book);

     }

 }

（3）JSONStringer： 

  • 是一个用于快速构造JSON文本的工具

  • JSONWriter的子类

  • bject():开始一个对象，即添加{；enObject():结束一个对象，即添加}

  • array():开始一个数组，即添加[； endArray():结束一个数组，即添加]

  • key():表示添加一个key；value():表示添加一个value

代码演示如下： 

 public static void jsonStringerTest() {

     JSONStringer stringer = new JSONStringer();

     stringer.object().key("name").value("xiazdong").key("age").value(20).endObject();

     System.out.println(stringer);

 }

负载的JSON格式写演示（PrintWriter+JSONStringer可以写入JSON文件）： 

 public static void jsonStringerTest2() throws FileNotFoundException {

     JSONStringer jsonStringer = new JSONStringer(); 

     JSONObject obj6 = new JSONObject();

     obj6.put("title", "book1").put("price", "$11"); 

     JSONObject obj3 = new JSONObject();

     obj3.put("book", obj6);

     obj3.put("author", new JSONObject().put("name", "author-1")); 

     JSONObject obj5 = new JSONObject();

     obj5.put("title", "book2").put("price", "$22"); 

     JSONObject obj4 = new JSONObject();

     obj4.put("book", obj5);

     obj4.put("author", new JSONObject().put("name", "author-2")); 

     JSONArray obj2 = new JSONArray();

     obj2.put(obj3).put(obj4); 

     JSONObject obj1 = new JSONObject();

     obj1.put("title", "BOOK");

     obj1.put("signing", obj2); 

     jsonStringer.object().key("session").value(obj1).endObject();

     System.out.println(jsonStringer.toString()); 

     PrintWriter out = new PrintWriter(new FileOutputStream("1.txt"));

     out.println(jsonStringer.toString());

     out.close();

 }

（4）JSONTokener 

  • 它和JSONObject和JSONArray的构造函数一起使用，用于解析JSON源字符串

代码演示如下（JSONObject+JSONTokener能够获取JSON格式文本对象）： 

 public static void JSONTokenerTest() throws FileNotFoundException {

     JSONObject jsonobj = new JSONObject(new JSONTokener(new FileReader(new File("1.txt"))));

     System.out.println(jsonobj.getJSONObject("session").getJSONArray("signing").getJSONObject(1).getJSONObject("book").getString("title"));

 }

注意：在Java中，JSON格式的字符串最好用单引号表示 

三、fastjson是一个阿里巴巴开发的Json处理工具包，包括"序列化"和"反序列化"两部分，它具备如下特征：

速度最快，测试表明，fastjson具有极快的性能，超越任其他的Java Json parser，包括自称最快的JackJson；
功能强大，完全支持Java Bean、集合、Map、日期、Enum，支持范型，支持自省；

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

支持Android；

开源 (Apache 2.0)

1、Fastjson API入口类是com.alibaba.fastjson.JSON，常用的序列化操作都可以在JSON类上的静态方法直接完成：

public static final Object parse(String text); // 把JSON文本parse为JSONObject或者JSONArray

public static final JSONObject parseObject(String text)； // 把JSON文本parse成JSONObject

public static final  T parseObject(String text, Class clazz); // 把JSON文本parse为JavaBean

public static final JSONArray parseArray(String text); // 把JSON文本parse成JSONArray

public static final  List parseArray(String text, Class clazz); //把JSON文本parse成JavaBean集合

public static final String toJSONString(Object object); // 将JavaBean序列化为JSON文本

public static final String toJSONString(Object object, boolean prettyFormat); // 将JavaBean序列化为带格式的JSON文本

public static final Object toJSON(Object javaObject); //将JavaBean转换为JSONObject或者JSONArray。

2、FastJson解析JSON数据步骤：

（1）服务器端将数据转换成JSON字符串：

首先服务器端项目要导入阿里巴巴的fastjson的jar包至builtPath路径下，如下图：

Android进阶笔记17：3种JSON解析工具（org.json、fastjson、gson）

然后将数据转为json字符串，核心函数是：

public static String createJsonString(Object value)

    {

        String alibabaJson = JSON.toJSONString(value);

        return alibabaJson;

    }

（2）客户端将JSON字符串 转换为 相应的Java Bean

首先客户端也是需要导入fastjson两个jar包

  • 客户端获取JSON字符串
public class HttpUtil

{

    public static String getJsonContent(String urlStr)

    {

        try

        {// 获取HttpURLConnection连接对象

            URL url = new URL(urlStr);

            HttpURLConnection httpConn = (HttpURLConnection) url

                    .openConnection();

            // 设置连接属性

            httpConn.setConnectTimeout(3000);

            httpConn.setDoInput(true);

            httpConn.setRequestMethod("GET");

            // 获取相应码

            int respCode = httpConn.getResponseCode();

            if (respCode == 200)

            {

                return ConvertStream2Json(httpConn.getInputStream());

            }

        }

        catch (MalformedURLException e)

        {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

        catch (IOException e)

        {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

        return "";

    }

    private static String ConvertStream2Json(InputStream inputStream)

    {

        String jsonStr = "";

        // ByteArrayOutputStream相当于内存输出流

        ByteArrayOutputStream out = new ByteArrayOutputStream();

        byte[] buffer = new byte[1024];

        int len = 0;

        // 将输入流转移到内存输出流中

        try

        {

            while ((len = inputStream.read(buffer, 0, buffer.length)) != -1)

            {

                out.write(buffer, 0, len);

            }

            // 将内存流转换为字符串

            jsonStr = new String(out.toByteArray());

        }

        catch (IOException e)

        {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

        return jsonStr;

    }

}

（2）客户端获得Java Bean

首先我们定义两个Bean类 User 和 Group：

工程结构图，如下：

Android进阶笔记17：3种JSON解析工具（org.json、fastjson、gson）

User：

public class User {

    private Long id;

    private String name;

    public Long getId() {

           return id;

    }

    public void setId(Long id) {

           this.id = id;

    }

    public String getName() {

           return name;

    }

    public void setName(String name) {

           this.name = name;

    }

}

Group：

public class Group {

    private Long id;

    private String name;

    private List<User> users = new ArrayList<User>();

    public Long getId() { 
　　　　　　return id; 
　　}

    public void setId(Long id) { 
　　　　　　this.id = id; 
　　}

    public String getName() { 
　　　　　　return name; 
　　}

    public void setName(String name) { 
　　　　　　this.name = name; 
　　}

    public List<User> getUsers() { 
　　　　　　return users; 
　　}

    public void setUsers(List<User> users) { 
　　　　　　this.users = users; 
　　}

}

测试代码FastJsonTest，如下：

package com.himi.fastjson;

import java.util.List;

import com.alibaba.fastjson.JSON;

public class FastJsonTest {

    public static void main(String[] args) {

        Group group = new Group();

        group.setId(0L);

        group.setName("admin");

        User guestUser = new User();

        guestUser.setId(2L);

        guestUser.setName("guest");

        User rootUser = new User();

        rootUser.setId(3L);

        rootUser.setName("root");

        group.getUsers().add(guestUser);

        group.getUsers().add(rootUser);

        String jsonString = JSON.toJSONString(group);

        System.out.println(jsonString);

        System.out.println("--------------------");

        Group group2 = JSON.parseObject(jsonString, Group.class);

        List<User> lists = group2.getUsers();

        for(int i=0; i<lists.size(); i++)

        {

            User user = (User)lists.get(i);

            System.out.println("ID:"+user.getId()+" Name:"+user.getName());

        }

    }

}

代码运行效果，如下：

Android进阶笔记17：3种JSON解析工具（org.json、fastjson、gson）

三、Gson是一个能把Java对象转化成JSON表现形式的一个库。并且他也能把一个JSON 字符串转换成等价的Java对象。Gson 是Google 开源出来的一个开源项目， 目前代码托管在github上。据说他很吊，能操作任何的java对象，甚至是没有源码的已经存在的Java对象。

新建一个JAVA工程为：GsonDemo，同时导入gson-2.3.1.jar包，如下：

Android进阶笔记17：3种JSON解析工具（org.json、fastjson、gson）

 1、将数组 转化为 JSON字符串：

在com.himi.gson，新建一个ArrayToJson，如下：

 package com.himi.gson;

 import com.google.gson.Gson;

 public class ArrayToJson {

     public static void main(String[] args) {

         // TODO Auto-generated method stub

         int numbers[] = {1,2,3,4,5,6,7};

         String[] days = {"Sun","Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};

         Gson gson = new Gson();

         String numbersJson = gson.toJson(numbers);

         String daysJson = gson.toJson(days);

         System.out.println("numbers数组转化为JSON数据："+numbersJson);

         System.out.println("days数组转化为JSON数据："+daysJson);

         System.out.println("");

         System.out.println("-------将JSON字符串转化为字符串数组-------");

         String[] weekdays = gson.fromJson(daysJson, String[].class);

         for(int i=0; i<weekdays.length; i++) {

             if (i == weekdays.length - 1) {

                 System.out.print(weekdays[i]);

             } else {

                 System.out.print(weekdays[i] + ",");

             }

         }

         System.out.println("");

         System.out.println("-------将多维int数组转化为Json-------");

         int[][] data = {{1, 2, 3}, {3, 4, 5}, {4, 5, 6}};

         String json = gson.toJson(data);

         System.out.println("Data = " + json);

         System.out.println("-------将JSON字符串组转化为多维int数组-------");

         int[][] dataMap = gson.fromJson(json, int[][].class);

         for (int i = 0; i < data.length; i++) {

             for (int j = 0; j < data[i].length; j++) {

                 System.out.print(data[i][j] + " ");

             }

             System.out.println("");

         }

     }

 }

运行效果，如下：

Android进阶笔记17：3种JSON解析工具（org.json、fastjson、gson）

2、将JAVA集合 转化为 JSON字符串：

新建一个包为com.himi.gson.bean，在内部新建一个类Student，如下：

 package com.himi.gson.bean;

 import java.util.Date;

 public class Student {

     private String name;

     private String address;

     private Date dateOfbirth;

     public Student() {

     }

     public Student(String name, String address, Date dateOfbirth) {

         super();

         this.name = name;

         this.address = address;

         this.dateOfbirth = dateOfbirth;

     }

     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 Date getDateOfbirth() {

         return dateOfbirth;

     }

     public void setDateOfbirth(Date dateOfbirth) {

         this.dateOfbirth = dateOfbirth;

     }

 }

同时在com.himi.gson包下，新建一个类CollectToJson，如下：

 package com.himi.gson;

 import java.util.ArrayList;

 import java.util.Date;

 import java.util.List;

 import java.lang.reflect.Type;

 import com.google.gson.Gson;

 import com.google.gson.reflect.TypeToken;

 import com.himi.gson.bean.Student;

 public class CollectToJson {

     public static void main(String[] args) {

         Gson gson = new Gson();

         System.out.println("-----------将List的字符串集合转化为JSON字符串-----------");

         List<String> names = new ArrayList<String>();

         names.add("Alice");

         names.add("Bob");

         names.add("Carol");

         names.add("Mallory");

         String jsonNames = gson.toJson(names);

         System.out.println("jsonNames = " + jsonNames);

         System.out.println("-----------将List的Student集合转化为JSON字符串-----------");

         Student a = new Student("Alice", "Apple St", new Date(2000, 10, 1));

         Student b = new Student("Bob", "Banana St", null);

         Student c = new Student("Carol", "Grape St", new Date(2000, 5, 21));

         Student d = new Student("Mallory", "Mango St", null);

         List<Student> students = new ArrayList<Student>();

         students.add(a);

         students.add(b);

         students.add(c);

         students.add(d);

         String jsonStudents = gson.toJson(students);

         System.out.println("jsonStudents = " + jsonStudents);

         System.out.println("-----------将JSON字符串转化为一个Student类的集合-----------");

         Type type = new TypeToken<List<Student>>() {

         }.getType();

         List<Student> studentList = gson.fromJson(jsonStudents, type);

         for (Student student : studentList) {

             System.out.println("student.getName() = " + student.getName()+"\n"

             +"student.getAddress() = "+student.getAddress()+"\n"

             +"student.getDateOfbirth() = "+student.getDateOfbirth());

             System.out.println("");

         }

     }

 }

运行效果，如下：

Android进阶笔记17：3种JSON解析工具（org.json、fastjson、gson）

3、将Map 转化为 Json字符串：

在com.himi.gson包下，新建一个MapToJson，如下：

package com.himi.gson;

import java.lang.reflect.Type;

import java.util.HashMap;

import java.util.Map;

import com.google.gson.Gson;

import com.google.gson.reflect.TypeToken;

public class MapToJson {

    public static void main(String[] args) {

        Map<String, String> colours = new HashMap<String, String>();

        colours.put("BLACK", "#000000");

        colours.put("RED", "#FF0000");

        colours.put("GREEN", "#008000");

        colours.put("BLUE", "#0000FF");

        colours.put("YELLOW", "#FFFF00");

        colours.put("WHITE", "#FFFFFF");

        System.out.println("将一个Map转化为Json字符串");

        Gson gson = new Gson();

        String json = gson.toJson(colours);

        System.out.println("json = " + json);

        System.out.println("---------------------");

        System.out.println("将一个Json字符串转化一个Map");

        Type type = new TypeToken<Map<String, String>>() {

        }.getType();

        Map<String, String> map = gson.fromJson(json, type);

        for (String key : map.keySet()) {

            System.out.println("map.get = " + map.get(key));

        }

    }

}

运行效果，如下：

Android进阶笔记17：3种JSON解析工具（org.json、fastjson、gson）

4、将对象 转化为 Json字符串：

在com.himi.gson包下，新建一个类StudentToJson，如下：

 package com.himi.gson;

 import java.util.Calendar;

 import com.google.gson.Gson;

 import com.himi.gson.bean.Student;

 public class StudentToJson {

     public static void main(String[] args) {

         Calendar dob = Calendar.getInstance();

         dob.set(2000, 1, 1, 0, 0, 0);

         Student student = new Student("Duke", "Menlo Park", dob.getTime());

         Gson gson = new Gson();

         String json = gson.toJson(student);

         System.out.println("json = " + json);

     }

 }

运行效果如下：

Android进阶笔记17：3种JSON解析工具（org.json、fastjson、gson）

5、将Json字符串 转化为 对象：

在com.himi.gson包下，新建一个JsonToStudent，如下：

 package com.himi.gson;

 import com.google.gson.Gson;

 import com.himi.gson.bean.Student;

 public class JsonToStudent {

     public static void main(String[] args) {

         String json = "{\"name\":\"Duke\",\"address\":\"Menlo Park\",\"dateOfBirth\":\"Feb 1, 2000 12:00:00 AM\"}";

         Gson gson = new Gson();

         Student student = gson.fromJson(json, Student.class);

         System.out.println("student.getName()        = " + student.getName());

         System.out.println("student.getAddress()     = " + student.getAddress());

         System.out.println("student.getDateOfbirth() = " + student.getDateOfbirth());

     }

 }

运行效果，如下：

Android进阶笔记17：3种JSON解析工具（org.json、fastjson、gson）

上一篇：Android进阶笔记14：3种JSON解析工具（org.json、fastjson、gson）


下一篇：Java: 扩大字节缓存区的大小，提升AIO的处理性能(并发性能)