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

Question

抽象控制器class 需要来自 REST 的对象列表。在使用 Spring RestTemplate 时，它没有将其映射到必需的 class 而是 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;

}

如果我用，

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

它工作正常。但是不能把所有的subclass都放进去，任何其他解法。

Answer 1

无法从 Spring 中找到解决方案，因此我在 HashMap 中使用 ParameterizedTypeReference 完成了它，例如

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

Answer 2

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

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 的答案那样保留类型的静态映射

Answer 3

将 ParameterizedTypeReference 用于 List<Domain>，当域是显式 class 时，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 用于泛型风格，则该列表本身应该被参数化。我找到的最佳方法是：

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

Answer 4

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

Answer 5

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

在基础 class 中，我试图定义一个 ParameterizedTypeReference 如下：

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

这没有用，所以我最终在基础中创建了一个抽象方法 class:

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

然后在导出的classes:

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

然后我可以在基础 class 中使用它，例如：

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

Answer 6

如果有人需要 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>

Answer 7

您可以使用 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;

}

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

Spring RestTemplate and generic types ParameterizedTypeReference collections like List<T>

java

resttemplate

spring-web

spring-rest