Json解析與使用

時間  2019-11-16
標籤 json 解析 使用 欄目 JavaScript 简体版
原文   原文鏈接

目錄介紹

  • 0.提問環節

  • 1.基本使用php

    • 1.1 Gson對象建立
    • 1.2 生成Json字符串
    • 1.3 fromJson之Json數組轉化爲字符串數組
    • 1.4 toJson之字符串數組轉爲Json數組
    • 1.5 fromJson之Json數組轉爲List<String>
    • 1.6 toJson之List<String>轉爲Json數組
    • 1.7 toJson之List<Model>轉爲Json數組
    • 1.8 fromJson之Json數組轉爲List<Model>

  • 2.高級使用git

    • 2.1 序列化和反序列化
    • 2.2 序列化
    • 2.3 反序列化
    • 2.4 字段過濾
    • 2.5 屬性重命名
    • 2.6 個性化設置
    • 2.7 TypeAdapter
    • 2.8 JsonSerializer序列化接口
    • 2.9 JsonDeserializer反序列化接口
    • 3.0 將請求網絡日誌按照必定格式展現

  • 3.源碼分析程序員

    • 3.1 後期添加
  • 4.知識拓展

關於連接

1.基本使用

1.1 Gson對象建立

  • 1.1.1 直接經過new來建立對象
//經過構造函數來獲取
Gson gson = new Gson();
//經過 GsonBuilder 來獲取，能夠進行多項特殊配置
Gson gson = new GsonBuilder().create();
  • 1.1.2 經過單利方式建立全局對象
private static Gson gson = null;

static {
    if (gson == null) {
        gson = new GsonBuilder()
                .setLenient()// json寬鬆
                .enableComplexMapKeySerialization()//支持Map的key爲複雜對象的形式
                .serializeNulls() //智能null
                .setPrettyPrinting()// 調教格式
                .disableHtmlEscaping()
                .registerTypeAdapter(int.class, new JsonDeserializer<Integer>() {//根治服務端int 返回""空字符串
                    @Override
                    public Integer deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
                        //try catch不影響效率
                        try {
                            return json.getAsInt();
                        } catch (NumberFormatException e) {
                            return 0;
                        }
                    }
                })
                .create();
    }
}

public static Gson getGson() {
    return gson;
}

1.2 生成Json字符串

  • 1.2.1 代碼以下所示
private void toJson() {
    JsonObject jsonObject = new JsonObject();
    jsonObject.addProperty("String", "leavesC");
    jsonObject.addProperty("Number_Integer", 23);
    jsonObject.addProperty("Number_Double", 22.9);
    jsonObject.addProperty("Boolean", true);
    jsonObject.addProperty("Char", 'c');
    //Log.e(TAG,jsonObject.getAsString());      //這個會崩潰
    Log.e(TAG,jsonObject.toString());
    Log.e(TAG,jsonObject+"");
    //{"String":"leavesC","Number_Integer":23,"Number_Double":22.9,"Boolean":true,"Char":"c"}
    //{"String":"leavesC","Number_Integer":23,"Number_Double":22.9,"Boolean":true,"Char":"c"}
}
  • 1.2.2 addProperty方法
  • 支持String，boolean，char，Number(包含：int，long，float，double，byte，short)
public void addProperty(String property, String value) {
    add(property, createJsonElement(value));
}

public void addProperty(String property, Number value) {
    add(property, createJsonElement(value));
}

public void addProperty(String property, Boolean value) {
    add(property, createJsonElement(value));
}

public void addProperty(String property, Character value) {
    add(property, createJsonElement(value));
}
  • 1.2.3 經過 JsonObject 本身來構建一個 JsonElement
  • addProperty 方法底層調用的是 add(String property, JsonElement value) 方法，即將基本數據類型轉化爲了 JsonElement 對象，JsonElement 是一個抽象類，而 JsonObject 繼承了 JsonElement ，所以咱們能夠經過 JsonObject 本身來構建一個 JsonElement
//注意這個方法返回JsonElement對象
private JsonElement createJsonElement(Object value) {
    return value == null ? JsonNull.INSTANCE : new JsonPrimitive(value);
}

  • 1.2.4 json解析步驟github

    • 首先獲取JSON元素數組：JSONArray jsonArray = new JSONArray(jsonData);
    • 其次循環獲取每一個元素：JSONObject jsonObject = jsonArray.getJSONObject(index);
    • 每次循環保存名稱相對應的值：String name = jsonObject.getString("name");

1.3 Json數組轉化爲字符串數組

private void jsonToArray() {
    //Json數組 轉爲 字符串數組
    String[] arr = {"2222","3333","4444","5555"};
    //這種崩潰
    //String jsonArray = "{\"2222\",\"3333\",\"4444\",\"5555\"}";
    //這種正常
    String jsonArray = "[\"2222\",\"3333\",\"4444\",\"5555\"]";
    String[] strings = gson.fromJson(jsonArray, String[].class);
    System.out.println("Json數組 轉爲 字符串數組: ");
    for (String string : strings) {
        Log.e(TAG,string);
    }
}

