Java 子类的Jackson序列化

在下面的示例中，我有一个主类-a和它的子类-B。它们都可以用作一般类X中的属性

public class A
{
   @JsonProperty("primary_key")
   public final String primaryKey;

   @JsonCreator
   A(@JsonProperty("primary_key") String primaryKey)
   {
        this.primaryKey = primaryKey;
   }
}
public class B extends A
{
   @JsonProperty("secondary_key")
   public final String secondaryKey;

   @JsonCreator
   B(@JsonProperty("primary_key") String primaryKey, @JsonProperty("secondary_key") String secondaryKey)
   {
        super(primaryKey);
        this.secondaryKey = secondaryKey;
   }
}

public class X
{
    @JsonProperty("keys")
    public final A keys;

    @JsonCreator
    X(@JsonProperty("keys") A keys)
    {
         this.keys = keys;
    }
}

如何使用Jackson多态特性将以下给定的json正确反序列化为各自的类：

JSON A:

 { "keys" :{
              "primary_key" : "abc"
          }
 }

JSON B:

 { "keys" : {
              "primary_key" : "abc",
              "secondary_key" : "xyz"
         }
    }

预期结果：将keys对象映射到JSON A的类A和JSON B的类B

---

也请提供其他建议。

如果我正确理解，只需传递值即可，无需任何配置。我相信这就是你想要的：

public class Test {

    private static final String JSON = "{\"keys\":{\"primary_key\":\"abc\",\"secondary_key\":\"xyz\"}}";

    public static void main(String[] args) throws IOException {

        ObjectMapper mapper = new ObjectMapper();
        X x = mapper.readValue(JSON, X.class);
        System.out.println(mapper.writeValueAsString(x));

    }
}

class A {
    private String primary_key;

    public String getPrimary_key() {
        return primary_key;
    }

    public void setPrimary_key(String primary_key) {
        this.primary_key = primary_key;
    }
}

class B extends A {

    private String secondary_key;

    public String getSecondary_key() {
        return secondary_key;
    }

    public void setSecondary_key(String secondary_key) {
        this.secondary_key = secondary_key;
    }
}

class X {

    private B keys;

    public B getKeys() {
        return keys;
    }

    public void setKeys(B keys) {
        this.keys = keys;
    }
}

输出将是：

{"keys":{"primary_key":"abc","secondary_key":"xyz"}}

---

如果这不是您所期望的，请提供另一个解释，我将根据需要编辑答案。

这感觉像是一个非常常见的问题，没有简单的方法来解决它（或者我只是找不到）：

您可以做的一件事是将自定义反序列化器添加到对象映射器中。下面是这种方法的一个很好的演示：

下面是与您的示例相关的演示：

import com.fasterxml.jackson.annotation.*;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.ObjectCodec;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.module.SimpleModule;

import java.io.IOException;

public class Main4 {


private static final String jsonA = "{ \"keys\" : { \"primary_key\" : \"abc\" } }";
private static final String jsonB = 
        "{ \"keys\" : { \"primary_key\" : \"abc\", \"secondary_key\" : \"xyz\" } }";

public static void main(String[] args) throws IOException {
    ObjectMapper mapper = new ObjectMapper();

    SimpleModule idAsRefModule = new SimpleModule("ID-to-ref");
    idAsRefModule.addDeserializer(A.class, new AJsonDeserializer());
    mapper.registerModule(idAsRefModule);

    X tl = mapper.readValue(jsonA, X.class);
    System.out.println(tl);

    X t2 = mapper.readValue(jsonB, X.class);
    System.out.println(t2);
}

public static class AJsonDeserializer  extends JsonDeserializer<A>{

    @Override
    public A deserialize(JsonParser jp, DeserializationContext dc)
    throws IOException {

        ObjectCodec codec = jp.getCodec();
        JsonNode node = codec.readTree(jp);

        if (node.has("secondary_key")) {
            return codec.treeToValue(node, B.class);
        }
        return new A(node.findValue("primary_key").asText());
    }
}

public static class A
{
    @JsonProperty("primary_key")
    public final String primaryKey;

    @JsonCreator
    A(@JsonProperty("primary_key") String primaryKey)
    {
        this.primaryKey = primaryKey;
    }

    @Override
    public String toString() {
        return "A{" +
                "primaryKey='" + primaryKey + '\'' +
                '}';
    }
}

public static class B extends A
{
    @JsonProperty("secondary_key")
    public final String secondaryKey;

    @JsonCreator
    B(@JsonProperty("primary_key") String primaryKey, 
      @JsonProperty("secondary_key") String secondaryKey)
    {
        super(primaryKey);
        this.secondaryKey = secondaryKey;
    }

    @Override
    public String toString() {
        return "B{" +
                "primaryKey='" + primaryKey + '\'' +
                "secondaryKey='" + secondaryKey + '\'' +
                '}';
    }
}

public static class X
{
    @JsonProperty("keys")
    public final A keys;

    @JsonCreator
    X(@JsonProperty("keys") A keys)
    {
        this.keys = keys;
    }

    @Override
    public String toString() {
        return "X{" +
                "keys=" + keys +
                '}';
    }
}
}

import com.fasterxml.jackson.annotation.*；
导入com.fasterxml.jackson.core.JsonParser；
导入com.fasterxml.jackson.core.ObjectCodec；
导入com.fasterxml.jackson.databind.*；
导入com.fasterxml.jackson.databind.module.SimpleModule；
导入java.io.IOException；
公共类main 4{
私有静态最终字符串jsonA=“{\'keys\”：{\'primary\u key\”：\'abc\'}”；
私有静态最终字符串jsonB=
“{\'keys\'：{\'primary\'u key\'：\'abc\'，\'secondary\'u key\'：\'xyz\'}”；
公共静态void main（字符串[]args）引发IOException{
ObjectMapper mapper=新的ObjectMapper（）；
SimpleModule idAsRefModule=新的SimpleModule（“ID到ref”）；
addDeserializer（A.class，新的AJsonDeserializer（））；
mapper.registerModule（idAsRefModule）；
X tl=mapper.readValue（jsonA，X.class）；
系统输出打印项次（tl）；
x2=mapper.readValue（jsonB，X.class）；
系统输出打印项次（t2）；
}
公共静态类AJsonDeserializer extends JsonDeserializer
İt不清楚您的实际结果和预期结果是什么？@YusufK。我想将第一个json映射到类A，第二个json映射到类B。我想您想从每个给定的json创建对象吗？是@YusufK。我想从给定的json创建对象。如果（给定json包含“secondary_key”），那么X中的keys对象应该属于B，否则X中的keys对象应该属于A