JSON框架之阿里fastjson的介绍

1. 前言

1.3 FastJson介绍

在日常的java项目开发中，JSON的使用越来越频繁，对于Json的处理工具也有很多。接下来就介绍一下阿里开源的一个高性能的JSON框架FastJson，功能完善，完全支持标准JSON库，现在已经越来越受到开发者的青睐。

1.2 FastJson的特点：

    1) FastJson数据处理速度快，无论序列化（把JavaBean对象转化成Json格式的字符串）和反序列化（把JSON格式的字符串转化为Java Bean对象），都是当之无愧的fast

    2) 功能强大（支持普通JDK类，包括javaBean, Collection, Date 或者enum）

    3) 零依赖（没有依赖其他的任何类库）

1.3 FastJson的简单说明：

FastJson对于JSON格式的字符串的解析主要是用到了下面三个类：

    1） JSON：FastJson的解析器，用于JSON格式字符串与JSON对象及JavaBean之间的转化。也是最基础的一个类，因为看过源码之后会发现，下面的两个类继承了JSON类，其中很多方法的实现也是基于JSON类中的parse()方法。

    2） JSONObject： FastJson提供的json对象，用于将String对象、javaBean、Collection等解析为JSON格式的对象

    3） JSONArray： FastJson提供json数组对象

2. FastJson的基础用法。

首先，我们定义两个json格式的字符串，以及两个JavaBean（使用了lombok）。方便我们在下面的代码中去使用FastJson中的方法。

String jsonString = "{\"errno\":0,\"data\":{\"count\":6,\"datastreams\":[{\"datapoints\":" +
                "[{\"at\":\"2018-05-01 15:33:25.000\",\"value\":{\"lon\":\"104.07803838511\"," +
                "\"lat\":\"30.633662874767996\"}},{\"at\":\"2018-04-29 17:37:25.000\",\"value\":" +
                "{\"lon\":\"106.54504673673999\",\"lat\":\"29.555934913502\"}},{\"at\":" +
                "\"2018-04-29 17:28:47.000\",\"value\":{\"lon\":\"106.5450423966\",\"lat\":" +
                "\"29.555937892982\"}},{\"at\":\"2018-04-29 17:08:25.000\",\"value\":{\"lon\":\"106.54504104044\"," +
                "\"lat\":\"29.555938434163\"}},{\"at\":\"2018-04-29 17:03:28.000\",\"value\":" +
                "{\"lon\":\"104.07765307713001\",\"lat\":\"30.634041802113998\"}}," +
                "{\"at\":\"2018-04-26 15:02:20.000\",\"value\":{\"lon\":\"104.07796817860999\",\"lat\":" +
                "\"30.633655490910996\"}}],\"id\":\"GPS\"}]},\"error\":\"succ\"}";

String beanStr = "{\"at\":\"2018-01-01\",\"value\":{\"lat\":\"456\",\"lon\":\"123\"}}";

jsonString字符串对应的JSON格式，以及beanStr字符串对应的Json格式分别为：

import lombok.Data;

/**
 * Created by songyangguang on 2018/5/10.
 */
@Data
public class Location {
    private String lon;
    private String lat;
}

import lombok.Data;

/**
 * Created by songyangguang on 2018/5/10.
 */
@Data
public class Datapoint {
    private String at;
    private Location value;
}

2.1 JSON格式字符串与JSON对象之间的转换

/**
     * json字符串-简单对象类型到JSONObject的转换
     * @param jsonStr
     */
    private static JSONObject testJsonStrToJSON(String jsonStr) {
        //将Json格式的字符串转化为JSON，这样才能按照层级读取JSON数据中的值
        JSONObject jsonObject = JSONObject.parseObject(jsonStr);
        System.out.println(jsonObject.getInteger("errno"));
        System.out.println(jsonObject.getJSONObject("data"));
        System.out.println(jsonObject.getString("error"));
        
        return jsonObject;
    }

    /**
     * JSONObject到json字符串-简单对象型的转换
     * @param jsonObject
     */
    private static void testJsonObjectToJsonStr(JSONObject jsonObject) {
        String jsonStr = jsonObject.toJSONString();
        System.out.println(jsonStr);
    }

其实，String——》JSON格式的转化，就是使用了JsonObject中的解析函数parseObject(String参数)。只有解析为JSON对象后，才能进行层级取值（JsonObject对象中的get***(String key)函数取出相应类型的值）。

    注：层级是指Json格式每一层的key-value的值（每次只能取最近一层的值）。如下图

一个Json格式的数据，所以，一次只能通过jsonObject.get***(key)读取第一层（最近）的数据。第二层的数据只能通过JsonObject.getJsonObject("data")获取第二层的数据，然后通过getString("key")等获取对应的值。这就是所谓的按照层级。

2.2 json字符串(数组类型)与JSONArray之间的转换

