如果泛型类型仅动态可用，则需要显式构建JavaType：

// do NOT create new ObjectMapper per each request!
final ObjectMapper mapper = new ObjectMapper();

public Json<T> void deSerialize(Class<T> clazz, InputStream json) {
    return mapper.readValue(json,
      mapper.getTypeFactory().constructParametricType(Json.class, clazz));
}

通用反序列化接口示例：

public interface Deserializable<T> {
    static final ObjectMapper mapper = new ObjectMapper();

    @SuppressWarnings("unchecked")
    default T deserialize(String rawJson) throws IOException {
        return mapper.readValue(rawJson, (Class<T>) this.getClass());
    }
}

您正在将Class对象序列化和反序列化为JSON？也许可以在Hit中将其保留为String，并创建额外的getter来启动Class.forName，例如。

public class Hit {
    public String id;
    public String data;
    public Class<?> getDataClass() throws Exception {
       return Class.forName(data);
    }
}

对我来说，类似的事情在类似的情况下也起过作用

public <T> T jsonToObject(String jsonContainsObject, Class<T> objectType) {
       ObjectMapper objectMapper = new ObjectMapper();
       try {
         return objectMapper.readValue(jsonContainsObject, objectType);
       } catch (JsonProcessingException e) {
         //Your exception handling
       }
    return null; 
}

需要反序列化的JSON字符串必须包含有关参数T的类型信息。
您必须在每个类上放置Jackson注解，这些类可以作为参数T传递给类Json，以便Jackson可以从JSON字符串读取参数类型T的类型信息，也可以将其写入JSON字符串。
让我们假设T可以是扩展抽象类Result的任何类。

public class Json<T extends Result> {
    public Hits<T> hits;
}

@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.WRAPPER_OBJECT)
@JsonSubTypes({
        @JsonSubTypes.Type(value = ImageResult.class, name = "ImageResult"),
        @JsonSubTypes.Type(value = NewsResult.class, name = "NewsResult")})
public abstract class Result {

}

public class ImageResult extends Result {

}

public class NewsResult extends Result {

}

当每个类（或者它们的公共超类型）都被标注为参数T时，Jackson会在JSON中包含参数T的信息，这样就可以在编译时反序列化JSON，而不需要知道参数T。
这个Jackson documentation link讨论了多态反序列化，但对于这个问题也很有用。

反序列化泛型类变量
...
我该怎么跟Jackson说？杰森会做得更好吗？
Gson用户指南中有一节详细介绍了我所理解的您要实现的目标，尽管该文档示例可能还不完整。
在一篇博客文章中，我更详细地介绍了使用Gson 1.7.1的解决方案。
在同一篇博客文章中，还演示和描述了使用Jackson（1.8.2）的类似（但更复杂）解决方案（不同的方法和示例使用数百行代码，所以我在这里省略了重新发布它们）。

public class GsonInstanceCreatorForParameterizedTypeDemo  
{  
 public static void main(String[] args)  
 {  
  Id<String> id1 = new Id<String>(String.class, 42);  
  
  Gson gson = new GsonBuilder().registerTypeAdapter(Id.class,  
    new IdInstanceCreator()).create();  
  String json1 = gson.toJson(id1);  
  System.out.println(json1);  
  // actual output: {"classOfId":{},"value":42}  
  // This contradicts what the Gson docs say happens.  
  // With custom serialization, as described in a  
  // previous Gson user guide section,   
  // intended output may be   
  // {"value":42}  
  
  // input: {"value":42}  
  String json2 = "{\"value\":42}";  
  
  Type idOfStringType=new TypeToken<Id<String>>(){}.getType();  
  Id<String> id1Copy = gson.fromJson(json2, idOfStringType);  
  System.out.println(id1Copy);  
  // output: classOfId=class java.lang.String, value=42  
  
  Type idOfGsonType = new TypeToken<Id<Gson>>() {}.getType();  
  Id<Gson> idOfGson = gson.fromJson(json2, idOfGsonType);  
  System.out.println(idOfGson);  
  // output: classOfId=class com.google.gson.Gson, value=42  
 }  
}  
  
class Id<T>  
{  
 private final Class<T> classOfId;  
 private final long value;  
  
 public Id(Class<T> classOfId, long value)  
 {  
  this.classOfId = classOfId;  
  this.value = value;  
 }  
  
 @Override  
 public String toString()  
 {  
  return "classOfId=" + classOfId + ", value=" + value;  
 }  
}  
  
class IdInstanceCreator implements InstanceCreator<Id<?>>  
{  
 @SuppressWarnings({ "unchecked", "rawtypes" })  
 public Id<?> createInstance(Type type)  
 {  
  Type[] typeParameters =   
    ((ParameterizedType) type).getActualTypeArguments();  
  Type idType = typeParameters[0];  
  return new Id((Class<?>) idType, 0L);  
 }  
}