Comment convertir une chaîne JSON en Map <String, String> avec Jackson JSON

J'essaye de faire quelque chose comme ça mais ça ne marche pas:

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

propertyMap = JacksonUtils.fromJSON(properties, Map.class);

Mais l'IDE dit:

Affectation non cochée Map to Map<String,String>

Quelle est la bonne façon de procéder? J'utilise uniquement Jackson parce que c'est ce qui est déjà disponible dans le projet, existe-t-il un moyen Java natif de convertir vers / depuis JSON?

En PHP, je voudrais simplement json_decode($str)et je récupérerais un tableau. J'ai besoin fondamentalement de la même chose ici.

J'ai le code suivant:

public void testJackson() throws IOException {  
    ObjectMapper mapper = new ObjectMapper(); 
    File from = new File("albumnList.txt"); 
    TypeReference<HashMap<String,Object>> typeRef 
            = new TypeReference<HashMap<String,Object>>() {};

    HashMap<String,Object> o = mapper.readValue(from, typeRef); 
    System.out.println("Got " + o); 
}   

Il lit à partir d'un fichier, mais mapper.readValue()accepte également un InputStreamet vous pouvez obtenir un à InputStreampartir d'une chaîne en utilisant ce qui suit:

new ByteArrayInputStream(astring.getBytes("UTF-8")); 

Il y a un peu plus d'explications sur le mappeur sur mon blog .

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).

Le moyen le plus simple d'utiliser directement Jackson 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.

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

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

Notez que cette readerinstance 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 résoudra votre problème.

Ce qui suit fonctionne pour moi:

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

où getJsonAsMapest défini comme ceci:

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 cela va échouer si vous avez des objets enfants dans votre JSON (parce qu'ils ne sont pas un String, ils sont une autre HashMap), mais ne fonctionnera que si votre JSON est une liste de valeurs clé des 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é 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 :)

je voulais juste donner une réponse à Kotlin

val propertyMap = objectMapper.readValue<Map<String,String>>(properties, object : TypeReference<Map<String, String>>() {})