Jak mogę przekonwertować JSON na Hashmapę za pomocą Gson?

Ten kod działa:

Gson gson = new Gson(); 
String json = "{\"k1\":\"v1\",\"k2\":\"v2\"}";
Map<String,Object> map = new HashMap<String,Object>();
map = (Map<String,Object>) gson.fromJson(json, map.getClass());

Wiem, że to dość stare pytanie, ale szukałem rozwiązania, aby generycznie deserializować zagnieżdżony JSON do Map<String, Object> i nic nie znalazłem.

Sposób, w jaki mój deserializer yaml działa, domyślnie ustawia obiekty JSON na Map<String, Object>, gdy nie podasz typu, ale gson tego nie robi. Na szczęście można to osiągnąć za pomocą niestandardowego deserializera.

Użyłem następującego deserializera, aby naturalnie deserializować cokolwiek, domyślnie JsonObject s do Map<String, Object> i JsonArray s do Object[]s, gdzie wszystkie dzieci są podobnie deserializowane.

private static class NaturalDeserializer implements JsonDeserializer<Object> {
  public Object deserialize(JsonElement json, Type typeOfT, 
      JsonDeserializationContext context) {
    if(json.isJsonNull()) return null;
    else if(json.isJsonPrimitive()) return handlePrimitive(json.getAsJsonPrimitive());
    else if(json.isJsonArray()) return handleArray(json.getAsJsonArray(), context);
    else return handleObject(json.getAsJsonObject(), context);
  }
  private Object handlePrimitive(JsonPrimitive json) {
    if(json.isBoolean())
      return json.getAsBoolean();
    else if(json.isString())
      return json.getAsString();
    else {
      BigDecimal bigDec = json.getAsBigDecimal();
      // Find out if it is an int type
      try {
        bigDec.toBigIntegerExact();
        try { return bigDec.intValueExact(); }
        catch(ArithmeticException e) {}
        return bigDec.longValue();
      } catch(ArithmeticException e) {}
      // Just return it as a double
      return bigDec.doubleValue();
    }
  }
  private Object handleArray(JsonArray json, JsonDeserializationContext context) {
    Object[] array = new Object[json.size()];
    for(int i = 0; i < array.length; i++)
      array[i] = context.deserialize(json.get(i), Object.class);
    return array;
  }
  private Object handleObject(JsonObject json, JsonDeserializationContext context) {
    Map<String, Object> map = new HashMap<String, Object>();
    for(Map.Entry<String, JsonElement> entry : json.entrySet())
      map.put(entry.getKey(), context.deserialize(entry.getValue(), Object.class));
    return map;
  }
}

Bałagan wewnątrz metody handlePrimitive jest po to, aby upewnić się, że zawsze masz tylko podwójne lub Integer lub długi, i prawdopodobnie może być lepiej, lub przynajmniej uproszczone, jeśli jesteś w porządku z bigdecimals, co uważam, że jest domyślne.

Możesz zarejestrować Ten adapter w następujący sposób:

GsonBuilder gsonBuilder = new GsonBuilder();
gsonBuilder.registerTypeAdapter(Object.class, new NaturalDeserializer());
Gson gson = gsonBuilder.create();

A potem nazwij to tak:

Object natural = gson.fromJson(source, Object.class);

Nie jestem pewien, dlaczego nie jest to domyślne zachowanie w gson, ponieważ jest w większości innych półstrukturalne biblioteki serializacyjne...

Aktualizacja dla nowego GSON lib:
Możesz teraz parsować zagnieżdżony Json, aby mapować bezpośrednio, ale powinieneś być świadomy, jeśli spróbujesz parsować Json do typu Map<String, Object>: spowoduje to podniesienie wyjątku. Aby to naprawić, po prostu zadeklaruj wynik jako typ LinkedTreeMap. Przykład poniżej:

String nestedJSON = "{"id":"1","message":"web_didload","content":{"success":1}};
Gson gson = new Gson();
LinkedTreeMap result = gson.fromJson(nestedJSON , LinkedTreeMap.class);

Z GSON 2.7 google ' a (prawdopodobnie wcześniejsze wersje też, ale testowałem z obecną wersją 2.7) jest to tak proste jak:

Map map = gson.fromJson(jsonString, Map.class);

Który zwraca Map typu com.google.gson.internal.LinkedTreeMap i działa rekurencyjnie na zagnieżdżonych obiektach, tablicach itp.

Uruchomiłem przykład OP w ten sposób (po prostu zastąpiłem double-z pojedynczymi cudzysłowami i usunąłem białe znaki):

