Java Jackson和泛型类型引用

我想将jackson json库用于以下通用方法：

public MyRequest<T> tester() {
    TypeReference<MyWrapper<T>> typeRef = new TypeReference<MyWrapper<T>>();  
    MyWrapper<T> requestWrapper = (MyWrapper<T>) JsonConverter.fromJson(jsonRequest, typeRef);
    return requestWrapper.getRequest();
}

publicMyRequestTester（）{
TypeReference typeRef=新的TypeReference（）；
MyWrapper requestWrapper=（MyWrapper）JsonConverter.fromJson（jsonRequest，typeRef）；
返回requestWrapper.getRequest（）；
}

公共类MyWrapper{
私人MyRequest请求；
公共MyRequest getRequest（）{
返回请求；
}
公共无效设置请求（MyRequest）{
this.request=请求；
}
}

公共类MyRequest{
私有列表对象；
public void setMyObjects（列表ets）{
this.myobjects=ets；
}
@NotNull
@杰索尼奥雷
公共T getMyObject（）{
返回myobjects.get（0）；
}
}

---

现在的问题是，当我调用请求对象内部的getMyObject（）时，Jackson将嵌套的自定义对象作为LinkedHashMap返回。是否有任何方式可以指定T对象需要返回？例如：如果我发送了Customer类型的对象，那么应该从该列表返回Customer？

这是Java类型擦除的一个众所周知的问题：T只是一个类型变量，您必须指明实际的类，通常作为类参数。没有这些信息，最好的办法就是使用边界；普通的T和“T扩展对象”大致相同。然后Jackson将JSON对象绑定为映射

在这种情况下，tester方法需要具有类的访问权限，并且您可以构造

JavaType type = mapper.getTypeFactory().
  constructCollectionType(List.class, Foo.class)

然后

List<Foo> list = mapper.readValue(new File("input.json"), type);

List List=mapper.readValue（新文件（“input.json”），类型）；

“JavaType”很有效！！ 我试图将json字符串中的列表解组（反序列化）到ArrayList java对象，从几天以来一直在努力寻找解决方案。
下面是最终为我提供解决方案的代码。 代码：

JsonMarshallerUnmarshaller{
T目标类；
公共ArrayList解组（字符串jsonString）{
ObjectMapper mapper=新的ObjectMapper（）；
AnnotationIntrospector Interspector=新的JacksonAnnotationInterspector（）；
getDeserializationConfig（）映射器
.带注释引导者（内省者）；
mapper.getSerializationConfig（）
.带注释引导者（内省者）；
JavaType=mapper.getTypeFactory（）。
构造集合类型(
ArrayList.class，
targetclass.getClass（））；
试一试{
类别c1=this.targetclass.getClass（）；
类c2=this.targetclass1.getClass（）；
ArrayList温度=（ArrayList）
readValue（jsonString，类型）；
返回温度；
}捕获（JSONParsee异常）{
e、 printStackTrace（）；
}捕获（JsonMappingException e）{
e、 printStackTrace（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
返回null；
}  
}

我修改后加入了一个工作示例

JsonMarshaller.java

import java.io.*；
导入java.util.*；
公共类JsonMarshaller{
私有静态类加载器=JsonMarshaller.class.getClassLoader（）；
公共静态void main（字符串[]args）{
试一试{
JsonMarshallerUnmarshaller marshaller=new-JsonMarshallerUnmarshaller（Station.class）；
字符串jsonString=read（loader.getResourceAsStream（“data.json”）；
List stations=marshaller.unmarshal（jsonString）；
stations.forEach（System.out:：println）；
系统输出打印LN（封送员、封送员（站））；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
@抑制警告（“资源”）
公共静态字符串读取（InputStream ios）{
返回新扫描仪（ios）。使用分隔符（\\A”）。下一步（）；//读取整个文件
}
}

输出 JsonMarshallerUnmarshaller.java

import java.io.*；
导入java.util.List；
导入com.fasterxml.jackson.core.*；
导入com.fasterxml.jackson.databind.*；
导入com.fasterxml.jackson.databind.introspect.JacksonAnnotationIntrospector；
公共类JsonMarshallerUnmarshaller{
私有对象映射器映射器；
私有类targetClass；
公共JsonMarshallerUnmarshaller（类targetClass）{
AnnotationIntrospector Interspector=新的JacksonAnnotationInterspector（）；
映射器=新的ObjectMapper（）；
带有（introspector）的mapper.getDeserializationConfig（）；
带有（introspector）的mapper.getSerializationConfig（）；
this.targetClass=targetClass；
}
公共列表解组（字符串jsonString）抛出JsonParseException、JsonMappingException、IOException{
返回parseList（jsonString、mapper、targetClass）；
}
公共字符串封送处理（列表）抛出JsonProcessingException{
返回mapper.writeValueAsString（列表）；
}
公共静态列表parseList（字符串str、对象映射器映射器、类clazz）
抛出JsonParseException、JsonMappingException、IOException{
返回mapper.readValue（str，listType（mapper，clazz））；
}
公共静态列表parseList（InputStream是，ObjectMapper映射器，类clazz）
抛出JsonParseException、JsonMappingException、IOException{
返回mapper.readValue（is，listType（mapper，clazz））；
}
公共静态JavaType listType（对象映射器映射器，类clazz）{
返回mapper.getTypeFactory（）.ConstructionCollectionType（List.class，clazz）；
}
}

Station.java

公共类电台{
私人长id；
私有字符串标题；
私有字符串名称；
公共长getId（）{
返回id；
}
公共无效集合id（长id）{
this.id=id；
}
公共字符串getTitle（）{
返回标题；
}
公共无效集合标题（字符串标题）{
this.title=标题；
}
公共字符串getName（）{
返回名称；
}
公共void集合名（字符串名）{
this.name=名称；
}
@凌驾
公共字符串toSt
JavaType type = mapper.getTypeFactory().
  constructCollectionType(List.class, Foo.class)

List<Foo> list = mapper.readValue(new File("input.json"), type);

JsonMarshallerUnmarshaller<T> {
    T targetClass;

    public ArrayList<T> unmarshal(String jsonString) {
        ObjectMapper mapper = new ObjectMapper();

        AnnotationIntrospector introspector = new JacksonAnnotationIntrospector();
        mapper.getDeserializationConfig()
            .withAnnotationIntrospector(introspector);

        mapper.getSerializationConfig()
            .withAnnotationIntrospector(introspector);
        JavaType type = mapper.getTypeFactory().
            constructCollectionType(
                ArrayList.class, 
                targetclass.getClass());

        try {
            Class c1 = this.targetclass.getClass();
            Class c2 = this.targetclass1.getClass();
            ArrayList<T> temp = (ArrayList<T>) 
                mapper.readValue(jsonString,  type);
            return temp ;
        } catch (JsonParseException e) {
            e.printStackTrace();
        } catch (JsonMappingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        return null ;
    }  
}

Station [id=123, title=my title, name=my name]
Station [id=456, title=my title 2, name=my name 2]
[{"id":123,"title":"my title","name":"my name"},{"id":456,"title":"my title 2","name":"my name 2"}]