根据json的key获取到对应的value

朱雀 2023-03-13 02:20 324阅读 0赞

项目中偶尔会用到解析json，然后获取某个key的值的问题，这个有两个办法，一个是通过json创建一个对象出来，然后通过json转对象，然后通过对象获取对应的value，第二个是通过JsonObject获取对应key的value，但是只能从顶级一层一层的获取你想要的值。  
如果json简单，两种方法都可以。如果json复杂一点，两种方法都挺麻烦的，所以就打算自己写一个工具类，通过传进去一个key就能直接获取到value了。  
但是有个问题就是如果key有多个重复的话就只能获取到第一个key了，不过这个问题也可以解决，先获取重复key外层的key对应的value，然后获取到的json再多次获取就可以了。  
talk is cheap，show you my code.  
json解析用的是fastjson

public class JsonUtil { 
    
        /** * json字符串 转对象 * @param jsonString * @param <T> * @return */
        public static <T> T toObject(String jsonString , Class<T> clz){ 
            if (StringUtils.isNotEmpty(jsonString)) { 
                return JSON.parseObject(jsonString , clz);
            }
            return null;
        }
    
        /** * jsonString 转list * @param jsonString * @param clz * @param <T> * @return */
        public static <T> List<T> toList(String jsonString , Class<T> clz){ 
            if (StringUtils.isNotEmpty(jsonString)) { 
                return JSON.parseArray(jsonString, clz);
            }
            return Collections.emptyList();
        }
    
        /** * 对象转json字符串 * @param object * @return */
        public static String toJsonString(Object object){ 
            if (object != null) { 
                return JSON.toJSONString(object);
            }
            return null;
        }
    
        /** * 根据json 中的可以 获取对应value，只会获取第一个被匹配到的值 * @param json json 字符串 * @param key * @return 返回结果类型可能是 JSONObject、String、JSONArray */
        public static Object getJsonValue(String json , String key){ 
            if (StringUtils.isNotEmpty(json) && StringUtils.isNotEmpty(key)) { 
                Object object = JSON.parse(json);
                if (object != null) { 
                    if (object instanceof JSONObject) { 
                        return getJsonValue((JSONObject) object, key);
                    }else if (object instanceof  JSONArray){ 
                        return getJsonValue((JSONArray) object, key);
                    }
                }
                return object;
            }
            throw new IllegalArgumentException("param json or key cannot be empty.");
        }
    
    
        /** * 根据json 中的可以 获取对应value，只会获取第一个被匹配到的值 * @param jsonObject * @param key * @return 返回结果类型可能是 JSONObject、String、JSONArray */
        public static Object getJsonValue(JSONObject jsonObject , String key) { 
            if (jsonObject != null && StringUtils.isNotEmpty(key)) { 
                for (Map.Entry<String, Object> entry : jsonObject.entrySet()) { 
                    String entryKey = entry.getKey();
                    Object value = entry.getValue();
                    if (key.equals(entryKey)) { 
                        return value;
                    } else { 
                        if (value != null) { 
                            String s = value.toString();
                            if (StringUtils.isNotEmpty(s)) { 
                                Object jsonValue = getJsonValue(value, key);
                                if (jsonValue != null) { 
                                    return jsonValue;
                                }
                            }
                        }
                    }
                }
                return null;
            }
            throw new IllegalArgumentException("param jsonObject or key cannot by empty.");
        }
    
        public static Object getJsonValue(Object object , String key){ 
            if (object != null && StringUtils.isNotEmpty(key)) { 
                if (object instanceof JSONObject) { 
                    return getJsonValue((JSONObject) object, key);
                }else if (object instanceof JSONArray){ 
                    return getJsonValue((JSONArray) object, key);
                }
            }
            return null;
        }
    
        public static Object getJsonValue(JSONArray jsonArray , String key) { 
            if (jsonArray != null && StringUtils.isNotEmpty(key)) { 
                for (Object next : jsonArray) { 
                    if (next != null) { 
                        return getJsonValue(next, key);
                    }
                }
            }
            return null;
        }
    }

测试：  
json 如下：

{ 
       "results" : [
          { 
             "access_points" : [],
             "address_components" : [
                { 
                   "long_name" : "1600",
                   "short_name" : "1600",
                   "types" : [ "street_number" ]
                },
                { 
                   "long_name" : "Amphitheatre Parkway",
                   "short_name" : "Amphitheatre Pkwy",
                   "types" : [ "route" ]
                },
                { 
                   "long_name" : "Mountain View",
                   "short_name" : "Mountain View",
                   "types" : [ "locality", "political" ]
                },
                { 
                   "long_name" : "Santa Clara County",
                   "short_name" : "Santa Clara County",
                   "types" : [ "administrative_area_level_2", "political" ]
                },
                { 
                   "long_name" : "California",
                   "short_name" : "CA",
                   "types" : [ "administrative_area_level_1", "political" ]
                },
                { 
                   "long_name" : "美国",
                   "short_name" : "US",
                   "types" : [ "country", "political" ]
                },
                { 
                   "long_name" : "94043",
                   "short_name" : "94043",
                   "types" : [ "postal_code" ]
                }
             ],
             "formatted_address" : "1600 Amphitheatre Pkwy, Mountain View, CA 94043美国",
             "geometry" : { 
                "location" : { 
                   "lat" : 37.4223097,
                   "lng" : -122.0846245
                },
                "location_type" : "ROOFTOP",
                "viewport" : { 
                   "northeast" : { 
                      "lat" : 37.4236586802915,
                      "lng" : -122.0832755197085
                   },
                   "southwest" : { 
                      "lat" : 37.4209607197085,
                      "lng" : -122.0859734802915
                   }
                }
             },
             "place_id" : "ChIJtYuu0V25j4ARwu5e4wwRYgE",
             "plus_code" : { 
                "compound_code" : "CWC8+W5 美国 California, 山景城",
                "global_code" : "849VCWC8+W5"
             },
             "types" : [ "street_address" ]
          }
       ],
       "status" : "OK"
    }

Object content = JsonUtil.getJsonValue(json, "northeast");

结果：

{ "lng":-122.0832755197085,"lat":37.4236586802915}

通过fastjson源码可以看到，json解析用的是map，所以获取的时候也是根据map的特性来获取的。  
可以看到能够获取到对应key的value，但是前面也说了，重复的key的话只能获取到第一个value。  
如果用对象的或者一层一层获取的话不会存在这个问题。

能力有限，水平一般，如果有更好的方法请评论告诉我。