You can deserialize directly to a list by using the TypeReference wrapper. An example method:

public static <T> T fromJSON(final TypeReference<T> type,
      final String jsonPacket) {
   T data = null;

   try {
      data = new ObjectMapper().readValue(jsonPacket, type);
   } catch (Exception e) {
      // Handle the problem
   }
   return data;
}

And is used thus:

final String json = "";
Set<POJO> properties = fromJSON(new TypeReference<Set<POJO>>() {}, json);

TypeReference Javadoc

Since you are using Jackson I think what you need is JsonDeserializer class (javadoc).

You can implement it like this:

public class ListOrObjectGenericJsonDeserializer<T> extends JsonDeserializer<List<T>> {

    private final Class<T> cls;

    public ListOrObjectGenericJsonDeserializer() {
        final ParameterizedType type = (ParameterizedType) this.getClass().getGenericSuperclass();
        this.cls = (Class<T>) type.getActualTypeArguments()[0];
    }

    @Override
    public List<T> deserialize(final JsonParser p, final DeserializationContext ctxt) throws IOException, JsonProcessingException {
        final ObjectCodec objectCodec = p.getCodec();
        final JsonNode listOrObjectNode = objectCodec.readTree(p);
        final List<T> result = new ArrayList<T>();
        if (listOrObjectNode.isArray()) {
            for (JsonNode node : listOrObjectNode) {
                result.add(objectCodec.treeToValue(node, cls));
            }
        } else {
            result.add(objectCodec.treeToValue(listOrObjectNode, cls));
        }
        return result;
    }
}

...

public class ListOrObjectResultItemJsonDeserializer extends ListOrObjectGenericJsonDeserializer<ResultItem> {}

Next you need to annotate your POJO field. Let's say you have classes like Result and ResultItem:

public class Result {

    // here you add your custom deserializer so jackson will be able to use it
    @JsonDeserialize(using = ListOrObjectResultItemJsonDeserializer.class)
    private List<ResultItem> result;

    public void setResult(final List<ResultItem> result) {
    this.result = result;
    }

    public List<ResultItem> getResult() {
        return result;
    }
}

...

public class ResultItem {

    private String value;

    public String getValue() {
        return value;
    }

    public void setValue(final String value) {
        this.value = value;
    }
}

Now you can check your deserializer:

// list of values
final String json1 = "{\"result\": [{\"value\": \"test\"}]}";
final Result result1 = new ObjectMapper().readValue(json1, Result.class);
// one value
final String json2 = "{\"result\": {\"value\": \"test\"}}";
final Result result2 = new ObjectMapper().readValue(json2, Result.class); 

result1 and result2 contain the same value.

If you have access to Role class you can just add such constructor:

private Role(String role) {
   this.role = role;
}

or static factory methods:

@JsonCreator
public static Role fromJson(String value){
    Role role = new Role();
    role.setRole(value);
    return role;
}

@JsonValue
public String toJson() {
    return role;
}

Otherwise you will have to write custom deserealizer and register it on object mapper like this:

public static class RoleSerializer extends JsonSerializer {
    @Override
    public void serialize(Object value, JsonGenerator gen, SerializerProvider serializers) throws IOException, JsonProcessingException {
        gen.writeString(((Role) value).getRole());
    }
}

public static class RoleDeserializer extends JsonDeserializer {
    @Override
    public Role deserialize(JsonParser jsonParser,DeserializationContext deserializationContext) throws IOException {
        ObjectCodec oc = jsonParser.getCodec();
        JsonNode node = oc.readTree(jsonParser);
        Role role =  new Role();
        role.setRole(node.asText());
        return role;
    }
}

Here is demo: https://gist.github.com/varren/84ce830d07932b6a9c18

FROM: [{"email": "user@email","roles": ["REGISTERED_USER"]}]

TO OBJ: [User{id=null, email='user@email', password='null', roles=Role{role='REGISTERED_USER'}}]

TO JSON:[{"email":"user@email","roles":["REGISTERED_USER"]}]

Ps: If you use ObjectMapper like this

Arrays.asList(objectMapper.readValue(multipartFile.getBytes(), User[].class));

then code from demo will work, but you will probably have to set custom Bean in Spring for jackson ObjectMapper to make RoleDeserializer and RoleSerializer work everywhere. Here is more info: Spring, Jackson and Customization (e.g. CustomDeserializer)

Looks like the payload got serialized twice somehow. Ideally you would fix that so it is serialized just once instead. However, you can fix it in the interim by deserializing first into a String, then into your List<Object>.

String payload = (String)JSON.deserializeUntyped(response.getBody());
List<Object> data = (List<Object>)JSON.deserializeUntyped(payload);

@JsonDeserialize(contentAs=Bar.class)
List<IBar> bars;