Comment ignorer les champs enum dans le mappage Jackson JSON-Object?

J'ai un Objet JSON quelque chose comme:

{"name":"John", "grade":"A"}

{"name":"Mike", "grade":"B"}

{"name":"Simon", "grade":"C"}

etc

Je suis en train de la carte ci-dessus JSON:

@JsonIgnoreProperties(ignoreUnknown = true)
public class Employee{
      @JsonIgnoreProperties(ignoreUnknown = true)
      public enum Grade{ A, B, C }
      Grade grade;
      String name;

  public Grade getGrade() {
    return grade;
  }

  public void setGrade(Grade grade) {
    this.grade = grade;
  }

  public String getName() {
    return name;
  }

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

au-dessus de la cartographie fonctionne très bien mais dans l'avenir il y aura plus de "Grade" types disons D,E, etc qui rompt le mappage existant et lève l'exception suivante

05-08 09:56:28.130: W/System.err(21309): org.codehaus.jackson.map.JsonMappingException: Can not construct instance of Employee from String value 'D': value not one of declared Enum instance names

Est-il un moyen d'ignorer les champs inconnus dans les types enum?

Grâce

source d'informationauteur Saqib

jackson java

Je pense que vous devriez définir externe deserializer pour Grade enum.

J'ai ajouté du champ enum - INCONNU:

enum Grade {
    A, B, C, UNKNOWN;

    public static Grade fromString(String value) {
        for (Grade grade : values()) {
            if (grade.name().equalsIgnoreCase(value)) {
                return grade;
            }
        }

        return UNKNOWN;
    }
}
class Employee {

    @JsonDeserialize(using = GradeDeserializer.class)
    private Grade grade;
    private String name;

    public Grade getGrade() {
        return grade;
    }

    public void setGrade(Grade grade) {
        this.grade = grade;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Employee [grade=" + grade + ", name=" + name + "]";
    }
}

Maintenant, analyseur pourrait ressembler à ça:

class GradeDeserializer extends JsonDeserializer<Grade> {
    @Override
    public Grade deserialize(JsonParser parser, DeserializationContext context)
            throws IOException, JsonProcessingException {
        return Grade.fromString(parser.getValueAsString());
    }
}

Exemple d'utilisation:

public class JacksonProgram {

    public static void main(String[] args) throws Exception {
        ObjectMapper objectMapper = new ObjectMapper();
        JsonFactory jsonFactory = new JsonFactory();
        JsonParser parser = jsonFactory
                .createJsonParser("{\"name\":\"John\", \"grade\":\"D\"}");
        Employee employee = objectMapper.readValue(parser, Employee.class);
        System.out.println(employee);
    }

}

De sortie:

Employee [grade=UNKNOWN, name=John]

Si vous ne voulez pas ajouter un champ supplémentaire, vous seriez de retour null par exemple.

J'ai trouvé un moyen pour ce faire comme suit:

public static void main(String[] args) throws JsonParseException, JsonMappingException, UnsupportedEncodingException, IOException {
    String json = "{\"name\":\"John\", \"grade\":\"D\"}";

    ObjectMapper mapper = new ObjectMapper();
    mapper.configure(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL, true);
    Employee employee = mapper.readValue(new ByteArrayInputStream(json.getBytes("UTF-8")), Employee.class);

    System.out.println(employee.getGrade());
}

Ce sorties :

null

autres classes:

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;

@JsonIgnoreProperties(ignoreUnknown = true)
public class Employee {
    private String name;
    private Grade grade;

    public String getName() {
        return name;
    }

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

    public Grade getGrade() {
        return grade;
    }

    public void setGrade(Grade grade) {
        this.grade = grade;
    }
}



import com.fasterxml.jackson.annotation.JsonIgnoreProperties;

@JsonIgnoreProperties(ignoreUnknown = true)
public enum Grade {A, B, C}

Je n'ai pas trouver le moyen de le faire avec une annotation encore.

J'espère que cette aide.

@JsonCreator fournit une plus concis solution par rapport à @JsonDeserialize.

L'idée est d'annoter vos valueOf() de remplacement ( appelé safeValueOf() dans cet exemple) avec @JsonCreator et puis Jackson désérialiser les chaînes à l'aide de votre mise en œuvre.

Noter que la mise en œuvre est à l'intérieur de l'enum, vous pouvez l'utiliser comme champ dans d'autres objets, sans changement.

La solution ci-dessous est enveloppé dans une unité de test de sorte que vous pouvez l'exécuter directement.

import static junit.framework.TestCase.assertEquals;

import java.io.IOException;

import org.junit.Test;

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.databind.ObjectMapper;

public class EmployeeGradeTest {

    public enum Grade {
        A, B, C, OTHER;

        @JsonCreator
        public static Grade safeValueOf(String string) {
            try {
                return Grade.valueOf(string);
            } catch (IllegalArgumentException e) {
                return OTHER;
            }
        }
    }

    @Test
    public void deserialize() throws IOException {
        assertEquals(Grade.A, new ObjectMapper().readValue("\"A\"", Grade.class));
    }

    @Test
    public void deserializeNewValue() throws IOException {
        assertEquals(Grade.OTHER, new ObjectMapper().readValue("\"D\"", Grade.class));
    }
}

Vous devez vous connecter pour publier un commentaire.