Spring RestTemplate and generic types ParameterizedTypeReference collections like List

Question

An Abstract controller class requires List of objects from REST. While using Spring RestTemplate its not mapping it to required class instead it returns Linked HashMAp

 public List<T> restFindAll() {

    RestTemplate restTemplate = RestClient.build().restTemplate();
    ParameterizedTypeReference<List<T>>  parameterizedTypeReference = new ParameterizedTypeReference<List<T>>(){};
    String uri= BASE_URI +"/"+ getPath();

    ResponseEntity<List<T>> exchange = restTemplate.exchange(uri, HttpMethod.GET, null,parameterizedTypeReference);
    List<T> entities = exchange.getBody();
    // here entities are List<LinkedHashMap>
    return entities;

}

If I use,

ParameterizedTypeReference<List<AttributeInfo>>  parameterizedTypeReference = 
    new ParameterizedTypeReference<List<AttributeInfo>>(){};
    ResponseEntity<List<AttributeInfo>> exchange =
  restTemplate.exchange(uri, HttpMethod.GET, null,parameterizedTypeReference);

It works fine. But can not put in all subclasses, any other solution.

score 47 · Accepted Answer · edited Jul 18 '18 at 08:01

I worked around this using the following generic method:

public <T> List<T> exchangeAsList(String uri, ParameterizedTypeReference<List<T>> responseType) {
    return restTemplate.exchange(uri, HttpMethod.GET, null, responseType).getBody();
}

Then I could call:

List<MyDto> dtoList = this.exchangeAsList("http://my/url", new ParameterizedTypeReference<List<MyDto>>() {});

This did burden my callers with having to specify the ParameterizedTypeReference when calling, but meant that I did not have to keep a static mapping of types like in vels4j's answer

score 14 · Answer 2 · answered Nov 20 '18 at 18:05

Using ParameterizedTypeReference for a List<Domain>, when Domain is an explicit class, that ParameterizedTypeReference works well, like this:

@Override
public List<Person> listAll() throws Exception {
    ResponseEntity<List<E>> response = restTemplate.exchange("http://example.com/person/", HttpMethod.GET, null,
            new ParameterizedTypeReference<List<Person>>() {});
    return response.getBody();
}

However, if a method listAll is used in generic flavor, that list should be parameterized itself. The best way I found for this is:

public abstract class WebServiceImpl<E> implements BaseService<E> {

    private Class<E> entityClass;

    @SuppressWarnings("unchecked")
    public WebServiceImpl() {
        this.entityClass = (Class<E>) ((ParameterizedType) getClass().getGenericSuperclass())
            .getActualTypeArguments()[0];
    }


    @Override
    public List<E> listAll() throws Exception {
        ResponseEntity<List<E>> response =  restTemplate.exchange("http://example.com/person/", HttpMethod.GET, null,
                new ParameterizedTypeReference<List<E>>() {
                    @Override
                    public Type getType() {
                        Type type = super.getType();
                        if (type instanceof ParameterizedType) {
                            Type[] responseWrapperActualTypes = { entityClass };
                            ParameterizedType responseWrapperType = new ParameterizedTypeImpl(List.class,
                                    responseWrapperActualTypes, null);
                            return responseWrapperType;
                        }
                        return type;
                    }
                });
        return response.getBody();
    }
}

This is a nice solution for getting typed collections when the entity class is only passed as a parameter, e.g. when implementing a spring-data RepositoryQuery. Thanks! — Rüdiger Schulz, Feb 12 '19 at 09:41
And instead of using sun internal APIs (ParameterizedTypeImpl) you could also have a look at commons-lang3's TypeUtils. — Rüdiger Schulz, Feb 12 '19 at 11:13
Your code does same thing as ParameterizedTypeReference class (from spring) — Mr Jedi, Apr 22 '21 at 07:59

score 13 · Answer 3 · answered Apr 29 '16 at 13:42

Couldnt find a solution from Spring, hence I have done it with ParameterizedTypeReference in HashMap like

 public final static HashMap<Class,ParameterizedTypeReference> paramTypeRefMap = new HashMap() ;
 static {
    paramTypeRefMap.put(AttributeDefinition.class, new ParameterizedTypeReference<List<AttributeDefinition>>(){} );
    paramTypeRefMap.put(AttributeInfo.class, new ParameterizedTypeReference<List<AttributeInfo>>(){} );
 }

and used it

ParameterizedTypeReference parameterizedTypeReference = paramTypeRefMap.get(requiredClass);
ResponseEntity<List> exchange = restTemplate.exchange(uri, HttpMethod.POST, entity, parameterizedTypeReference);

The method exchange(String, HttpMethod, HttpEntity>, Class, Object...) in the type RestTemplate is not applicable for the arguments (String, HttpMethod, HttpEntity, ParameterizedTypeReference) did it really worked for you ? — Abhishek Galoda, Nov 03 '17 at 17:49

score 1 · Answer 4 · answered Dec 19 '18 at 14:59

1

The easiest solution for me is to define an object MyOperationResult containing the list you expect as field and use restTemplate.getForObject to get this result.

answered Dec 19 '18 at 14:59

JRA_TLL

880
7
21

score 1 · Answer 5 · answered May 22 '20 at 21:15

In case someone need a Kotlin solution, you can do:

val responseType = object : ParameterizedTypeReference<Map<String, Any?>>() {}         
val request = HttpEntity<Any?>(data)
val response = restTemplate.exchange(url, HttpMethod.POST, request, responseType)
val responseMap = response?.body as Map<String, Any>

score 0 · Answer 6 · answered Apr 16 '20 at 03:08

I did this a bit different. In my situation, I had a base class where I was implementing a set of CRUD operations and then using derived classes to implement specific resource types.

In the base class, I was trying to define a ParameterizedTypeReference as follows:

ParameterizedTypeReference<ServicePagedResult<R>> typeRef = 
  new ParameterizedTypeReference<ServicePagedResult<R>>() {};

This didn't work so I ended up creating an abstract method in the base class:

protected abstract ParameterizedTypeReference<ServicePagedResult<R>> 
getServicePagedResultTypeRef();

and then in the derived classes:

@Override
protected ParameterizedTypeReference<ServicePagedResult<AccountResource>>
getServicePagedResultTypeRef() {
  return new ParameterizedTypeReference<ServicePagedResult<AccountResource>>() {};
}

I could then use that in the base class like:

ResponseEntity<ServicePagedResult<R>> response = lbRestTemplate.exchange(
  uri, HttpMethod.GET, null, getServicePagedResultTypeRef(), uriVariables);

score 0 · Answer 7 · answered Mar 12 '21 at 20:20

You can use TypeUtil to build the generic Type to pass to exchange:

 public List<T> restFindAll() {

    RestTemplate restTemplate = RestClient.build().restTemplate();
    String uri= BASE_URI +"/"+ getPath();

    ResponseEntity<List<T>> exchange = restTemplate.exchange(uri, HttpMethod.GET, null, ParameterizedTypeReference.forType(TypeUtils.parameterize(List.class, clazz)));
    List<T> entities = exchange.getBody();
    return entities;

}
``

Spring RestTemplate and generic types ParameterizedTypeReference collections like List

7 Answers7

Linked

Related