Jackson avec JSON: champ non reconnu, non marqué comme ignorable

J'ai besoin de convertir une certaine chaîne JSON en un objet Java. J'utilise Jackson pour la gestion JSON. Je n'ai aucun contrôle sur le JSON d'entrée (j'ai lu à partir d'un service Web). Voici mon entrée JSON:

{"wrapper":[{"id":"13","name":"Fred"}]}

Voici un cas d'utilisation simplifié:

private void tryReading() {
    String jsonStr = "{\"wrapper\"\:[{\"id\":\"13\",\"name\":\"Fred\"}]}";
    ObjectMapper mapper = new ObjectMapper();  
    Wrapper wrapper = null;
    try {
        wrapper = mapper.readValue(jsonStr , Wrapper.class);
    } catch (Exception e) {
        e.printStackTrace();
    }
    System.out.println("wrapper = " + wrapper);
}

Ma classe d'entité est:

public Class Student { 
    private String name;
    private String id;
    //getters & setters for name & id here
}

Ma classe Wrapper est essentiellement un objet conteneur pour obtenir ma liste d'étudiants:

public Class Wrapper {
    private List<Student> students;
    //getters & setters here
}

Je continue à recevoir cette erreur et les retours "wrapper" null. Je ne sais pas ce qui manque. Quelqu'un peut-il aider s'il vous plaît?

org.codehaus.jackson.map.exc.UnrecognizedPropertyException: 
    Unrecognized field "wrapper" (Class Wrapper), not marked as ignorable
 at [Source: java.io.StringReader@1198891; line: 1, column: 13] 
    (through reference chain: Wrapper["wrapper"])
 at org.codehaus.jackson.map.exc.UnrecognizedPropertyException
    .from(UnrecognizedPropertyException.java:53)

Vous pouvez utiliser l'annotation de niveau classe de Jackson:

import com.fasterxml.jackson.annotation.JsonIgnoreProperties

@JsonIgnoreProperties
class { ... }

Il ignorera toutes les propriétés que vous n'avez pas définies dans votre POJO. Très utile lorsque vous recherchez simplement quelques propriétés dans le JSON et que vous ne souhaitez pas écrire l'intégralité du mappage. Plus d'informations sur le site Web de Jackson . Si vous souhaitez ignorer toute propriété non déclarée, vous devez écrire:

@JsonIgnoreProperties(ignoreUnknown = true)

Vous pouvez utiliser

ObjectMapper objectMapper = getObjectMapper();
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

Il ignorera toutes les propriétés non déclarées.

La première réponse est presque correcte, mais ce qu'il faut, c'est changer la méthode getter, PAS le champ - le champ est privé (et non auto-détecté); en outre, les getters ont priorité sur les champs si les deux sont visibles (il existe des moyens de rendre les champs privés visibles également, mais si vous voulez avoir un getter, il n'y a pas grand-chose à voir)

Donc, getter doit être nommé getWrapper()ou annoté avec:

@JsonProperty("wrapper")

Si vous préférez le nom de la méthode getter tel quel.

en utilisant Jackson 2.6.0, cela a fonctionné pour moi:

private static final ObjectMapper objectMapper = 
    new ObjectMapper()
        .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

et avec réglage:

@JsonIgnoreProperties(ignoreUnknown = true)

il peut être réalisé de 2 manières:

1. Marquez le POJO pour ignorer les propriétés inconnues

   @JsonIgnoreProperties(ignoreUnknown = true)

2. Configurez ObjectMapper qui sérialise / désérialise le POJO / json comme ci-dessous:

   ObjectMapper mapper =new ObjectMapper();            
   // for Jackson version 1.X        
   mapper.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);
   // for Jackson version 2.X
   mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false) 

Cela a parfaitement fonctionné pour moi

ObjectMapper objectMapper = new ObjectMapper();
objectMapper.configure(
    DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);

@JsonIgnoreProperties(ignoreUnknown = true) l'annotation ne l'a pas fait.

Cela fonctionne mieux que tous s'il vous plaît se référer à cette propriété.

import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;

    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    projectVO = objectMapper.readValue(yourjsonstring, Test.class);

Si vous utilisez Jackson 2.0

ObjectMapper mapper = new ObjectMapper();
mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);

Selon le document, vous pouvez ignorer les champs sélectionnés ou tous les champs inconnus:

 // to prevent specified fields from being serialized or deserialized
 // (i.e. not include in JSON output; or being set even if they were included)
 @JsonIgnoreProperties({ "internalId", "secretKey" })

 // To ignore any unknown properties in JSON input without exception:
 @JsonIgnoreProperties(ignoreUnknown=true)

