46

这是一个重复的问题，因为以下问题要么很混乱，要么根本没有答案：

用杰克逊反序列化通用类型

jackson-deserialize-into-runtime-specified-class

杰克逊反序列化使用通用类

杰克逊反序列化通用类变量

我希望这个问题最终能找到一个答案，让这个问题永远清晰。

有一个模型：

public class AgentResponse<T> {

    private T result;

    public AgentResponse(T result) {
        this.result = result;
    }
    public T getResult() {
        return result;
    }
}

JSON输入：

{"result":{"first-client-id":3,"test-mail-module":3,"third-client-id":3,"second-client-id":3}}

以及两种反序列化泛型类型的推荐方法：

mapper.readValue(out, new TypeReference<AgentResponse<Map<String, Integer>>>() {});

或者

JavaType javaType = mapper.getTypeFactory().constructParametricType(AgentResponse.class, Map.class);
mapper.readValue(out, javaType);

Jackson 永远无法处理泛型类型 T，它认为它是来自 JavaType 的 Map，但由于类型擦除，它找到了 Object 类型的构造函数参数并引发错误。那么这是杰克逊的错误，还是我做错了什么？TypeReference 或 JavaType 的显式规范还有什么用途？

com.fasterxml.jackson.databind.JsonMappingException: No suitable constructor found for type [simple type, class com.fg.mail.smtp.AgentResponse<java.util.Map<java.lang.String,java.lang.Integer>>]: can not instantiate from JSON object (need to add/enable type information?)
at [Source: java.io.InputStreamReader@4f2d26d; line: 1, column: 2]
at com.fasterxml.jackson.databind.JsonMappingException.from(JsonMappingException.java:164)
at com.fasterxml.jackson.databind.deser.BeanDeserializerBase.deserializeFromObjectUsingNonDefault(BeanDeserializerBase.java:984)
at com.fasterxml.jackson.databind.deser.BeanDeserializer.deserializeFromObject(BeanDeserializer.java:276)
at com.fasterxml.jackson.databind.deser.BeanDeserializer.deserialize(BeanDeserializer.java:121)
at com.fasterxml.jackson.databind.ObjectMapper._readMapAndClose(ObjectMapper.java:2888)
at com.fasterxml.jackson.databind.ObjectMapper.readValue(ObjectMapper.java:2064)
4

6 回答 6

57

您需要在构造函数上添加一些注释来告诉杰克逊如何构建对象。以下对我有用：

public class AgentResponse<T> {

    private T result;

    @JsonCreator
    public AgentResponse(@JsonProperty("result") T result) {
        this.result = result;
    }
    public T getResult() {
        return result;
    }
}

如果没有@JsonCreator注解，Jackson 无法知道调用此构造函数。如果没有@JsonProperty注释，杰克逊不知道构造函数的第一个参数映射到result属性。

于 2013-07-01T12:14:28.950 回答
8

我尝试使用相同的方法，但我没有注释我的模型类。它对我来说很好。

这是我的模型课

public class BasicMessage<T extends Serializable> implements Message<T> {
    private MessageHeader messageHeader = new MessageHeader();
    private T payload;
    public MessageHeader getHeaders() {
        return messageHeader;
    }

    public Object getHeader(String key) {
        return messageHeader.get(key);
    }

    public Object addHeader(String key, Object header) {
        return messageHeader.put(key, header);
    }

    public T getPayload() {
        return payload;
    }

    public void setPayload(T messageBody) {
        this.payload = messageBody;
    }
}

我使用以下方法对有效负载进行反序列化

public static <T extends Serializable> BasicMessage<T> getConcreteMessageType(String jsonString, Class<T> classType) {
        try {
            ObjectMapper mapper = new ObjectMapper();
            JavaType javaType = mapper.getTypeFactory().constructParametricType(BasicMessage.class, classType);
            return mapper.readValue(jsonString, javaType);
        } catch (IOException e) {

        }
 }

其中 jsonString 包含字符串中的 BasicMessageObject。

于 2016-08-18T11:37:25.657 回答
2

如果您以编程方式java.lang.reflect.Type从例如方法返回类型或字段中获取，那么它最容易使用

Type type = obj.getClass().getDeclaredField( "aKnownFieldName" ).getGenericType(); 
// or
Type type = obj.getClass().getDeclaredMethod( "aKnownMethod" ).getGenericReturnType(); 


ObjectMapper mapper = new ObjectMapper();
JavaType javaType = mapper.getTypeFactory().constructType( type );
Object value = mapper.readValue( json, javaType );

创建了一个完全嵌套的 JavaType，因此Controller<PID<Temperature,Double>>>将正确反序列化。

于 2019-08-08T05:33:28.247 回答
1

需要反序列化的 JSON 字符串必须包含有关参数的类型信息T。
您必须在可以作为参数传递T给类的每个类上放置 Jackson 注释，以便 Jackson可以从 JSON 字符串读取/写入AgentResponse有关参数类型的类型信息。T

让我们假设它T可以是任何扩展抽象类的类Result。

public class AgentResponse<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 {

}

一旦可以作为参数传递的每个类（或其公共超类型）都被注释，Jackson 将在 JSON 中T 包含有关参数的信息。T然后可以T在编译时不知道参数的情况下反序列化此类 JSON。
这个杰克逊文档链接讨论了多态反序列化，但也可以参考这个问题。

于 2018-02-20T08:17:23.713 回答
0 
public class AgentResponse<T> {

private T result;

public AgentResponse(T result) {
    this.result = result;
}
public T getResult() {
    return result;
}

}

所以对于上面的类结构，T可以是T1，T2类

因此，要反序列化 AgentResponse，请使用以下代码

JavaType javaType = objectMapper.getTypeFactory.constructParametricType(AgentResponse.class,T1.class)
AgentResponse<T1> agentResponseT1 = objectMapper.readValue(inputJson,javaType);
于 2018-11-22T15:41:07.223 回答
0

解决方案 ：

使用 TypeReference 而不是类

 public T getObject(String json, TypeReference typeReference) throws JsonParseException, JsonMappingException, IOException{
      ObjectMapper mapper = new ObjectMapper();
      mapper.configure(DeserializationFeature.UNWRAP_ROOT_VALUE, true);
     T t = (T) mapper.readValue(json, typeReference);
      return t;
   }

我的 Pojo 结构

    public class SQSRequest<T> implements Serializable {    
    private T data;
    private String msgId;
    private String msgGroupId;
    .... 
}


        
 public class EmailDetails implements Serializable {
     private Map<String,String> paramMap;
        .... 
}

采用

SQSRequest<EmailDetails> req2=this.getObject(str, new TypeReference<SQSRequest<EmailDetails>>() {});
于 2021-04-07T07:38:36.200 回答