String jsonString = "{'header': {'alerts': [{'AlertID': '2', 'TSExpires': null, 'Target': '1', 'Text': 'woot', 'Type': '1'}, {'AlertID': '3', 'TSExpires': null, 'Target': '1', 'Text': 'woot', 'Type': '1'}], 'session': '0bc8d0835f93ac3ebbf11560b2c5be9a'}, 'result': '4be26bc400d3c'}";
Map map = gson.fromJson(jsonString, Map.class);
System.out.println(map.getClass().toString());
System.out.println(map);

I otrzymaliśmy następujące wyjście:

class com.google.gson.internal.LinkedTreeMap
{header={alerts=[{AlertID=2, TSExpires=null, Target=1, Text=woot, Type=1}, {AlertID=3, TSExpires=null, Target=1, Text=woot, Type=1}], session=0bc8d0835f93ac3ebbf11560b2c5be9a}, result=4be26bc400d3c}

Miałem dokładnie to samo pytanie i wylądowałem tutaj. Miałem inne podejście, które wydaje się dużo prostsze (może nowsze wersje gson?).

    Gson gson = new Gson();
    Map jsonObject = (Map) gson.fromJson(data, Object.class);

Z następującym json

{
  "map-00": {
    "array-00": [
      "entry-00",
      "entry-01"
     ],
     "value": "entry-02"
   }
}

Następujące

    Map map00 = (Map) jsonObject.get("map-00");
    List array00 = (List) map00.get("array-00");
    String value = (String) map00.get("value");
    for (int i = 0; i < array00.size(); i++) {
        System.out.println("map-00.array-00[" + i + "]= " + array00.get(i));
    }
    System.out.println("map-00.value = " + value);

Wyjścia

map-00.array-00[0]= entry-00
map-00.array-00[1]= entry-01
map-00.value = entry-02

Możesz dynamicznie sprawdzać za pomocą instanceof podczas nawigacji po jsonObject. Coś jak

Map json = gson.fromJson(data, Object.class);
if(json.get("field") instanceof Map) {
  Map field = (Map)json.get("field");
} else if (json.get("field") instanceof List) {
  List field = (List)json.get("field");
} ...

U mnie działa, więc musi działać u ciebie; -)

Spróbuj tego, to zadziała. Używałem go do Hashtable.

public static Hashtable<Integer, KioskStatusResource> parseModifued(String json) {
    JsonObject object = (JsonObject) new com.google.gson.JsonParser().parse(json);
    Set<Map.Entry<String, JsonElement>> set = object.entrySet();
    Iterator<Map.Entry<String, JsonElement>> iterator = set.iterator();

    Hashtable<Integer, KioskStatusResource> map = new Hashtable<Integer, KioskStatusResource>();

    while (iterator.hasNext()) {
        Map.Entry<String, JsonElement> entry = iterator.next();

        Integer key = Integer.parseInt(entry.getKey());
        KioskStatusResource value = new Gson().fromJson(entry.getValue(), KioskStatusResource.class);

        if (value != null) {
            map.put(key, value);
        }

    }
    return map;
}

Zastąp KioskStatusResource do klasy iLiczba całkowita do twojej klasy.

Oto co używam:

public static HashMap<String, Object> parse(String json) {
    JsonObject object = (JsonObject) parser.parse(json);
    Set<Map.Entry<String, JsonElement>> set = object.entrySet();
    Iterator<Map.Entry<String, JsonElement>> iterator = set.iterator();
    HashMap<String, Object> map = new HashMap<String, Object>();
    while (iterator.hasNext()) {
        Map.Entry<String, JsonElement> entry = iterator.next();
        String key = entry.getKey();
        JsonElement value = entry.getValue();
        if (!value.isJsonPrimitive()) {
            map.put(key, parse(value.toString()));
        } else {
            map.put(key, value.getAsString());
        }
    }
    return map;
}

Poniżej jest obsługiwana od gson 2.8.0

public static Type getMapType(Class keyType, Class valueType){
    return TypeToken.getParameterized(HashMap.class, keyType, valueType).getType();
}

public static  <K,V> HashMap<K,V> fromMap(String json, Class<K> keyType, Class<V> valueType){
    return gson.fromJson(json, getMapType(keyType,valueType));
}

Mam przezwyciężyć podobny problem z niestandardowym JsonDeSerializer. Próbowałem zrobić to trochę ogólne, ale nadal nie wystarczająco. Jest to jednak rozwiązanie, które pasuje do moich potrzeb.

Przede wszystkim musisz zaimplementować nowy JsonDeserializer dla obiektów Map.

public class MapDeserializer<T, U> implements JsonDeserializer<Map<T, U>>

I metoda deserialize będzie wyglądać podobnie do tego:

