为什么此代码在包装在通用函数中时不起作用？

Question

我使用此代码执行 HTTP POST 请求并反序列化返回值：

ParameterizedTypeReference<MyClass> typeRef = new ParameterizedTypeReference<>() {};
HttpEntity<Object> requestEntity = new HttpEntity<>("some text");
ResponseEntity<MyClass> result = restTemplate.exchange("/test", HttpMethod.POST, requestEntity, typeRef);
MyClass returnValue = result.getBody();

为了方便使用，我尝试将代码包装在一个函数中，如下所示：

public <T> T post(Object content, Class<T> returnType, String url){
    ParameterizedTypeReference<T> typeRef = new ParameterizedTypeReference<>() {};
    HttpEntity<Object> requestEntity = new HttpEntity<>(content);
    ResponseEntity<T> response = restTemplate.exchange(url, HttpMethod.POST, requestEntity, typeRef);
    return response.getBody();
}

但是，代码在放入函数时会停止运行。它抛出java.lang.ClassCastException: java.base/java.util.LinkedHashMap cannot be cast to client.rest.MyClass。似乎某些类型信息在此过程中丢失了。

以下是 2 个测试用例形式的完整代码：

package client.rest;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.*;
import org.springframework.test.web.client.MockRestServiceServer;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.client.support.RestGatewaySupport;

import static org.springframework.test.web.client.ExpectedCount.times;
import static org.springframework.test.web.client.match.MockRestRequestMatchers.requestTo;
import static org.springframework.test.web.client.response.MockRestResponseCreators.withSuccess;

class MyClass {
    public int getInt(){
        return 1;
    }

    public void setInt(int i){}
}

public class TEMP {

    public static RestTemplate restTemplate = new RestTemplate();
    public static MockRestServiceServer mockServer;

    @BeforeClass
    public static void beforeClass() throws JsonProcessingException {
        MyClass value = new MyClass();

        // set up a mock server
        RestGatewaySupport gateway = new RestGatewaySupport();
        gateway.setRestTemplate(restTemplate);
        mockServer = MockRestServiceServer.bindTo(gateway).build();

        ObjectMapper objectmapper = new ObjectMapper();
        String payload = objectmapper.writeValueAsString(value);

        mockServer.expect(times(2), requestTo("/test"))
            .andRespond(withSuccess(payload, MediaType.APPLICATION_JSON));
    }

    @Test
    public void without_function() {
        ParameterizedTypeReference<MyClass> typeRef = new ParameterizedTypeReference<>() {};
        HttpEntity<Object> requestEntity = new HttpEntity<>("some text");
        ResponseEntity<MyClass> result = restTemplate.exchange("/test", HttpMethod.POST, requestEntity, typeRef);
        MyClass returnValue = result.getBody();
    }

    public <T> T post(Object content, Class<T> returnType, String url){
        ParameterizedTypeReference<T> typeRef = new ParameterizedTypeReference<>() {};
        HttpEntity<Object> requestEntity = new HttpEntity<>(content);
        ResponseEntity<T> response = restTemplate.exchange(url, HttpMethod.POST, requestEntity, typeRef);
        return response.getBody();
    }

    @Test
    public void with_function() {
        MyClass returnValue = post("some text", MyClass.class, "/test");
    }
}

我的问题有两个：

1. 为什么该功能不起作用？
2. 我怎样才能让它工作？

Answer 1

答案为 1。

ParameterizedTypeReference<X> typeRef = new ParameterizedTypeReference<X>() {};

感谢最后的{}jackson 能够使用反射找出运行时X 的内容，但是X 在编译时得到解决，所以如果你有MyClass 或T，那正是它将在运行时得到什么；它无法确定T 在运行时分配给了什么。

出于同样的原因，如果您继续使用无功能选项但在最后删除{}，它将编译但会导致相同的错误。

回答 2。

您可以直接传递ParameterizedTypeReference<T> typeRef，而不是Class<T> returnType，即您永远不会引用btw。然后调用帖子的代码需要在编译时确定T：

@Test
    public void with_function() {
        ParameterizedTypeReference<MyClass> typeRef = new ParameterizedTypeReference<>() {}; 
        MyClass returnValue = post("some text", typeRef, "/test");
    }
}

但是，我认为您应该考虑不依赖 {} 技巧的替代方案，这可能会出现问题。

你试过ParameterizedTypeReference的forType吗？：

public <T> T post(Object content, Class<T> returnType, String url){
        ParameterizedTypeReference<T> typeRef = ParameterizedTypeReference.forType(returnType);
        HttpEntity<Object> requestEntity = new HttpEntity<>(content);
        ResponseEntity<T> response = restTemplate.exchange(url, HttpMethod.POST, requestEntity, typeRef);
        return response.getBody();
}

在任何情况下，这都适用于对T 的非泛型分配，例如MyClass，就像将MyClass.class 作为返回类型传递时一样；它不适用于ArrayList<MyClass> list; list.getClass()，因为它等同于返回ArrayList.class。我猜在这些情况下，您需要构造并传递一个不同的 Type 实例，该实例对应于更复杂的类型表达式。

Answer 2

您不需要ParameterizedTypeReference，因为您没有参数化类型。只需使用直接接受Class 的overload：

ResponseEntity<T> response = restTemplate.exchange(url, HttpMethod.POST, requestEntity, returnType);