Using Spring RestTemplate in generic method with generic parameter

Question

To use generic types with Spring RestTemplate we need to use ParameterizedTypeReference  Unable to get a generic ResponseEntity lt T gt  where T is a generic class  quot SomeClass lt SomeGenericType gt  quot    Suppose I have some class  public class MyClass       int users         public int   getUsers     return users        public void setUsers int   users   this users   users       And some wrapper class  public class ResponseWrapper  lt T gt        T response       public T getResponse      return response        public void setResponse T response   this response   response       So if I m trying to do something like this  all is OK   public ResponseWrapper lt MyClass gt  makeRequest URI uri        ResponseEntity lt ResponseWrapper lt MyClass gt  gt  response   template exchange          uri          HttpMethod POST          null          new ParameterizedTypeReference lt ResponseWrapper lt MyClass gt  gt             return response      But when I m trying to create generic variant of the above method      public  lt T gt  ResponseWrapper lt T gt  makeRequest URI uri  Class lt T gt  clazz       ResponseEntity lt ResponseWrapper lt T gt  gt  response   template exchange          uri          HttpMethod POST          null          new ParameterizedTypeReference lt ResponseWrapper lt T gt  gt             return response          and calling this method like so      makeRequest uri  MyClass class        instead of getting ResponseEntity lt ResponseWrapper lt MyClass gt  gt  object I m getting ResponseEntity lt ResponseWrapper lt LinkedHashSet gt  gt  object    How can I solve this problem  Is it a RestTemplate bug   UPDATE 1 Thanks to  Sotirios I understand the concept  Unfortunately I m newly registered here so I cant comment on his answer  so writing it here  Im not sure that I clearly understand how to implement the proposed approach to solve my problem with Map with Class key  Proposed by  Sotirios in the end of his answer   Would someone mind to give an example

User · Answer

My own implementation of generic restTemplate call:

private <REQ, RES> RES queryRemoteService(String url, HttpMethod method, REQ req, Class reqClass) {
    RES result = null;
    try {
        long startMillis = System.currentTimeMillis();

        // Set the Content-Type header
        HttpHeaders requestHeaders = new HttpHeaders();
        requestHeaders.setContentType(new MediaType("application","json"));            

        // Set the request entity
        HttpEntity<REQ> requestEntity = new HttpEntity<>(req, requestHeaders);

        // Create a new RestTemplate instance
        RestTemplate restTemplate = new RestTemplate();

        // Add the Jackson and String message converters
        restTemplate.getMessageConverters().add(new MappingJackson2HttpMessageConverter());
        restTemplate.getMessageConverters().add(new StringHttpMessageConverter());

        // Make the HTTP POST request, marshaling the request to JSON, and the response to a String
        ResponseEntity<RES> responseEntity = restTemplate.exchange(url, method, requestEntity, reqClass);
        result = responseEntity.getBody();
        long stopMillis = System.currentTimeMillis() - startMillis;

        Log.d(TAG, method + ":" + url + " took " + stopMillis + " ms");
    } catch (Exception e) {
         Log.e(TAG, e.getMessage());
    }
    return result;
}

To add some context, I'm consuming RESTful service with this, hence all requests and responses are wrapped into small POJO like this:

public class ValidateRequest {
  User user;
  User checkedUser;
  Vehicle vehicle;
}

and

public class UserResponse {
  User user;
  RequestResult requestResult;
}

Method which calls this is the following:

public User checkUser(User user, String checkedUserName) {
    String url = urlBuilder()
            .add(USER)
            .add(USER_CHECK)
            .build();

    ValidateRequest request = new ValidateRequest();
    request.setUser(user);
    request.setCheckedUser(new User(checkedUserName));

    UserResponse response = queryRemoteService(url, HttpMethod.POST, request, UserResponse.class);
    return response.getUser();
}

And yes, there's a List dto-s as well.

User · Answer

