java - Jakson 多态枚举案例

Question

我对 Jackson 的多态问题很着迷。

我从事网络 JDR 角色编辑器个人项目。我使用 Springboot 并尝试坚持其哲学。此外，我尝试制作一些独立的包，因为我的实际工作(另一个 springboot 项目)的研究案例。

在没有 Jackson 配置的情况下，我的能力序列化没有问题。但是，当我尝试取回 Web 编辑器上的任何修改时，当 Jackson 对 Competence 进行反序列化时，“依赖”属性就会出现问题。

这是我的类(class):

我尝试序列化/反序列化的:

public class Competence implements Composante, ComposanteTemplate {    public enum Categorie {        APPRENTI,        COMPAGNON    }    private String nom;    private String description;    private Categorie categorie;    private Chapitre chapitre;    private AttributTemplate dependance;    private List sousCompetences = new ArrayList();    public String getNom() {        return nom;    }    public void setNom(String nom) {        this.nom = nom;    }    public String getDescription() {        return description;    }    public void setDescription(String description) {        this.description = description;    }    public Competence getTemplate() {        return this;    }    public Categorie getCategorie() {        return categorie;    }    public void setCategorie(Categorie categorie) {        this.categorie = categorie;    }    public Chapitre getChapitre() {        return chapitre;    }    public void setChapitre(Chapitre chapitre) {        this.chapitre = chapitre;    }    public AttributTemplate getDependance() {        return dependance;    }    public void setDependance(AttributTemplate dependance) {        this.dependance = dependance;    }    public List getSousCompetences() {        return sousCompetences;    }    public void setSousCompetences(List sousCompetences) {        this.sousCompetences = sousCompetences;    }    public boolean isOuverte() {        return !sousCompetences.isEmpty();    }}

The superclass of the property I have a problem with:

public interface AttributTemplate extends ComposanteTemplate {}

The two subclasses which could be use for Competence#dependance property:

public enum Carac implements AttributTemplate, Attribut {    FORT(Type.PHYSIQUE),    AGILE(Type.PHYSIQUE),    RESISTANT(Type.PHYSIQUE),    OBSERVATEUR(Type.PHYSIQUE),    SAVANT(Type.MENTALE),    RUSE(Type.MENTALE),    TALENTUEUX(Type.MENTALE),    CHARMEUR(Type.MENTALE);    public enum Type {        PHYSIQUE,        MENTALE    }    public final Type type;    public final String nom = name().toLowerCase();    private String description;    Carac(Type type) {        this.type = type;    }    @Override    public String getNom() { return nom; }    @Override    public String getDescription() { return description;  }    @Override    public Carac getTemplate() { return this; }    public void setDescription(String description) { this.description = description; }}

public enum ArtTemplate implements AttributTemplate {    ART_GUERRIER(2, 1),    ART_ETRANGE(1, 2),    ART_GUILDIEN(1, 1);    public static final String ART_PREFIX = "ART";    public final String nom = name().toLowerCase().replace("_", " ");    public final int nbCaracsPhysiques;    public final int nbCaracsMentales;    private String description;    ArtTemplate(int nbCaracsPhysiques, int nbCaracsMentales) {        this.nbCaracsMentales = nbCaracsMentales;        this.nbCaracsPhysiques = nbCaracsPhysiques;    }    @Override    public String getNom() {        return nom;    }    @Override    public String getDescription() {        return description;    }    public void setDescription(String description) {        this.description = description;    }    public int getNbCaracs() {        return nbCaracsPhysiques + nbCaracsMentales;    }}

The result json (and then the json I send) is:

{"nom":"Comp_1489746646510","description":"ezbuixnwrclfvmgwdviubcauenzytpzzvumnohwyhpuynxaqhkjdbqygtrmbtlschthovuyoiolkauucwokkfjnaujnufshrjboykuqce","categorie":"APPRENTI","chapitre":"GUERRE","dependance":"ART_ETRANGE","ouverte":false,"sousCompetences":[]}

QUESTION:I understand that my problem is caused by the abstract relation AttributTemplate, and then when Jackson try to deserialize, he does not know which of Carac or ArtTemplate class to use.I try to keep unchanged Competence (Competence come from an external jar), so no annotation on this class is possible.

I've tried many of the solutions I found (Jackson 1.5: Polymorphic Type Handling, first steps ) and the only one which has worked was to define a DeserializationProblemHandler

mapper.addHandler(new DeserializationProblemHandler() {
 @Override
 public Object handleMissingInstantiator(DeserializationContext ctxt, Class<?> instClass, JsonParser p, String msg) throws IOException {
     if (instClass == AttributTemplate.class) {
         String name = p.getText();
         return !name.startsWith(ArtTemplate.ART_PREFIX) ? Carac.valueOf(name) : ArtTemplate.valueOf(name);
     }
     return super.handleMissingInstantiator(ctxt, instClass, p, msg);
 }

});

但我对这个解决方案感觉不好，因为我确信还有另一个漂亮的解决方案。

那么是否可以配置映射器，以便他能够确定他必须使用 Carac 或 ArtTemplate 中的哪一个来获取 AttributTemplate？

