Comment convertir une chaîne JSON en une carte avec Jackson JSON

Essayez TypeFactory. Voici le code pour Jackson JSON (2.8.4).

Map<String, String> result;
ObjectMapper mapper;
TypeFactory factory;
MapType type;

factory = TypeFactory.defaultInstance();
type    = factory.constructMapType(HashMap.class, String.class, String.class);
mapper  = new ObjectMapper();
result  = mapper.readValue(data, type);

Voici le code d'une ancienne version de Jackson JSON.

Map<String, String> result = new ObjectMapper().readValue(
    data, TypeFactory.mapType(HashMap.class, String.class, String.class));

L'avertissement que vous obtenez est fait par le compilateur, pas par la bibliothèque (ou la méthode utilitaire).

La façon la plus simple d'utiliser Jackson directement serait:

HashMap<String,Object> props;

// src is a File, InputStream, String or such
props = new ObjectMapper().readValue(src, new TypeReference<HashMap<String,Object>>() {});
// or:
props = (HashMap<String,Object>) new ObjectMapper().readValue(src, HashMap.class);
// or even just:
@SuppressWarnings("unchecked") // suppresses typed/untype mismatch warnings, which is harmless
props = new ObjectMapper().readValue(src, HashMap.class);

La méthode utilitaire que vous appelez fait probablement quelque chose de similaire à ceci.

ObjectReader reader = new ObjectMapper().readerFor(Map.class);

Map<String, String> map = reader.readValue("{\"foo\":\"val\"}");

Notez que reader instance est Thread Safe.

Conversion de chaîne en carte JSON:

Map<String,String> map = new HashMap<String,String>();

ObjectMapper mapper = new ObjectMapper();

map = mapper.readValue(string, HashMap.class);

JavaType javaType = objectMapper.getTypeFactory().constructParameterizedType(Map.class, Key.class, Value.class);
Map<Key, Value> map=objectMapper.readValue(jsonStr, javaType);

Je pense que cela va résoudre votre problème.

Ce qui suit fonctionne pour moi:

Map<String, String> propertyMap = getJsonAsMap(json);

Où getJsonAsMap est défini comme suit:

public HashMap<String, String> getJsonAsMap(String json)
{
    try
    {
        ObjectMapper mapper = new ObjectMapper();
        TypeReference<Map<String,String>> typeRef = new TypeReference<Map<String,String>>() {};
        HashMap<String, String> result = mapper.readValue(json, typeRef);

        return result;
    }
    catch (Exception e)
    {
        throw new RuntimeException("Couldnt parse json:" + json, e);
    }
}

Notez que ce échouera Si vous avez des objets enfants dans votre json (parce qu'ils ne sont pas un String, ils sont un autre HashMap), mais fonctionnera si votre json est une liste de valeurs clés de propriétés comme ceci:

{
    "client_id": "my super id",
    "exp": 1481918304,
    "iat": "1450382274",
    "url": "http://www.example.com"
}

Utilisation du Gson de Google

Pourquoi ne pas utiliser le Gson de Google comme mentionné dans ici ?

Très simple et a fait le travail pour moi:

HashMap<String,String> map = new Gson().fromJson( yourJsonString, new TypeToken<HashMap<String, String>>(){}.getType());

Voici la solution générique à ce problème.

public static <K extends Object, V extends Object> Map<K, V> getJsonAsMap(String json, K key, V value) {
    try {
      ObjectMapper mapper = new ObjectMapper();
      TypeReference<Map<K, V>> typeRef = new TypeReference<Map<K, V>>() {
      };
      return mapper.readValue(json, typeRef);
    } catch (Exception e) {
      throw new RuntimeException("Couldnt parse json:" + json, e);
    }
  }

J'espère qu'un jour quelqu'un penserait à créer une méthode util pour convertir en N'importe quel type de carte clé/valeur d'où cette réponse:)