Actually  you can do this  but with additional code   There is Guava equivalent of ParameterizedTypeReference and it s called TypeToken   Guava s class is much more powerful then Spring s equivalent  You can compose the TypeTokens as you wish  For example   static  lt K  V gt  TypeToken lt Map lt K  V gt  gt  mapToken TypeToken lt K gt  keyToken  TypeToken lt V gt  valueToken      return new TypeToken lt Map lt K  V gt  gt            where new TypeParameter lt K gt        keyToken       where new TypeParameter lt V gt        valueToken       If you call mapToken TypeToken of String class   TypeToken of BigInteger class    you will create TypeToken lt Map lt String  BigInteger gt  gt    The only disadvantage here is that many Spring APIs require ParameterizedTypeReference and not TypeToken  But we can create ParameterizedTypeReference implementation which is adapter to TypeToken itself   import com google common reflect TypeToken  import org springframework core ParameterizedTypeReference   import java lang reflect Type   public class ParameterizedTypeReferenceBuilder        public static  lt T gt  ParameterizedTypeReference lt T gt  fromTypeToken TypeToken lt T gt  typeToken            return new TypeTokenParameterizedTypeReference lt  gt  typeToken              private static class TypeTokenParameterizedTypeReference lt T gt  extends ParameterizedTypeReference lt T gt             private final Type type           private TypeTokenParameterizedTypeReference TypeToken lt T gt  typeToken                this type   typeToken getType                        Override         public Type getType                 return type                      Override         public boolean equals Object obj                return  this    obj     obj instanceof ParameterizedTypeReference  amp  amp                      this type equals   ParameterizedTypeReference lt   gt   obj  getType                           Override         public int hashCode                 return this type hashCode                        Override         public String toString                 return  ParameterizedTypeReference lt     this type     gt                          Then you can use it like this   public  lt T gt  ResponseWrapper lt T gt  makeRequest URI uri  Class lt T gt  clazz       ParameterizedTypeReference lt ResponseWrapper lt T gt  gt  responseTypeRef              ParameterizedTypeReferenceBuilder fromTypeToken                 new TypeToken lt ResponseWrapper lt T gt  gt                           where new TypeParameter lt T gt        clazz       ResponseEntity lt ResponseWrapper lt T gt  gt  response   template exchange          uri          HttpMethod POST          null          responseTypeRef       return response      And call it like   ResponseWrapper lt MyClass gt  result   makeRequest uri  MyClass class     And the response body will be correctly deserialized as ResponseWrapper lt MyClass gt    You can even use more complex types if you rewrite your generic request method  or overload it  like this   public  lt T gt  ResponseWrapper lt T gt  makeRequest URI uri  TypeToken lt T gt  resultTypeToken       ParameterizedTypeReference lt ResponseWrapper lt T gt  gt  responseTypeRef              ParameterizedTypeReferenceBuilder fromTypeToken                 new TypeToken lt ResponseWrapper lt T gt  gt                           where new TypeParameter lt T gt        resultTypeToken       ResponseEntity lt ResponseWrapper lt T gt  gt  response   template exchange          uri          HttpMethod POST          null          responseTypeRef       return response      This way T can be complex type  like List lt MyClass gt    And call it like   ResponseWrapper lt List lt MyClass gt  gt  result   makeRequest uri  new TypeToken lt List lt MyClass gt  gt

User · Answer

No  it is not a bug  It is a result of how the ParameterizedTypeReference hack works    If you look at its implementation  it uses Class getGenericSuperclass   which states     Returns the Type representing the direct superclass of the entity    class  interface  primitive type or void  represented by this Class       If the superclass is a parameterized type  the Type object returned   must accurately reflect the actual type parameters used in the source   code    So  if you use   new ParameterizedTypeReference lt ResponseWrapper lt MyClass gt  gt         it will accurately return a Type for ResponseWrapper lt MyClass gt     If you use   new ParameterizedTypeReference lt ResponseWrapper lt T gt  gt         it will accurately return a Type for ResponseWrapper lt T gt  because that is how it appears in the source code   When Spring sees T  which is actually a TypeVariable object  it doesn t know the type to use  so it uses its default   You cannot use ParameterizedTypeReference the way you are proposing  making it generic in the sense of accepting any type  Consider writing a Map with key Class mapped to a predefined ParameterizedTypeReference for that class   You can subclass ParameterizedTypeReference and override its getType method to return an appropriately created ParameterizedType  as suggested by IonSpin

User · Answer

I have another way to do this    suppose you swap out your message converter to String for your RestTemplate  then you can receive raw JSON   Using the raw JSON  you can then map it into your Generic Collection using a Jackson Object Mapper   Here s how   Swap out the message converter       List lt HttpMessageConverter lt   gt  gt  oldConverters   new ArrayList lt HttpMessageConverter lt   gt  gt         oldConverters addAll template getMessageConverters          List lt HttpMessageConverter lt   gt  gt  stringConverter   new ArrayList lt HttpMessageConverter lt   gt  gt         stringConverter add new StringHttpMessageConverter          template setMessageConverters stringConverter     Then get your JSON response like this       ResponseEntity lt String gt  response   template exchange uri  HttpMethod GET  null  String class     Process the response like this        String body   null       List lt T gt  result   new ArrayList lt T gt          ObjectMapper mapper   new ObjectMapper          if  response hasBody              body   items getBody            try               result   mapper readValue body  mapper getTypeFactory   constructCollectionType List class  clazz              catch  Exception e                e printStackTrace              finally               template setMessageConverters oldConverters