打印日誌：
2222
3333
4444
5555

1.4 toJson之字符串數組轉爲Json數組

private void arrayToJson() {
    String jsonArray = "[\"2222\",\"3333\",\"4444\",\"5555\"]";
    //字符串數組 轉爲 Json數組
    jsonArray = gson.toJson(jsonArray, new TypeToken<String>() {}.getType());
    Log.e(TAG,jsonArray);
    
    //打印日誌
    //"[\"2222\",\"3333\",\"4444\",\"5555\"]"
}

1.5 fromJson之Json數組轉爲List

private void jsonToList() {
    //Json數組 轉爲 List
    String jsonArray = "[\"2222\",\"3333\",\"4444\",\"5555\"]";
    List<String> stringList = gson.fromJson(jsonArray, new TypeToken<List<String>>() {}.getType());
    for (String string : stringList) {
        Log.e(TAG,string);
    }
}

1.6 toJson之List<String>轉爲Json數組

private void listToJson() {
    String jsonArray = "[\"2222\",\"3333\",\"4444\",\"5555\"]";
    List<String> stringList = gson.fromJson(jsonArray, new TypeToken<List<String>>() {}.getType());
    //List 轉爲 Json數組
    jsonArray = gson.toJson(stringList, new TypeToken<List<String>>() {}.getType());
    Log.e(TAG,jsonArray);
    //打印日誌
    //["2222","3333","4444","5555"]
}

1.7 toJson之List<Model>轉爲Json數組

private void listModelToJson() {
    Person model1 = new Person("yangChong", 25, true);
    Person model2 = new Person("doubi", 26, false);
    final ArrayList<Person> lists = new ArrayList<>();
    lists.add(model1);
    lists.add(model2);
    Gson gson = new Gson();
    String s = gson.toJson(lists);
    Log.e(TAG,s);
    //打印日誌
    //[{"age":25,"name":"yangChong","sex":true},{"age":26,"name":"doubi","sex":false}]
}

1.8 fromJson之Json數組轉爲List<Model>

private void jsonToListMode() {
    String json = "[{\"age\":25,\"name\":\"yangChong\",\"sex\":true},{\"age\":26,\"name\":\"doubi\",\"sex\":false}]";
    Gson gson = new Gson();
    List<Person> list = gson.fromJson(json, new TypeToken<List<Person>>() {}.getType());
    for (Person person : list) {
        Log.e(TAG,person.toString());
    }
    //打印日誌
    //Person{name='yangChong', age=25, sex=true}
    //Person{name='doubi', age=26, sex=false}
}

2.高級使用

2.1 序列化和反序列化

  • Gson 也提供了 toJson() 和 fromJson() 兩個方法用於轉化 Model 與 Json，前者實現了序列化，後者實現了反序列化。

2.2 序列化

  • 將model對象轉變成json字符串
private void personModelToJson() {
    //序列化
    Person person = new Person("yangChong", 25, true);
    Gson gson = new Gson();
    String s = gson.toJson(person);
    Log.e(TAG,s);
    //打印日誌
    //{"age":25,"name":"yangChong","sex":true}
}

2.3 反序列化

  • 將json字符串轉變成model對象
private void jsonToPersonModel() {
    //反序列化
    String userJson = "{\"age\":25,\"name\":\"yangChong\",\"sex\":true}";
    Gson gson = new Gson();
    Person person = gson.fromJson(userJson, Person.class);
    Log.e(TAG,person.toString());
    //打印日誌
    //Person{name='yangChong', age=25, sex=true}
}

2.5 屬性重命名

2.6 個性化設置

gson = new GsonBuilder()            //builder構建者模式
        .setLenient()               //json寬鬆
        .enableComplexMapKeySerialization() //支持Map的key爲複雜對象的形式
        .setPrettyPrinting()        //格式化輸出
        .serializeNulls()           //智能null
        //.setDateFormat("yyyy-MM-dd HH:mm:ss:SSS")       //格式化時間
        .disableHtmlEscaping()      //默認是GSON把HTML轉義的
        .registerTypeAdapter(int.class, new JsonDeserializer<Integer>() {
            //根治服務端int 返回""空字符串
            @Override
            public Integer deserialize(JsonElement json, Type typeOfT,
                                       JsonDeserializationContext context)
                    throws JsonParseException {
                //try catch不影響效率
                try {
                    return json.getAsInt();
                } catch (NumberFormatException e) {
                    return 0;
                }
            }
        })
        .create();

2.7 TypeAdapter

  • TypeAdapter 是一個泛型抽象類，用於接管某種類型的序列化和反序列化過程，包含兩個抽象方法，分別用於自定義序列化和反序列化過程
  • 2.7.1 舉個例子
  • 定義 TypeAdapter 的子類 UserTypeAdapter 來接管 User 類的序列化和反序列化過程

