Spring RestTemplate和泛型类型ParameterizedTypeReference集合（如List<T>）

Question

一个抽象控制器类需要从REST获取对象列表。使用Spring RestTemplate时，它没有将其映射到所需的类，而是返回了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;

}

如果我使用，

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

它运行良好，但不能放在所有子类中，是否有其他解决方案。

- vels4j

Answer 1

我使用以下通用方法解决了这个问题：

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

那么我可以打电话：

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

这确实让我的调用者需要在调用时指定ParameterizedTypeReference，但意味着我不必像vels4j的回答中那样保留类型的静态映射。

- Rossiar

---

return restTemplate.exchange(uri, HttpMethod.GET, null, responseType).getBody(); }``` 调用方式相同 调用方式为 List dtoList = this.exchangeAsList("http://my/url", new ParameterizedTypeReference<>() {}); - Mrinal Bhattacharjee

Answer 2

当Domain是一个明确的类时，使用ParameterizedTypeReference来处理List<Domain>，那么ParameterizedTypeReference能够很好地工作，就像这样：

@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();
}

不过，如果在通用版本中使用方法listAll，那么该列表本身应该被参数化。我发现最好的方法是：

然而，如果在泛型版中使用 listAll 方法，则需要对该列表进行自身参数化。我发现以下是最佳方式：

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

- Moesio

---

这是一个不错的解决方案，当实体类仅作为参数传递时，可以获得已输入的集合，例如在实现Spring-data RepositoryQuery时。谢谢！ - Rüdiger Schulz

你可以考虑使用commons-lang3库的TypeUtils，而不是使用sun内部的API（ParameterizedTypeImpl）。这样做可以使代码更加通用。 - Rüdiger Schulz

你的代码和Spring框架中的ParameterizedTypeReference类做了相同的事情。 - Mr Jedi

Answer 3

在Spring中找不到解决方案，因此我使用ParameterizedTypeReference和HashMap完成了它。

 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>>(){} );
 }

并使用它

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

- vels4j

---

RestTemplate 类中的 exchange(String, HttpMethod, HttpEntity<?>, Class<T>, Object...) 方法不适用于参数 (String, HttpMethod, HttpEntity<LodgingAvailabilityRequest>, ParameterizedTypeReference<List<DXARoom>>)。 - Abhishek Galoda

Answer 4

我做了一些不同的事情。在我的情况下，我有一个基类，在其中实现了一组CRUD操作，然后使用派生类来实现特定的资源类型。

在基类中，我尝试定义ParameterizedTypeReference如下：

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

这个方法没有起作用，所以最终我在基类中创建了一个抽象方法：

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

接着在派生类中：

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

我可以在基类中这样使用:

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

- Ken Joyner

---

我使用了你的解决方案。它看起来是最简洁和最容易的一个。谢谢分享 ;) - Saxophonist

Answer 5

您可以使用Apache的commons-lang3中的TypeUtil来构建通用类型，以传递给交换函数：

 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;

}

- user1928596

---

TypeUtils来自哪里？你能提供完全限定的类名吗？ - Sniper

@Sniper，这是给你的 :) - user1928596

Answer 6

对我来说最简单的解决方案是定义一个名为MyOperationResult的对象，其中包含您期望的列表作为字段，并使用restTemplate.getForObject获取此结果。

- JRA_TLL

Answer 7

如果有人需要 Kotlin 解决方案，您可以执行以下操作：

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>

- ELavicount