關於JSONObject的性能問題

現有一段代碼：

private JSONObject override(User user, UserVO vo) {
    String json = JSON.toJSONString(vo);
    JSONObject o = JSON.parseObject(json);
    JSONObject name = new JSONObject();
    if (StringUtils.isNotBlank(user.getName())) {
        name = JSON.parseObject(user.getName());
        o.put("name", name);
    }
}

這段代碼就是將一個VO對象轉JSON字符串之后再轉為對象，然后將User對象中的name屬性轉為對象，最后通過put方法獲取到這個它。

 

其實這個邏輯是沒問題的，不過我們可以嘗試測試它的運行速度，

這是一段簡單的測試代碼：

public static void main(String[] args) {
    User user = new User();
    long start = System.currentTimeMillis();
    String json = JSON.toJSONString(user);
    JSONObject o = JSON.parseObject(json);
    long end = System.currentTimeMillis();
    System.out.println("用時："+(end - start) + "ms");
}

為了避免測試偶然性，采用多次測試：

第一次：331ms

第二次：348ms

第三次：367ms

第四次：328ms

第五次：307ms

第六次：383ms

可以發現，就這樣一個簡單的轉換，竟然用時在300ms以上。

點進 parseObject() 查看原因：

public static JSONObject parseObject(String text) {
        Object obj = parse(text);
        if (obj instanceof JSONObject) {
            return (JSONObject)obj;
        } else {
            try {
                return (JSONObject)toJSON(obj);
            } catch (RuntimeException var3) {
                throw new JSONException("can not cast to JSONObject.", var3);
            }
        }
}

方法內第一行開始解析傳入的參數，再往里面點，發現僅僅一步解析，就走了很多方法。

然后是toJSON()：

    public static Object toJSON(Object javaObject, SerializeConfig config) {
        if (javaObject == null) {
            return null;
        } else if (javaObject instanceof JSON) {
            return javaObject;
        } else {
            JSONObject json;
            int len;
            if (javaObject instanceof Map) {
                Map<Object, Object> map = (Map)javaObject;
                len = map.size();
                Object innerMap;
                if (map instanceof LinkedHashMap) {
                    innerMap = new LinkedHashMap(len);
                } else if (map instanceof TreeMap) {
                    innerMap = new TreeMap();
                } else {
                    innerMap = new HashMap(len);
                }

                json = new JSONObject((Map)innerMap);
                Iterator var24 = map.entrySet().iterator();

                while(var24.hasNext()) {
                    Entry<Object, Object> entry = (Entry)var24.next();
                    Object key = entry.getKey();
                    String jsonKey = TypeUtils.castToString(key);
                    Object jsonValue = toJSON(entry.getValue(), config);
                    json.put(jsonKey, jsonValue);
                }

                return json;
            } else {
                Object item;
                if (javaObject instanceof Collection) {
                    Collection<Object> collection = (Collection)javaObject;
                    JSONArray array = new JSONArray(collection.size());
                    Iterator var19 = collection.iterator();

                    while(var19.hasNext()) {
                        Object item = var19.next();
                        item = toJSON(item, config);
                        array.add(item);
                    }

                    return array;
                } else if (javaObject instanceof JSONSerializable) {
                    String json = toJSONString(javaObject);
                    return parse(json);
                } else {
                    Class<?> clazz = javaObject.getClass();
                    if (clazz.isEnum()) {
                        return ((Enum)javaObject).name();
                    } else if (clazz.isArray()) {
                        len = Array.getLength(javaObject);
                        JSONArray array = new JSONArray(len);

                        for(int i = 0; i < len; ++i) {
                            item = Array.get(javaObject, i);
                            Object jsonValue = toJSON(item);
                            array.add(jsonValue);
                        }

                        return array;
                    } else if (ParserConfig.isPrimitive2(clazz)) {
                        return javaObject;
                    } else {
                        ObjectSerializer serializer = config.getObjectWriter(clazz);
                        if (serializer instanceof JavaBeanSerializer) {
                            JavaBeanSerializer javaBeanSerializer = (JavaBeanSerializer)serializer;
                            json = new JSONObject();

                            try {
                                Map<String, Object> values = javaBeanSerializer.getFieldValuesMap(javaObject);
                                Iterator var7 = values.entrySet().iterator();

                                while(var7.hasNext()) {
                                    Entry<String, Object> entry = (Entry)var7.next();
                                    json.put((String)entry.getKey(), toJSON(entry.getValue(), config));
                                }

                                return json;
                            } catch (Exception var11) {
                                throw new JSONException("toJSON error", var11);
                            }
                        } else {
                            String text = toJSONString(javaObject);
                            return parse(text);
                        }
                    }
                }
            }
        }
    }

可以發現里面嵌套了4層if-else語句，邏輯十分復雜，甚至還有遞歸方法。

 

所以 parseObject() 方法的執行效率很低，如果出現高並發的情況，那很可能直接崩潰。