<小时/>

编辑:我设法做到了:

{"nom":"Comp_1489756873433","description":"kruzueemlwisibshlkotasayfkhdqkqolvhlqgsnntndkpvbmmgklqysabiakaolempmupeyiqaztdcrhwimdksgzybbdzttwnwqjxhfo","categorie":"COMPAGNON","chapitre":"GUERRE","dependance":["mova.ged.perso.inne.Carac","AGILE"],"ouverte":true,"sousCompetences":[...]}

通过这样配置映射器

    abstract class CompetenceMixIn {        private AttributTemplate dependance;        @JsonTypeInfo(use=JsonTypeInfo.Id.CLASS, include=JsonTypeInfo.As.EXISTING_PROPERTY, property="dependance")        @JsonSubTypes({ @JsonSubTypes.Type(value = Carac.class, name = "carac"), @JsonSubTypes.Type(value = ArtTemplate.class, name = "artTemplate") })        public void setDependance(AttributTemplate dependance) {            this.dependance = dependance;        }    }

ObjectMapper mapper = jsonConverter.getObjectMapper();mapper.addMixIn(Competence.class, CompetenceMixIn.class);

如您所见，我仍然寄生在包装 dependance 值的数组中。我会 (...)"dependance": "AGILE", (...) 而不是 (...)"dependance":["mova.ged.perso.inne. Carac", "AGILE"], (...)
我不知道要改变什么才能得到这个。

Answer 1

我一直在研究你想做什么。不幸的是，我认为枚举+继承存在问题。

我有一个您可以使用的替代解决方案，即使用自定义创建器并忽略未知属性。请参阅以下示例:

public class JacksonInheritance {

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

        Competence c = new Competence();
        c.desc = "desc";
        c.nome = "nome";
        c.template = Att1.TEST_Att1;
        String test = mapper.writeValueAsString(c);
        System.out.println(test);

        Competence readValue = mapper.readValue(test, Competence.class);
        System.out.println(readValue.template);
    }

    @JsonIgnoreProperties(ignoreUnknown = true)
    public static class Competence {

        private static final Map<String, AttributeTemplate> templates;
        static {
            templates = new HashMap<>();
            Stream.of(Att1.values()).forEach( a -> templates.put(a.name(), a));
            Stream.of(Att2.values()).forEach( a -> templates.put(a.name(), a));
        }

        @JsonProperty
        String nome;
        @JsonProperty
        String desc;
        @JsonIgnore
        AttributeTemplate template;

        @JsonProperty("template_type")
        public String getTempl() {
            // Here you can do whichever way uou would like to serialise your template. This will be the key
            return template.toString();
        }

        @JsonCreator
        public static Competence create(@JsonProperty("template_type") String templateType) {
            Competence c = new Competence();
            c.template =  templates.get(templateType);
            return c;
        }
    }

    public static interface AttributeTemplate {
    }

    public static enum Att1 implements AttributeTemplate {
        TEST_Att1;
    }

    public static enum Att2 implements AttributeTemplate {

        TEST2_Att2;
    }
}

在这里，我将枚举逻辑与 jackson 逻辑分离并实现我自己的逻辑。这不需要自定义序列化。

我基本上是说，我将枚举序列化为其值(您显然可以选择您想要的属性)。

我的输出 json 如下所示:

{"template_type":"TEST_Att1","nome":"nome","desc":"desc"}

在返回步骤中，我现在知道从 template_type 属性构造正确的枚举模板类型所需的信息。这就是我可以注入(inject)到我的工厂方法 create 中的内容。

在创建中，我可以使用静态创建的映射将正确的枚举填充到我的对象中。我们可以静态地创建这个映射，因为我们的枚举是有限的和静态的。

这样做的好处还在于生成器仅用于创建。使用@JsonIgnoreProperties(ignoreUnknown = true)，我们可以告诉 Jackson 不要被 json 中的所有自定义元素吓坏。它只会反序列化它可以检测到的任何字段并保留其他字段(因为我们使用自定义 template_type 进行枚举解析)。

最后，我忽略了 bean 中实际的模板，因为 jackson 无法构造它。

我希望这对您有用/对您有帮助。抱歉耽搁了。

不使用继承的原因:

1. jackson 中的枚举+继承似乎存在问题。特别是 Jackson 默认使用反射并调用枚举的私有(private)构造函数进行生成。不过，您也许可以让创作者以与上述类似的方式工作。

2. 反序列化需要模板。我假设您不一定想要序列化枚举的所有元素。这是因为枚举名称(在我的例子中 TEST_Att1)使枚举变得唯一。无需序列化并发送这些枚举所具有的所有不同属性。然而，Deserialization with @JsonSubTypes for no value - missing property error显示 Jackson 要求您的模板字段至少存在。这是一个小问题，因为您想为此使用外部属性(所以为什么要按照 json 中的建议包含一个空字段，只是为了让 jackson 高兴)

这可能不是最好的解决方案，但考虑到限制，我认为它相对优雅。希望对您有帮助，

阿图尔