Cela a fonctionné pour moi avec le code suivant:

ObjectMapper mapper =new ObjectMapper();    
mapper.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);

L'ajout de setters et de getters a résolu le problème , ce que je pensais être le vrai problème était de savoir comment le résoudre mais pas comment supprimer / ignorer l'erreur. J'ai eu l'erreur " Champ non reconnu .. non marqué comme ignorable .. "

Bien que j'utilise l'annotation ci-dessous en haut de la classe, il n'a pas pu analyser l'objet json et me donner l'entrée

@JsonIgnoreProperties (ignoreUnknown = true)

Puis j'ai réalisé que je n'ai pas ajouté de setters et de getters, après avoir ajouté des setters et des getters au "Wrapper" et au "Student" cela a fonctionné comme un charme.

Jackson se plaint car il ne trouve pas de champ dans votre classe Wrapper appelé "wrapper". C'est parce que votre objet JSON a une propriété appelée "wrapper".

Je pense que le correctif consiste à renommer le champ de votre classe Wrapper en "wrapper" au lieu de "étudiants".

J'ai essayé la méthode ci-dessous et cela fonctionne pour une telle lecture au format JSON avec Jackson. Utilisez la solution déjà suggérée de: annoter getter avec@JsonProperty("wrapper")

Votre classe wrapper

public Class Wrapper{ 
  private List<Student> students;
  //getters & setters here 
} 

Ma suggestion de classe wrapper

public Class Wrapper{ 

  private StudentHelper students; 

  //getters & setters here 
  // Annotate getter
  @JsonProperty("wrapper")
  StudentHelper getStudents() {
    return students;
  }  
} 


public class StudentHelper {

  @JsonProperty("Student")
  public List<Student> students; 

  //CTOR, getters and setters
  //NOTE: If students is private annotate getter with the annotation @JsonProperty("Student")
}

Cela vous donnerait cependant la sortie du format:

{"wrapper":{"student":[{"id":13,"name":Fred}]}}

Pour plus d'informations, reportez-vous également à https://github.com/FasterXML/jackson-annotations

J'espère que cela t'aides

Cette solution est générique lors de la lecture de flux json et n'a besoin d'obtenir que certains champs alors que les champs non mappés correctement dans vos classes de domaine peuvent être ignorés:

import org.codehaus.jackson.annotate.JsonIgnoreProperties;
@JsonIgnoreProperties(ignoreUnknown = true)

Une solution détaillée serait d'utiliser un outil tel que jsonschema2pojo pour générer automatiquement les classes de domaine requises telles que Student à partir du schéma de la réponse json. Vous pouvez le faire par n'importe quel convertisseur json en schéma en ligne.

Annotez les étudiants sur le terrain comme ci-dessous car il y a un décalage dans les noms des propriétés json et java

public Class Wrapper {
    @JsonProperty("wrapper")
    private List<Student> students;
    //getters & setters here
}

Comme personne d'autre ne l'a mentionné, j'ai pensé que je le ferais ...

Le problème est que votre propriété dans votre JSON est appelée "wrapper" et votre propriété dans Wrapper.class est appelée "étudiants".

Alors non plus ...

1. Corrigez le nom de la propriété dans la classe ou JSON.
2. Annotez votre variable de propriété selon le commentaire de StaxMan.
3. Annoter le setter (si vous en avez un)

rendre public vos champs de classe non privés .

public Class Student { 
    public String name;
    public String id;
    //getters & setters for name & id here
}

Ce qui a fonctionné pour moi, c'est de rendre la propriété publique. Cela a résolu le problème pour moi.

Soit changer

public Class Wrapper {
    private List<Student> students;
    //getters & setters here
}

à

public Class Wrapper {
    private List<Student> wrapper;
    //getters & setters here
}

---- ou ----

Changez votre chaîne JSON en

{"students":[{"id":"13","name":"Fred"}]}

Votre contribution

{"wrapper":[{"id":"13","name":"Fred"}]}

indique qu'il s'agit d'un objet, avec un champ nommé "wrapper", qui est une collection d'étudiants. Donc, ma recommandation serait,

Wrapper = mapper.readValue(jsonStr , Wrapper.class);

où Wrapperest défini comme

class Wrapper {
    List<Student> wrapper;
}

Le nouveau Firebase Android a introduit d'énormes changements; ci-dessous la copie du document:

[ https://firebase.google.com/support/guides/firebase-android] :

Mettez à jour vos objets de modèle Java

Comme avec le SDK 2.x, la base de données Firebase convertira automatiquement les objets Java que vous passez DatabaseReference.setValue()en JSON et peut lire JSON en objets Java à l'aide DataSnapshot.getValue().

Dans le nouveau SDK, lors de la lecture de JSON dans un objet Java avec DataSnapshot.getValue(), les propriétés inconnues dans le JSON sont désormais ignorées par défaut, vous n'avez donc plus besoin @JsonIgnoreExtraProperties(ignoreUnknown=true).

Pour exclure des champs / getters lors de l'écriture d'un objet Java dans JSON, l'annotation est désormais appelée à la @Excludeplace de @JsonIgnore.

BEFORE

@JsonIgnoreExtraProperties(ignoreUnknown=true)
public class ChatMessage {
   public String name;
   public String message;
   @JsonIgnore
   public String ignoreThisField;
}

dataSnapshot.getValue(ChatMessage.class)

AFTER

public class ChatMessage {
   public String name;
   public String message;
   @Exclude
   public String ignoreThisField;
}

dataSnapshot.getValue(ChatMessage.class)

S'il existe une propriété supplémentaire dans votre JSON qui n'est pas dans votre classe Java, vous verrez cet avertissement dans les fichiers journaux:

W/ClassMapper: No setter/field for ignoreThisProperty found on class com.firebase.migrationguide.ChatMessage

Vous pouvez vous débarrasser de cet avertissement en mettant une @IgnoreExtraPropertiesannotation sur votre classe. Si vous souhaitez que la base de données Firebase se comporte comme dans le SDK 2.x et lève une exception s'il existe des propriétés inconnues, vous pouvez mettre une @ThrowOnExtraPropertiesannotation sur votre classe.

Pour ma part, la seule ligne

@JsonIgnoreProperties(ignoreUnknown = true)

n'a pas fonctionné aussi.

Ajoutez simplement

@JsonInclude(Include.NON_EMPTY)

Jackson 2.4.0

Cela a parfaitement fonctionné pour moi

objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

J'ai résolu ce problème en changeant simplement les signatures de mes méthodes setter et getter de ma classe POJO. Tout ce que j'avais à faire était de changer la méthode getObject pour qu'elle corresponde à ce que le mappeur recherchait. Dans mon cas, j'avais à l' origine un getImageUrl , mais les données JSON avaient image_url qui rejetait le mappeur. J'ai changé à la fois mon setter et mes getters en getImage_url et setImage_url .

J'espère que cela t'aides.

Le POJO doit être défini comme

Classe de réponse

public class Response {
    private List<Wrapper> wrappers;
    // getter and setter
}

Classe Wrapper

public class Wrapper {
    private String id;
    private String name;
    // getters and setters
}

et mappeur pour lire la valeur

Response response = mapper.readValue(jsonStr , Response.class);

Cela peut être une réponse très tardive, mais le simple fait de changer le POJO en ceci devrait résoudre la chaîne json fournie dans le problème (car la chaîne d'entrée n'est pas sous votre contrôle comme vous l'avez dit):

public class Wrapper {
    private List<Student> wrapper;
    //getters & setters here
}

Une autre possibilité est cette propriété dans le fichier application.properties spring.jackson.deserialization.fail-on-unknown-properties=false, qui ne nécessitera aucun autre changement de code dans votre application. Et lorsque vous pensez que le contrat est stable, vous pouvez supprimer cette propriété ou la marquer comme vraie.

Ce n'est peut-être pas le même problème que le PO, mais au cas où quelqu'un arriverait avec la même erreur que moi, cela les aiderait à résoudre leur problème. J'ai eu la même erreur que l'OP lorsque j'ai utilisé un ObjectMapper d'une dépendance différente comme l'annotation JsonProperty.

Cela marche:

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

Ne marche pas:

import org.codehaus.jackson.map.ObjectMapper; //org.codehaus.jackson:jackson-mapper-asl:1.8.8
import com.fasterxml.jackson.annotation.JsonProperty; //com.fasterxml.jackson.core:jackson-databind:2.2.3

Google m'a amené ici et j'ai été surpris de voir les réponses ... tous ont suggéré de contourner l'erreur ( qui mord toujours 4 fois plus tard dans le développement ) plutôt que de la résoudre jusqu'à ce que ce monsieur soit restauré par la foi en SO!

objectMapper.readValue(responseBody, TargetClass.class)

est utilisé pour convertir une chaîne json en un objet de classe, ce qui manque, c'est que le TargetClassdevrait avoir des getter / setters publics . Il en va de même dans l'extrait de question d'OP! :)

via lombok votre classe comme ci-dessous devrait fonctionner !!

@Data
@Builder
public class TargetClass {
    private String a;
}

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;

@JsonIgnoreProperties