/**
     *JsonArray与Json字符串-数组类型的转化
     * @param jsonArray
     */
    private static void testJSONArrayToJsonStr(JSONArray jsonArray) {
        String arrStr = JSONArray.toJSONString(jsonArray);
        System.out.println(arrStr);
    }

    /**
     * Json字符串-数组类型到JSONArray的转换
     * @param jsonString
     */
    private static JSONArray testJsonStrToJSONArray(String jsonString) {

        JSONObject jsonObject = JSONObject.parseObject(jsonString);
        //获取data数据，然后读取data数据中datastreams关键字对应的数组（有[]标示的为数组）
        JSONArray jsonArray1 = jsonObject.getJSONObject("data").getJSONArray("datastreams");
        //获取JsonArray下标对应的JsonObject
        JSONObject jsonArray2 = jsonArray1.getJSONObject(0);
        //其中的关键字datapoints对应的也是一个JsonObject数组
        JSONArray jsonArray3 = jsonArray2.getJSONArray("datapoints");
        System.out.println(jsonArray3);

     /*   int size = jsonArray3.size();
        //遍历1
        for(int i = 0; i < size; i++) {
            System.out.println(jsonArray3.getJSONObject(i));
        }*/

        //遍历2
        for(Object object: jsonArray3){
            System.out.println(object);
        }
        return jsonArray3;
    }

其中，我们可以通过观察JSON格式的数据来确定层级的内容，以及是Object还是ArrayObject。如下图：

可以通过正常的数组遍历每一个Object。

2.3 简单的JavaBean与Json对象之间的转化

前面我们以及定义两个bean。

/**
     * 简单json对象到JavaBean_obj的转换
     *
     * 步骤：第一步将 JsonString转化为JSON格式的数据
     * 第二：通过JSONObject.parseObject(*,*)方法转化
     */
    private static void testJsonToJsonBean() {
        
        JSONObject jsonObject = JSONObject.parseObject(beanStr);

        //第一种方式：使用TypeRefernce<T>,由于其构造方式使用protected进行修饰，故创建其子类
        Datapoint datapoint = JSONObject.parseObject(jsonObject.toJSONString(),new TypeReference<Datapoint>() {});

        System.out.println(datapoint);
    }

    /**
     * 简单javaBean到json对象的转换
     */
    private static void testJavaBeanToJson() {
        //模拟一个javaBean数据
        Datapoint datapoint = new Datapoint();
        Location location = new Location();

        location.setLon("123");
        location.setLat("456");
        datapoint.setAt("2018-01-01");
        datapoint.setValue(location);
        //一步实现
        String jsonString = JSONObject.toJSONString(datapoint);
        System.out.println(jsonString);
    }

2.4 JavaList对象数组与JsonArray之间的转化

/**
     * 将JavaBeanList 转化为JsonArray
     */
    private static void testJavaListToJsonArray() {
        //模拟一个List<JabaBean>
        Location location1 = new Location();
        Location location2 = new Location();
        Datapoint datapoint1 = new Datapoint();
        Datapoint datapoint2 = new Datapoint();
        List<Datapoint> datapoints = new ArrayList<Datapoint>();
        location1.setLon("1122");
        location1.setLat("2233");
        datapoint1.setAt("2018-01-02");
        datapoint1.setValue(location1);
        datapoints.add(datapoint1);
        location2.setLon("3344");
        location2.setLat("4455");
        datapoint2.setAt("2018-01-03");
        datapoint2.setValue(location2);
        datapoints.add(datapoint2);

        //方法一：
        String arrString = JSONArray.toJSONString(datapoints);
        JSONArray jsonArray = JSONArray.parseArray(arrString);
        System.out.println(jsonArray);
        //方法二：
        JSONArray jsonArray1 = (JSONArray) JSONArray.toJSON(datapoints);
        System.out.println(jsonArray1);
    }

    //JavaList与JsonArray之间的转换
    private static void testJsonArrayToJavaList(String jsonString) {
        //已知JsonArray
        JSONArray jsonArray = testJsonStrToJSONArray(jsonString);

        //方法一：使用TypeReference<T>类，由于其构造方法使用protected进行修饰，故创造其子类
        List<Datapoint> datapoints = JSONArray.parseObject(jsonArray.toJSONString(),new TypeReference<ArrayList<Datapoint>>() {});
        System.out.println(datapoints);

        //方法二：使用Gson的思想
        List<Datapoint> datapoints1 = JSONArray.parseArray(jsonArray.toJSONString(),Datapoint.class);
        System.out.println();
    }

3 总结：

其实我们平时用到的也就是上面的这个方法，JSONObject，JSONArray两个类中的方法。想深入了解的话，可以看一下源码。但是源码基本上没有注释，所以看起来有点迷糊。但是只要深入研究，总能弄明白的。现在我只会使用这些常用的方法，希望后面有时间能够深入的取研究一下源码。