为什么Jackson的ObjectMapper方法采用原始的TypeReference(Why Jackson’s ObjectMapper methods take raw TypeReference)

 Jackson 2 ObjectMapper类定义了许多用于将JSON字符串，字节数组，文件等反序列化为给定Java类型的通用方法。 
 
 目标类型在这些方法的参数中给出。 
 
 例如。 类型可以作为Class<T> ，就像在方法中一样 
 
public <T> T readValue(String content, Class<T> valueType)
 
 它返回相同的T对象（因此是类型安全的）。 
 
 但它也可以作为TypeReference<T> （可以编码复杂的泛型类型）给出，因此可以构建例如。 new TypeReference<List<Long>> { }告诉ObjectMapper需要将输入反序列化为longs列表 - 例如，可以传递它。 进入方法： 
 
@SuppressWarnings({ "unchecked", "rawtypes" })
public <T> T readValue(String content, TypeReference valueTypeRef)
 
 但是该方法采用原始 TypeReference而不是通用TypeReference<T> ，因此需要手动向调用添加泛型参数： 
 
objectMapper.<List<Long>>readValue(input, listOfLongs)
 
 如果在提供的类型中出错，编译器就无法捕获它。 如果方法签名是，那将不是问题 
 
public <T> T readValue(String content, TypeReference<T> valueTypeRef)
 
 这将告诉编译器返回的值始终与提供的TypeReference的泛型参数的类型相同，类似于它与Class<T> 。 
 
 我的问题是 - 这种API背后的原因是什么？ 为什么Jackson方法采用原始TypeReference ？ 当返回的对象实际上是TypeReference的泛型参数引用的不同类型时，是否存在任何有效的情况？ 
 
 PS：还有什么让我感到困惑的是，相应的convertValue方法不是原始类型，而是通配符： 
 
public <T> T convertValue(Object fromValue, TypeReference<?> toValueTypeRef)
 
 和类似的readValues ： 
 
public <T> MappingIterator<T> readValues(JsonParser p, TypeReference<?> valueTypeRef)
 
 readValue(JsonParser, TypeReference)实际上采用了一个完全限定的泛型参数 ： 
 
public <T> T readValue(JsonParser p, TypeReference<T> valueTypeRef)

Jackson 2 ObjectMapper class defines numerous generic methods for deserializing JSON strings, byte arrays, files, etc. to given Java types.
 
Target type is given in an argument to those methods.
 
Eg. a type may be given as a Class<T>, like in the method
 
public <T> T readValue(String content, Class<T> valueType)
 
which returns the same T object (and thus is type-safe to use).
 
But it may also be given as a TypeReference<T> (which can encode a complex generic type), so one can build eg. new TypeReference<List<Long>> { } to tell ObjectMapper that the input needs to be deserialized into a list of longs – it can be passed eg. into the method:
 
@SuppressWarnings({ "unchecked", "rawtypes" })
public <T> T readValue(String content, TypeReference valueTypeRef)
 
But that method takes raw TypeReference and not a generic TypeReference<T>, and thus one needs to manually add a generic parameter to the call:
 
objectMapper.<List<Long>>readValue(input, listOfLongs)
 
and if one makes a mistake in the provided type, the compiler cannot catch that. That would not be a problem if the method signature was
 
public <T> T readValue(String content, TypeReference<T> valueTypeRef)
 
which would tell the compiler that the returned value is always of the same type as the generic parameter of provided TypeReference, similarly to how it works with Class<T>.
 
My question is – what is the reason behind such an API? Why do Jackson methods take raw TypeReference? Are there any valid cases when returned object is really of a different type that that referenced by generic parameter of TypeReference?
 
PS: What also puzzles me is that a corresponding convertValue method takes not a raw type, but a wildcard one:
 
public <T> T convertValue(Object fromValue, TypeReference<?> toValueTypeRef)
 
and similarly readValues:
 
public <T> MappingIterator<T> readValues(JsonParser p, TypeReference<?> valueTypeRef)
 
and the readValue(JsonParser, TypeReference) actually takes a fully qualified generic parameter:
 
public <T> T readValue(JsonParser p, TypeReference<T> valueTypeRef)

原文：https://stackoverflow.com/questions/48401520