与杰克逊

Question

反序列化复杂的Json我遇到了一个问题，用“复杂” JSON：

{ 
    "Books": [ 
    { 
     "title": "Java", 
     "instructions": [], 
     "links": { 
     "EJB": { 
      "href": "www.java.com/EJB" 
     } 
     } 
    }, 
    { 
     "title": "C#", 
     "instructions": [], 
     "links": { 
     "SOAP": { 
      "href": "www.C#.com/SOAP" 
     } 
     } 
    }] 
} 

谁能告诉我如何反序列化这种JSON来获得POJO的名单吗？

该POJO必须是一个“书”有3个字段：标题，说明和链接

谢谢。

Answer 1

你POJO类看起来是这样的：

class Books { 

    @JsonProperty("Books") 
    private List<Book> books; 

    public List<Book> getBooks() { 
     return books; 
    } 

    public void setBooks(List<Book> books) { 
     this.books = books; 
    } 

    @Override 
    public String toString() { 
     return "Books [books=" + books + "]"; 
    } 
} 

class Book { 

    private String title; 
    private List<String> instructions; 
    private Map<String, Link> links; 

    public String getTitle() { 
     return title; 
    } 

    public void setTitle(String title) { 
     this.title = title; 
    } 

    public List<String> getInstructions() { 
     return instructions; 
    } 

    public void setInstructions(List<String> instructions) { 
     this.instructions = instructions; 
    } 

    public Map<String, Link> getLinks() { 
     return links; 
    } 

    public void setLinks(Map<String, Link> links) { 
     this.links = links; 
    } 

    @Override 
    public String toString() { 
     return "Book [title=" + title + ", instructions=" + instructions + ", links=" + links + "]"; 
    } 
} 

class Link { 

    private String href; 

    public String getHref() { 
     return href; 
    } 

    public void setHref(String href) { 
     this.href = href; 
    } 

    @Override 
    public String toString() { 
     return href; 
    } 
} 

简单的用法：

ObjectMapper mapper = new ObjectMapper(); 

System.out.println(mapper.readValue(json, Books.class)); 

上面的程序打印：

Books [books=[Book [title=Java, instructions=[], links={EJB=www.java.com/EJB}], Book [title=C#, instructions=[], links={SOAP=www.C#.com/SOAP}]]] 

Answer 2

对于初学者来说，你的JSON有一个基本问题;你有重复的成员名称。

而在这种情况下，解析器的行为是undefined（RFC 7159, section 4）。由于jsonschema2pojo使用杰克逊，这意味着您将获得每个重复成员的定义值最后。

使用数组：

[ 
{ 
    "title":"Title 1", 
    "instructions" : [], 
    "links": { 
    "link 1": { 
     "href": "The link 1" 
    } 
    } 
}, 
{ 
    "title":"Title 2", 
    "instructions" : [], 
    "links": { 
    "link 2": { 
     "href": "The link 2" 
    } 
    } 
} 
] 

然后，jsonschema2pojo不会真的反序列化到一个POJO;你真正想要的是定义MyClass类的数组元素（即一个对象），并使用杰克逊的ObjectMapper反序列化：

final TypeReference<List<MyClass>> typeref 
    = new TypeReference<List<MyClass>>() {}; 

final ObjectMapper mapper = new ObjectMapper(); 

final List<MyClass> list = mapper.readValue(whatever, typeref);