Comment désérialiser une classe avec des constructeurs surchargés à l'aide de JsonCreator

- Il encore vrai pour Jackson databind 2.7.0.

La Jackson @JsonCreator annotation de 2,5 javadoc ou Jackson annotations de la documentation grammaire (constructeurs et de l'usine méthodes) laissent croire en effet que l'on peut marque plusieurs constructeurs.

Marqueur d'annotation qui peut être utilisé pour définir des constructeurs et de l'usine méthodes à utiliser pour l'instanciation de nouvelles instances de la classe associée.

Regardant le code où la créateurs sont identifiés, il semble que Jackson CreatorCollector est ignorant constructeurs surchargés, car il ne vérifie le premier argument du constructeur.

Class<?> oldType = oldOne.getRawParameterType(0);
Class<?> newType = newOne.getRawParameterType(0);

if (oldType == newType) {
    throw new IllegalArgumentException("Conflicting "+TYPE_DESCS[typeIndex]
           +" creators: already had explicitly marked "+oldOne+", encountered "+newOne);
}

• oldOne est le premier constructeur créateur.
• newOne est la surcharge de constructeur créateur.

Qui signifie que le code comme ça ne fonctionne pas

@JsonCreator
public Phone(@JsonProperty("value") String value) {
    this.value = value;
    this.country = "";
}

@JsonCreator
public Phone(@JsonProperty("country") String country, @JsonProperty("value") String value) {
    this.value = value;
    this.country = country;
}

assertThat(new ObjectMapper().readValue("{\"value\":\"+336\"}", Phone.class).value).isEqualTo("+336"); //raise error here
assertThat(new ObjectMapper().readValue("{\"value\":\"+336\"}", Phone.class).value).isEqualTo("+336");

Mais ce code fonctionne :

@JsonCreator
public Phone(@JsonProperty("value") String value) {
    this.value = value;
    enabled = true;
}

@JsonCreator
public Phone(@JsonProperty("enabled") Boolean enabled, @JsonProperty("value") String value) {
    this.value = value;
    this.enabled = enabled;
}

assertThat(new ObjectMapper().readValue("{\"value\":\"+336\"}", Phone.class).value).isEqualTo("+336");
assertThat(new ObjectMapper().readValue("{\"value\":\"+336\",\"enabled\":true}", Phone.class).value).isEqualTo("+336");

C'est un peu hacky et ne peut pas être l'avenir de.

---

La documentation est vague au sujet de la façon dont la création d'un objet de travaux; à partir de ce que je déduis de code bien, c'est qu'il est possible de mélanger différentes méthodes :

Par exemple on peut avoir une statique usine méthode annotée avec @JsonCreator

@JsonCreator
public Phone(@JsonProperty("value") String value) {
    this.value = value;
    enabled = true;
}

@JsonCreator
public Phone(@JsonProperty("enabled") Boolean enabled, @JsonProperty("value") String value) {
    this.value = value;
    this.enabled = enabled;
}

@JsonCreator
public static Phone toPhone(String value) {
    return new Phone(value);
}

assertThat(new ObjectMapper().readValue("\"+336\"", Phone.class).value).isEqualTo("+336");
assertThat(new ObjectMapper().readValue("{\"value\":\"+336\"}", Phone.class).value).isEqualTo("+336");
assertThat(new ObjectMapper().readValue("{\"value\":\"+336\",\"enabled\":true}", Phone.class).value).isEqualTo("+336");

Cela fonctionne, mais il n'est pas l'idéal. En fin de compte, il pourrait être intéressant, par exemple, si le json est que dynamique alors peut-être que l'on devrait chercher à utiliser un délégué constructeur pour gérer la charge utile des variations beaucoup plus élégamment que avec plusieurs annoté des constructeurs.

Également noter que Jackson les commandes des créateurs en priorité, par exemple, dans ce code :

//Simple
@JsonCreator
public Phone(@JsonProperty("value") String value) {
    this.value = value;
}

//more
@JsonCreator
public Phone(Map<String, Object> properties) {
    value = (String) properties.get("value");

    //more logic
}

assertThat(new ObjectMapper().readValue("\"+336\"", Phone.class).value).isEqualTo("+336");
assertThat(new ObjectMapper().readValue("{\"value\":\"+336\"}", Phone.class).value).isEqualTo("+336");
assertThat(new ObjectMapper().readValue("{\"value\":\"+336\",\"enabled\":true}", Phone.class).value).isEqualTo("+336");

Ce temps, Jackson ne lèvera une erreur, mais Jackson n'utilisera que les délégué constructeur Phone(Map<String, Object> properties), cela signifie que le Phone(@JsonProperty("value") String value) n'est jamais utilisé.

Si vous n'avez pas l'esprit de faire un peu plus de travail, vous pouvez désérialiser l'entité manuellement:

@JsonDeserialize(using = Person.Deserializer.class)
public class Person {

    public Person(@JsonProperty("name") String name,
            @JsonProperty("age") int age) {
        //... person with both name and age
    }

    public Person(@JsonProperty("name") String name) {
        //... person with just a name
    }

    public static class Deserializer extends StdDeserializer<Person> {
        public Deserializer() {
            this(null);
        }

        Deserializer(Class<?> vc) {
            super(vc);
        }

        @Override
        public Person deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {
            JsonNode node = jp.getCodec().readTree(jp);
            if (node.has("name") && node.has("age")) {
                String name = node.get("name").asText();
                int age = node.get("age").asInt();
                return new Person(name, age);
            } else if (node.has("name")) {
                String name = node.get("name").asText();
                return new Person("name");
            } else {
                throw new RuntimeException("unable to parse");
            }
        }
    }
}