public Map<T, U> deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
        throws JsonParseException {

        if (!json.isJsonObject()) {
            return null;
        }

        JsonObject jsonObject = json.getAsJsonObject();
        Set<Entry<String, JsonElement>> jsonEntrySet = jsonObject.entrySet();
        Map<T, U> deserializedMap = new HashMap<T, U>();

        for (Entry<java.lang.String, JsonElement> entry : jsonEntrySet) {
            try {
                U value = context.deserialize(entry.getValue(), getMyType());
                deserializedMap.put((T) entry.getKey(), value);
            } catch (Exception ex) {
                logger.info("Could not deserialize map.", ex);
            }
        }

        return deserializedMap;
    }

Plusem tego rozwiązania jest to, że klucz mojej mapy jest zawsze typu "String". Jednak przez chaning niektóre rzeczy ktoś może zrobić to ogólne. Dodatkowo, muszę powiedzieć, że Klasa value powinna być przekazywana w konstruktorze. Tak więc metoda getMyType() w moim kodzie zwraca typ wartości mapy, który został przekazany w konstruktorze.

Możesz odwołać się do tego posta Jak napisać niestandardowy deserializer JSON dla Gson? aby dowiedzieć się więcej o niestandardowych deserializerach.

Oto jednolinijkowy, który to zrobi:

HashMap<String, Object> myMap =
   gson.fromJson(yourJson, new TypeToken<HashMap<String, Object>>(){}.getType());

Możesz użyć tej klasy zamiast:) (obsługuje nawet listy , zagnieżdżone listy i json)

public class Utility {

    public static Map<String, Object> jsonToMap(Object json) throws JSONException {

        if(json instanceof JSONObject)
            return _jsonToMap_((JSONObject)json) ;

        else if (json instanceof String)
        {
            JSONObject jsonObject = new JSONObject((String)json) ;
            return _jsonToMap_(jsonObject) ;
        }
        return null ;
    }


   private static Map<String, Object> _jsonToMap_(JSONObject json) throws JSONException {
        Map<String, Object> retMap = new HashMap<String, Object>();

        if(json != JSONObject.NULL) {
            retMap = toMap(json);
        }
        return retMap;
    }


    private static Map<String, Object> toMap(JSONObject object) throws JSONException {
        Map<String, Object> map = new HashMap<String, Object>();

        Iterator<String> keysItr = object.keys();
        while(keysItr.hasNext()) {
            String key = keysItr.next();
            Object value = object.get(key);

            if(value instanceof JSONArray) {
                value = toList((JSONArray) value);
            }

            else if(value instanceof JSONObject) {
                value = toMap((JSONObject) value);
            }
            map.put(key, value);
        }
        return map;
    }


    public static List<Object> toList(JSONArray array) throws JSONException {
        List<Object> list = new ArrayList<Object>();
        for(int i = 0; i < array.length(); i++) {
            Object value = array.get(i);
            if(value instanceof JSONArray) {
                value = toList((JSONArray) value);
            }

            else if(value instanceof JSONObject) {
                value = toMap((JSONObject) value);
            }
            list.add(value);
        }
        return list;
    }
}

Aby przekonwertować JSON string na hashmap Użyj tego :

HashMap<String, Object> hashMap = new HashMap<>(Utility.jsonToMap(response)) ;

To jest bardziej dodatek do Odpowiedzi Kevina Dolana niż kompletna odpowiedź, ale miałem problem z wyodrębnieniem typu z liczby. To jest moje rozwiązanie:

private Object handlePrimitive(JsonPrimitive json) {
  if(json.isBoolean()) {
    return json.getAsBoolean();
  } else if(json.isString())
    return json.getAsString();
  }

  Number num = element.getAsNumber();

  if(num instanceof Integer){
    map.put(fieldName, num.intValue());
  } else if(num instanceof Long){
    map.put(fieldName, num.longValue());
  } else if(num instanceof Float){
    map.put(fieldName, num.floatValue());
  } else {    // Double
     map.put(fieldName, num.doubleValue());
  }
}

 HashMap<String, String> jsonToMap(String JsonDetectionString) throws JSONException {

    HashMap<String, String> map = new HashMap<String, String>();
    Gson gson = new Gson();

    map = (HashMap<String, String>) gson.fromJson(JsonDetectionString, map.getClass());

    return map;

}

JSONObject zazwyczaj używa HashMap wewnętrznie do przechowywania danych. Możesz więc użyć go jako mapy w swoim kodzie.

Przykład,

JSONObject obj = JSONObject.fromObject(strRepresentation);
Iterator i = obj.entrySet().iterator();
while (i.hasNext()) {
   Map.Entry e = (Map.Entry)i.next();
   System.out.println("Key: " + e.getKey());
   System.out.println("Value: " + e.getValue());
}

Użyłem tego kodu:

Gson gson = new Gson();
HashMap<String, Object> fields = gson.fromJson(json, HashMap.class);