The TypeFactory in Jackson allows to map directly to collections and other complex types:

String json = "[ \"abc\", \"def\" ]";
ObjectMapper mapper = new ObjectMapper();

List<String> list = mapper.readValue(json, TypeFactory.defaultInstance().constructCollectionType(List.class, String.class));

You are asking Jackson to parse a StudentList. Tell it to parse a List (of students) instead. Since List is generic you will typically use a TypeReference

List<Student> participantJsonList = mapper.readValue(jsonString, new TypeReference<List<Student>>(){});

First create a mapper :

import com.fasterxml.jackson.databind.ObjectMapper;// in play 2.3
ObjectMapper mapper = new ObjectMapper();

As Array:

MyClass[] myObjects = mapper.readValue(json, MyClass[].class);

As List:

List<MyClass> myObjects = mapper.readValue(jsonInput, new TypeReference<List<MyClass>>(){});

Another way to specify the List type:

List<MyClass> myObjects = mapper.readValue(jsonInput, mapper.getTypeFactory().constructCollectionType(List.class, MyClass.class));

The problem is that your JsonNaming annotation requires snake_case and you are not using it.

To solve it

• remove the annotation @JsonNaming(PropertyNamingStrategy.SnakeCaseStrategy.class)
• or, rename the variable in the JSON String to role_ids

Use TypeReference<T>:

TypeReference<List<List<String>>> typeReference = 
        new TypeReference<List<List<String>>>() {};
List<List<String>> list = mapper.readValue(json, typeReference);

It is impossible explicitly, however, you can deserialize you String into List< Object> and then cast your Object in for-loop to Map< String, Object>:

String jsonString = '[{"id":2,"name":"Abc_SS","description":"Abc"},{"id":100,"name":"sales","description":"sales"}]';

List<Object> items = (List<Object>) JSON.deserializeUntyped(jsonString);

for (Object itemObj : items) {
    Map<String, Object> item = (Map<String, Object>) itemObj;
    //now you can work with it like you always work with Map
}

For the json itself, you can try to use this website to generate the pojo class https://www.jsonschema2pojo.org/

It really helpful to know what class that you need to parse the json. For the example that you've post, what you need is 2 classes.

This is POJO for the outer json.

public class ExampleObject {

    @JsonProperty("Items")
    public List<Item> items = null;

}

This one is for your Item class

public class Item {

    @JsonProperty("mode")
    public String mode;

    @JsonProperty("processing")
    public List<String> processing = null;
    
    //Dont forget to put your setter getter in here.

}

After that, just use your code to parse that json into new class.

ObjectMapper mapper = new ObjectMapper();
List<Items> actions = Arrays.asList(mapper.readValue(json, ExampleObject.class)); 

Hope it helps, cheers

You will need to pass a TypeReference to readValue with the desired result type:

ObjectMapper mapper = new ObjectMapper();
List<Map<String, Object>> data = mapper.readValue(json, new TypeReference<List<Map<String, Object>>>(){});

First, define POJOs for mapping your request object:

public class RequestObj implements Serializable{

    private List<Long> ids;

    private UsuarioDTO user;

    /* getters and setters here */

}

public class UsuarioDTO implements Serializable{

    private String name;
    private String email;

    /* getters and setters here */

}

And then modify your endpoint:

@PostMapping(value = "/sendToOficial")
public ResponseEntity<?> sendToOficial(@RequestBody RequestObj payload) {

In this way you also do not need to use an ObjectMapper. Just call payload.getIds().

Consider also that in this way if payload changes you'll need only to change RequestObj definition, while using ObjectMapper would force you to update also your endpoint in an important way. It's better and safer to separate payload representation from control logic.