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.

MyClass.java

public class MyClass {
    private String text1;
    private String text2;

    public MyClass() {
    }

    public MyClass(String text1, String text2) {
        this.text1 = text1;
        this.text2 = text2;
    }

    public String getText1() {
        return this.text1;
    }

    public void setText1(String text1) {
        this.text1 = text1;
    }

    public String getText2() {
        return this.text2;
    }

    public void setText1(String text2) {
        this.text2 = text2;
    }
}

import com.fasterxml.jackson.databind.ObjectMapper;
ObjectMapper mapper = new ObjectMapper();

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

Explanation of How ObjectMapper works:

The Jackson ObjectMapper class is the simplest way to parse JSON with Jackson. The Jackson Object mapper can parse JSON into objects of classes developed by you, or into objects of the built-in JSON tree model. The reason it is called ObjectMapper is that it maps JSON into Java Objects (deserialization), or Java Objects into JSON (serialization).

mapper.convertValue(customer, CustomerDTO.class)

This attempts to create a single CustomerDTO, not a list of them.

Perhaps this will help:

mapper.readValues(customer, CustomerDTO.class).readAll()

You can convert them by registering custom deserializer as below:

public class PersonDeserializer extends JsonDeserializer<Person> {

    @Override
    public Person deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {
        ObjectCodec oc = jp.getCodec();
        JsonNode node = oc.readTree(jp);

        final Integer age = node.get("age").asInt();
        final String name = node.get("name").asText();
        final String hobbyListAsString = node.get("hobby_list").asText();

        ObjectMapper mapper = new ObjectMapper();
        // convert JSON array to List of objects
        List<Hobby> hobbyList = Arrays.asList(mapper.readValue(hobbyListAsString, Hobby[].class));

        Person person = new Person();
        person.setName(name);
        person.setAge(age);
        person.setHobbyList(hobbyList);

        return person;
    }
}

and in pojo at root use annotation @JsonDeserialize(using = PersonDeserializer.class) so that above deserializer can be registered. Attaching reference below:

@JsonDeserialize(using = PersonDeserializer.class)
@Data
public class Person {
    @JsonProperty("name")
    private String name;

    @JsonProperty("age")
    private Integer age;

    @JsonProperty("hobby_list")
    private List<Hobby> hobbyList;
}

Then I was able to deserialize above hobby_list string to object

ObjectMapper mapper = new ObjectMapper();
Person person = mapper.readValue(content, Person.class);
System.out.println(person.getHobbyList());

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

Create 2 more classes like

public class Temp {
    Meta meta;
    List<TPDetails> data;
}

public class Meta {
    String code;
}

and now convert this json to Temp class.

Temp temp = objectMapper.convertValue(responseEntity.getBody().getClass(), new TypeReference<Temp>(){});

UPDATED :

Make sure responseEntity.getBody() return the exact Json String which you mentioned above.

Temp temp = objectMapper.readValue(responseEntity.getBody(), new TypeReference<Temp>(){});