這裏設定當 User 類序列化時 Json 中的Key值都是大寫字母開頭，反序列化時支持「name」和「Name」兩種不一樣的 Json 風格json

public class UserTypeAdapter extends TypeAdapter<User> {

    /**
     * 序列化
     */
    @Override
    public void write(JsonWriter jsonWriter, User user) throws IOException {
        //流式序列化成對象開始
        jsonWriter.beginObject();
        //將Json的Key值都指定爲大寫字母開頭
        jsonWriter.name("Name").value(user.getName());
        jsonWriter.name("Age").value(user.getAge());
        jsonWriter.name("Sex").value(user.isSex());
        //流式序列化結束
        jsonWriter.endObject();
    }

    /**
     * 反序列化
     */
    @Override
    public User read(JsonReader jsonReader) throws IOException {
        User user = new User();
        //流式反序列化開始
        jsonReader.beginObject();
        while (jsonReader.hasNext()) {
            switch (jsonReader.nextName()) {
                //首字母大小寫均合法
                case "userName":
                case "name":
                case "Name":
                    user.setName(jsonReader.nextString());
                    break;
                case "age":
                    user.setAge(jsonReader.nextInt());
                    break;
                case "sex":
                    user.setSex(jsonReader.nextBoolean());
                    break;
            }

        }
        //流式反序列化結束
        jsonReader.endObject();
        return user;
    }

}
  • 2.7.2 序列化和反序列化

2.8 JsonSerializer序列化接口

/**
 * 序列化過程
 */
@SuppressLint("LongLogTag")
private void toJsonSerializer() {
    Gson gson = new GsonBuilder().registerTypeAdapter(User.class, new JsonSerializer<User>() {
        @Override
        public JsonElement serialize(User user, Type type, JsonSerializationContext jsonSerializationContext) {
            JsonObject jsonObject = new JsonObject();
            jsonObject.addProperty("NameHi", user.getName());
            jsonObject.addProperty("Sex", user.isSex());
            jsonObject.addProperty("Age", user.getAge());
            return jsonObject;
        }
    }).create();
    User user = new User("leavesC", 24, true);
    String s = gson.toJson(user);
    Log.e(TAG,s);
}

2.9 JsonDeserializer反序列化接口

/**
 * 反序列化過程
 */
private void toJsonDeserializer() {
    Gson gson = new GsonBuilder().registerTypeAdapter(User.class, new JsonDeserializer<User>() {
        @Override
        public User deserialize(JsonElement jsonElement, Type type, JsonDeserializationContext jsonDeserializationContext) throws JsonParseException {
            JsonObject jsonObject = jsonElement.getAsJsonObject();
            String name = null;
            //同時支持 userName 和 name 兩種狀況
            if (jsonObject.has("userName")) {
                name = jsonObject.get("userName").getAsString();
            } else if (jsonObject.has("name")) {
                name = jsonObject.get("name").getAsString();
            }
            int age = jsonObject.get("age").getAsInt();
            boolean sex = jsonObject.get("sex").getAsBoolean();
            return new User(name, age, sex);
        }
    }).create();
    String json = "{\"userName\":\"leavesC\",\"sex\":true,\"age\":24}";
    User user = gson.fromJson(json, User.class);
    System.out.println();
    System.out.println(user);

    json = "{\"name\":\"leavesC\",\"sex\":true,\"age\":24}";
    user = gson.fromJson(json, User.class);
    System.out.println();
    System.out.println(user);
}

3.0 將請求網絡日誌按照必定格式展現

private static final String LINE_SEPARATOR = System.getProperty("line.separator");
public static void printJson(String tag, String msg) {
    String message;
    try {
        if (msg.startsWith("{")) {
            JSONObject jsonObject = new JSONObject(msg);
            //最重要的方法，就一行，返回格式化的json字符串，其中的數字4是縮進字符數
            message = jsonObject.toString(4);
        } else if (msg.startsWith("[")) {
            JSONArray jsonArray = new JSONArray(msg);
            message = jsonArray.toString(4);
        } else {
            message = msg;
        }
    } catch (JSONException e) {
        message = msg;
    }
    if(isGoodJson(message)){
        printLine(tag, true);
        String[] lines = message.split(LINE_SEPARATOR);
        for (String line : lines) {
            Log.e(tag, "║ " + line);
        }
        printLine(tag, false);
    }
}

private static void printLine(String tag, boolean isTop) {
    if (isTop) {
        Log.e(tag, "Http---------------------");
    } else {
        Log.e(tag, "Http---------------------");
    }
}

private static boolean isGoodJson(String json) {
    if (TextUtils.isEmpty(json)) {
        return false;
    }
    try {
        new JsonParser().parse(json);
        return true;
    } catch (JsonSyntaxException e) {
        return false;
    } catch (JsonParseException e) {
        return false;
    }
}
  • 如圖，日誌格式以下所示：
  • image
關於個人博客
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程