User · Answer

I am using org springframework core ResolvableType for a ListResultEntity        ResolvableType resolvableType   ResolvableType forClassWithGenerics ListResultEntity class  itemClass       ParameterizedTypeReference lt ListResultEntity lt T gt  gt  typeRef   ParameterizedTypeReference forType resolvableType getType       So in your case   public  lt T gt  ResponseWrapper lt T gt  makeRequest URI uri  Class lt T gt  clazz       ResponseEntity lt ResponseWrapper lt T gt  gt  response   template exchange          uri          HttpMethod POST          null          ParameterizedTypeReference forType ResolvableType forClassWithGenerics ResponseWrapper class  clazz         return response      This only makes use of spring and of course requires some knowledge about the returned types  but should even work for things like Wrapper   as long as you provide the classes as varargs

User · Answer

As Sotirios explains  you can not use the ParameterizedTypeReference  but ParameterizedTypeReference is used only to provide Type to the object mapper  and as you have the class that is removed when type erasure happens  you can create your own ParameterizedType and pass that to RestTemplate  so that the object mapper can reconstruct the object you need   First you need to have the ParameterizedType interface implemented  you can find an implementation in Google Gson project here   Once you add the implementation to your project  you can extend the abstract ParameterizedTypeReference like this    class FakeParameterizedTypeReference lt T gt  extends ParameterizedTypeReference lt T gt      Override public Type getType         Type    responseWrapperActualTypes    MyClass class       ParameterizedType responseWrapperType   new ParameterizedTypeImpl          ResponseWrapper class          responseWrapperActualTypes          null                return responseWrapperType            And then you can pass that to your exchange function   template exchange      uri      HttpMethod POST      null      new FakeParameterizedTypeReference lt ResponseWrapper lt T gt  gt        With all the type information present object mapper will properly construct your ResponseWrapper lt MyClass gt  object

User · Answer

I feel like there s a much easier way to do this    Just define a class with the type parameters that you want  e g     final class MyClassWrappedByResponse extends ResponseWrapper lt MyClass gt        private static final long serialVersionUID   1L      Now change your code above to this and it should work   public ResponseWrapper lt MyClass gt  makeRequest URI uri        ResponseEntity lt MyClassWrappedByResponse gt  response   template exchange          uri          HttpMethod POST          null          MyClassWrappedByResponse class     return response

User · Answer

Note  This answer refers adds to Sotirios Delimanolis s answer and comment   I tried to get it to work with Map lt Class  ParameterizedTypeReference lt ResponseWrapper lt   gt  gt  gt   as indicated in Sotirios s comment  but couldn t without an example   In the end  I dropped the wildcard and parametrisation from ParameterizedTypeReference and used raw types instead  like so  Map lt Class lt   gt   ParameterizedTypeReference gt  typeReferences   new HashMap lt  gt     typeReferences put MyClass1 class  new ParameterizedTypeReference lt ResponseWrapper lt MyClass1 gt  gt          typeReferences put MyClass2 class  new ParameterizedTypeReference lt ResponseWrapper lt MyClass2 gt  gt                ParameterizedTypeReference typeRef   typeReferences get clazz    ResponseEntity lt ResponseWrapper lt T gt  gt  response   restTemplate exchange          uri           HttpMethod GET           null           typeRef     and this finally worked   If anyone has an example with parametrisation  I d be very grateful to see it

User · Answer

As the code below shows it  it works   public  lt T gt  ResponseWrapper lt T gt  makeRequest URI uri  final Class lt T gt  clazz       ResponseEntity lt ResponseWrapper lt T gt  gt  response   template exchange          uri          HttpMethod POST          null          new ParameterizedTypeReference lt ResponseWrapper lt T gt  gt                  public Type getType                     return new MyParameterizedTypeImpl  ParameterizedType  super getType    new Type    clazz                          return response     public class MyParameterizedTypeImpl implements ParameterizedType       private ParameterizedType delegate      private Type   actualTypeArguments       MyParameterizedTypeImpl ParameterizedType delegate  Type   actualTypeArguments            this delegate   delegate          this actualTypeArguments   actualTypeArguments              Override     public Type   getActualTypeArguments             return actualTypeArguments              Override     public Type getRawType             return delegate getRawType                Override     public Type getOwnerType             return delegate getOwnerType

[java] Using Spring RestTemplate in generic method with generic parameter

Examples related to java

Examples related to spring

Examples related to generics

Examples related to jackson

Examples related to resttemplate