我正在尝试完成程序员 Bruce 的教程，该教程应该允许对多态 JSON 进行反序列化。

完整的列表可以在这里找到 Programmer Bruce tutorials (顺便说一句，很棒的东西)

我已经完成了前五个，没有任何问题，但我在最后一个(示例 6)上遇到了障碍，这当然是我真正需要开始工作的那个。

我在编译时收到以下错误

The method readValue(JsonParser, Class) in the type ObjectMapper is not applicable for the arguments (ObjectNode, Class)

这是由代码块引起的

  public Animal deserialize(  
      JsonParser jp, DeserializationContext ctxt)   
      throws IOException, JsonProcessingException  
  {  
    ObjectMapper mapper = (ObjectMapper) jp.getCodec();  
    ObjectNode root = (ObjectNode) mapper.readTree(jp);  
    Class<? extends Animal> animalClass = null;  
    Iterator<Entry<String, JsonNode>> elementsIterator =   
        root.getFields();  
    while (elementsIterator.hasNext())  
    {  
      Entry<String, JsonNode> element=elementsIterator.next();  
      String name = element.getKey();  
      if (registry.containsKey(name))  
      {  
        animalClass = registry.get(name);  
        break;  
      }  
    }  
    if (animalClass == null) return null;  
    return mapper.readValue(root, animalClass);
  }  
} 

具体按行

return mapper.readValue(root, animalClass);

以前有没有人遇到过这种情况，如果有，有解决办法吗？

任何人都可以提供任何帮助，我将不胜感激 提前致谢 乔恩 D.

最佳答案

正如我所 promise 的，我正在举一个例子来说明如何使用注释来序列化/反序列化多态对象，我在你正在阅读的教程中的 Animal 类中建立了这个例子。

首先你的 Animal 类带有子类的 Json 注释。

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonSubTypes;
import com.fasterxml.jackson.annotation.JsonTypeInfo;

@JsonIgnoreProperties(ignoreUnknown = true)
@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.PROPERTY)
@JsonSubTypes({
    @JsonSubTypes.Type(value = Dog.class, name = "Dog"),

    @JsonSubTypes.Type(value = Cat.class, name = "Cat") }
)
public abstract class Animal {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

然后是你的子类，Dog 和 Cat。

public class Dog extends Animal {

    private String breed;

    public Dog() {

    }

    public Dog(String name, String breed) {
        setName(name);
        setBreed(breed);
    }

    public String getBreed() {
        return breed;
    }

    public void setBreed(String breed) {
        this.breed = breed;
    }
}

public class Cat extends Animal {

    public String getFavoriteToy() {
        return favoriteToy;
    }

    public Cat() {}

    public Cat(String name, String favoriteToy) {
        setName(name);
        setFavoriteToy(favoriteToy);
    }

    public void setFavoriteToy(String favoriteToy) {
        this.favoriteToy = favoriteToy;
    }

    private String favoriteToy;

}

如您所见，Cat 和 Dog 并没有什么特别之处，唯一了解它们的是 abstract 类 Animal，因此在反序列化时，您将定位到 Animal 并且 ObjectMapper 将返回实际实例，如下面的测试所示:

public class Test {

    public static void main(String[] args) {

        ObjectMapper objectMapper = new ObjectMapper();

        Animal myDog = new Dog("ruffus","english shepherd");

        Animal myCat = new Cat("goya", "mice");

        try {
            String dogJson = objectMapper.writeValueAsString(myDog);

            System.out.println(dogJson);

            Animal deserializedDog = objectMapper.readValue(dogJson, Animal.class);

            System.out.println("Deserialized dogJson Class: " + deserializedDog.getClass().getSimpleName());

            String catJson = objectMapper.writeValueAsString(myCat);

            Animal deseriliazedCat = objectMapper.readValue(catJson, Animal.class);

            System.out.println("Deserialized catJson Class: " + deseriliazedCat.getClass().getSimpleName());



        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

运行Test类后的输出:

{"@type":"Dog","name":"ruffus","breed":"english shepherd"}

反序列化的 dogJson 类:Dog

{"@type":"Cat","name":"goya","favoriteToy":"mice"}

反序列化的 catJson 类:猫

希望这会有所帮助，

何塞·路易斯

关于java - 使用 Jackson 将 JSON 反序列化为多态类型 - 一个完整的示例给了我一个编译错误，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/30362446/