Como converter uma string JSON em um mapa <String, String> com Jackson JSON

Estou tentando fazer algo assim, mas não funciona:

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

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

Mas o IDE diz:

Atribuição não verificada Map to Map<String,String>

Qual é o caminho certo para fazer isso? Estou usando apenas Jackson, porque é isso que já está disponível no projeto. Existe uma maneira nativa de Java de converter de / para JSON?

No PHP, eu simplesmente json_decode($str)e recuperaria uma matriz. Eu preciso basicamente da mesma coisa aqui.

Eu tenho o seguinte 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); 
}   

Ele está lendo um arquivo, mas mapper.readValue()também aceita um InputStreame você pode obter um InputStreamde uma string usando o seguinte:

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

Há um pouco mais de explicação sobre o mapeador no meu blog .

Tente TypeFactory. Aqui está o 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);

Aqui está o código para uma versão mais antiga do Jackson JSON.

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

O aviso obtido é feito pelo compilador, não pela biblioteca (ou método utilitário).

A maneira mais simples de usar o Jackson diretamente seria:

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

O método utilitário que você chama provavelmente faz algo semelhante a isso.

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

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

Observe que a readerinstância é segura para threads.

Convertendo de String para 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);

Eu acho que isso vai resolver o seu problema.

O seguinte funciona para mim:

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

Onde getJsonAsMap é definido assim:

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

Note que este irá falhar se você tem objetos filho em sua json (porque eles não são um String, eles são outra HashMap), mas vai funcionar se o JSON é uma lista de valores-chave de imóveis como assim:

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

Usando o Gson do Google

Por que não usar o Gson do Google, como mencionado aqui ?

Muito direto e fez o trabalho para mim:

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

Aqui está a solução genérica para esse 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 algum dia alguém pense em criar um método util para converter para qualquer tipo de mapa de chave / valor, portanto, esta resposta :)

só queria dar uma resposta Kotlin

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