You should create specific Map type and provide it into deserialization process:

TypeFactory typeFactory = mapper.getTypeFactory();
MapType mapType = typeFactory.constructMapType(HashMap.class, String.class, Theme.class);
HashMap<String, Theme> map = mapper.readValue(json, mapType);

The solution that worked for me was using custom deserialization, @JsonDeserialize annotation & JsonDeserializer interface, in order to achieve the desired results.

Below is the solution:

public class Request {

  private String method;
  private String resource;
  @JsonDeserialize(using = BodyDeserializer.class)
  private final Map<String, Object> body;
  private final Map<String, String> headers;
  private final Map<String, String[]> parameters;

  public Request() {
    this.body = new HashMap();
    this.headers = new HashMap();
    this.parameters = new HashMap();
  }

  public String getMethod() {
    return method;
  }

  public String getResource() {
    return resource;
  }

  public Map<String, Object> getBody() {
    return body;
  }

  public Map<String, String> getHeaders() {
    return headers;
  }

  public Map<String, String[]> getParameters() {
    return parameters;
  }

  public String getHeader(String name) {
    return headers.get(name);
  }

  public Request setBody(Map<String, Object> body) {
    this.body.putAll(body);
    return this;
  }

  public Request setMethod(String name) {
    this.method = name;
    return this;
  }

  public Request setResource(String name) {
    this.resource = name;
    return this;
  }

  public Request setHeaders(Map<String, String> headers) {
    this.headers.putAll(headers);
    return this;
  }

  public Request setParameters(Map<String, String[]> parameters) {
    this.parameters.putAll(parameters);
    return this;
  }

  private static class BodyDeserializer extends JsonDeserializer<Map<String, Object>> {

    @Override
    public Map<String, Object> deserialize(JsonParser jp, DeserializationContext dc) throws IOException, JsonProcessingException {
      JsonDeserializer<Object> deserializer = dc.findRootValueDeserializer(dc.constructType(Map.class));
      Map<String, Object> map = (Map<String, Object>) deserializer.deserialize(jp, dc);
      return map;
    }
  }
}

I think the simplest way of achieve what you want is using:

ObjectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

This will add type information in the serialized json.

Here you are a running example, that you will need to adapt to Spring:

public class Main {
    
    public enum MyEnum {
        enumValue1
    }
        
    public static void main(String[] args) throws IOException {
        ObjectMapper mapper = new ObjectMapper();
            
        MyClass obj = new MyClass();
        obj.setContext(new HashMap<String, Object>());
            
        obj.setVal1("foo");
        obj.setVal2("var");
        obj.getContext().put("key1", "stringValue1");
        obj.getContext().put("key2", MyEnum.enumValue1);
        obj.getContext().put("key3", 3.0);

        mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        String json = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj);
            
        System.out.println(json);
            
        MyClass readValue = mapper.readValue(json, MyClass.class);
        //Check the enum value was correctly deserialized
        Assert.assertEquals(readValue.getContext().get("key2"), MyEnum.enumValue1);
    }
}

The object will be serialized into something similar to:

[ 
  "so_27871226.MyClass", 
  {
    "val1" : "foo",
    "val2" : "var",
    "context" : [ 
      "java.util.HashMap", 
      {
        "key3" : 3.0,
        "key2" : [ "so_27871226.Main$MyEnum", "enumValue1" ],
        "key1" : "stringValue1"
      } 
    ]
  } 
]

And will be deserialized back correctly, and the assertion will pass.

By the way, there are more ways of doing this, please look at https://github.com/FasterXML/jackson-docs/wiki/JacksonPolymorphicDeserialization for more info.

I hope it will help.

The solution here is to deserialize into a list instead of a map because, as you noted, your JSON is a list.

// List<Object> is the list analogue to Map<String, Object> for deserializing
List<Object> untypedList = (List<Object>) JSON.deserializeUntyped(response.getBody());

// Getting at the data in a list is also similar (in that it involves explicit
//   type casting)
for(Object jsonObj :untypedList){
    // Since we're now working with a single json "object", we can
    //   re-cast it as a Map<String, Object> which will allow us to
    //   get at the juicy data contained within.
    Map<String, Object> castJsonObj = (Map<String, Object>)jsonObj;

    String externalId = (String)castJsonObj.get('_id');
    Boolean replacement = (Boolean)castJsonObj.get('replacement');
    // ...and so on
}

You need to register a deserializer:

ObjectMapper mapper = new ObjectMapper();
SimpleModule module = new SimpleModule();
module.addDeserializer(Response.class, new ResponseDeserializer());
mapper.registerModule(module);

Response resp = mapper.readValue(myjson, Response.class);

Here is an example:

public class ResponseDeserializer extends StdDeserializer<Response> {
    public ResponseDeserializer() { 
        this(null); 
    } 

    public ResponseDeserializer(Class<?> vc) { 
        super(vc); 
    }

    @Override
    public Response deserialize(JsonParser jp, DeserializationContext dc)
            throws IOException, JsonProcessingException {
        Response resp = new Response();
        resp.parameters = new HashMap<>();
        JsonNode node = jp.getCodec().readTree(jp);
        ArrayNode parms = (ArrayNode)node.get("parameters");
        for (JsonNode parm: parms) {
            String key = parm.get("key").asText();
            String value = parm.get("value").asText();
            resp.parameters.put(key, value);
        }
        return resp;
    }   
}

You would need to write a custom deserializer to handle this. This gives a decent overview, and there are a number of other questions on stackoverflow that cover this, for example here.

Alternatively, you could let Jackson deserialize in to a Map<String, Map<String, String>> and then post-process it in to whatever form you wish.

Jackson can by default deserialize into a Map<String, String>. So the following should work by default.

@GetMapping
public void getSomething(@RequestBody Map<String,String> map) {
      ....
}

But your case seems different, since you expect multiple JSON objects inside a List with duplicate information of key: somekey, value : somevalue. key and value are duplicate information for each object in the list.

After seeing more feedback from the comments IMO the best bet here would be to introduce a custom deserialized which will be used to convert the input JSON into a Map<String, String>. More about custom deserializers and example can be found here.

First, addressing your problem. You are trying to de-serialize JSON to a class that doesn't have fields present in the JSON string, so it's failing to find those fields and returning the exception.

You could alternatively do the following:

ObjectMapper mapper = new ObjectMapper();
Map<String, Object> map = mapper.readValue(JSON_STRING, new TypeReference<Map<String, String>>(){});
box.setJsonMap(map);

where box would have a setter to set the json map

Or you could add all the fields to your Box POJO and use GSON to make this easier!

E.g. Json -> Object

Gson gson = new Gson();
Box box = gson.fromJson(JSON_STRING, Box.class);

E.g. Object -> Json

Gson gson = new Gson();
String str = gson.toJson(mBox); //mBox is some box object

GSON would populate all the fields within box to match the key, value pairs found in the JSON string. Ignore this if you don't want to do that but it is another alternative!