Cómo convertir una cadena JSON en un Mapa <Cadena, Cadena> con Jackson JSON

Estoy tratando de hacer algo como esto pero no funciona:

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

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

Pero el IDE dice:

Asignación no verificada Map to Map<String,String>

¿Cuál es la forma correcta de hacer esto? Solo estoy usando Jackson porque eso es lo que ya está disponible en el proyecto, ¿hay una forma nativa de Java de convertir a / desde JSON?

En PHP simplemente json_decode($str)lo haría y obtendría una matriz. Necesito básicamente lo mismo aquí.

Tengo el siguiente código:

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); 
}   

Está leyendo desde un archivo, pero mapper.readValue()también aceptará un InputStreamy puede obtener uno InputStreamde una cadena usando lo siguiente:

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

Hay un poco más de explicación sobre el mapeador en mi blog .

Tratar TypeFactory. Aquí está el código para 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);

Aquí está el código para una versión anterior de Jackson JSON.

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

La advertencia que obtienes se realiza por compilador, no por biblioteca (o método de utilidad).

La forma más sencilla de usar Jackson directamente sería:

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

El método de utilidad que llamas probablemente solo hace algo similar a esto.

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

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

Tenga en cuenta que la readerinstancia es segura para subprocesos.

Conversión de Cadena a Mapa 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);

Creo que esto resolverá tu problema.

Lo siguiente funciona para mí:

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

donde getJsonAsMapse define así:

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);
    }
}

Tenga en cuenta que esto va a fallar si tiene objetos secundarios en su JSON (porque no son una String, son otro HashMap), pero funcionará si su JSON es una lista de valores clave de las propiedades, así:

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

Usando el Gson de Google

¿Por qué no usar Google's Gson como se menciona aquí ?

Muy sencillo e hizo el trabajo por mí:

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

Aquí está la solución genérica a este problema.

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);
    }
  }

Espero que algún día alguien piense crear un método util para convertir a cualquier tipo de clave / valor del mapa, de ahí esta respuesta :)

solo quería dar una respuesta a Kotlin

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