Jackson mit JSON: Nicht erkanntes Feld, nicht als ignorierbar markiert

Ich muss eine bestimmte JSON-Zeichenfolge in ein Java-Objekt konvertieren. Ich verwende Jackson für das JSON-Handling. Ich habe keine Kontrolle über die Eingabe JSON (ich lese von einem Webdienst). Dies ist meine Eingabe JSON:

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

Hier ist ein vereinfachter Anwendungsfall:

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);
}

Meine Entitätsklasse ist:

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

Meine Wrapper-Klasse ist im Grunde ein Containerobjekt, um meine Schülerliste abzurufen:

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

Ich erhalte immer wieder diesen Fehler und "Wrapper" kehrt zurück null. Ich bin mir nicht sicher, was fehlt. Kann mir bitte jemand helfen?

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)

Sie können Jacksons Annotation auf Klassenebene verwenden:

import com.fasterxml.jackson.annotation.JsonIgnoreProperties

@JsonIgnoreProperties
class { ... }

Alle Eigenschaften, die Sie in Ihrem POJO nicht definiert haben, werden ignoriert. Sehr nützlich, wenn Sie nur nach einigen Eigenschaften in JSON suchen und nicht die gesamte Zuordnung schreiben möchten. Weitere Infos auf Jacksons Website . Wenn Sie eine nicht deklarierte Eigenschaft ignorieren möchten, sollten Sie Folgendes schreiben:

@JsonIgnoreProperties(ignoreUnknown = true)

Sie können verwenden

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

Alle nicht deklarierten Eigenschaften werden ignoriert.

Die erste Antwort ist fast richtig, aber es ist erforderlich, die Getter-Methode zu ändern, NICHT Feld - Feld ist privat (und nicht automatisch erkannt); Außerdem haben Getter Vorrang vor Feldern, wenn beide sichtbar sind. (Es gibt auch Möglichkeiten, private Felder sichtbar zu machen, aber wenn Sie Getter haben möchten, gibt es nicht viel Sinn.)

Daher sollte Getter entweder benannt getWrapper()oder mit folgenden Anmerkungen versehen werden:

@JsonProperty("wrapper")

Wenn Sie den Namen der Getter-Methode so wie sie ist bevorzugen.

Mit Jackson 2.6.0 funktionierte dies für mich:

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

und mit Einstellung:

@JsonIgnoreProperties(ignoreUnknown = true)

Es kann auf zwei Arten erreicht werden:

1. Markieren Sie das POJO, um unbekannte Eigenschaften zu ignorieren

   @JsonIgnoreProperties(ignoreUnknown = true)

2. Konfigurieren Sie ObjectMapper, der das POJO / json wie folgt serialisiert / de-serialisiert:

   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) 

Das hat bei mir einfach perfekt funktioniert

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

@JsonIgnoreProperties(ignoreUnknown = true) Anmerkung nicht.

Dies funktioniert besser als alle Bitte beziehen Sie sich auf diese Eigenschaft.

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);

Wenn Sie Jackson 2.0 verwenden

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

Laut Dokument können Sie ausgewählte Felder oder alle unbekannten Felder ignorieren:

 // 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)

Es hat bei mir mit folgendem Code funktioniert:

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

Das Hinzufügen von Setzern und Gettern löste das Problem . Ich war der Meinung, dass das eigentliche Problem darin bestand, wie man es löst, aber nicht, wie man den Fehler unterdrückt / ignoriert. Ich habe den Fehler " Nicht erkanntes Feld .. nicht als ignorierbar markiert .. " erhalten.

Obwohl ich die folgende Annotation über der Klasse verwende, war es nicht möglich, das json-Objekt zu analysieren und mir die Eingabe zu geben

@JsonIgnoreProperties (ignoreUnknown = true)

Dann wurde mir klar, dass ich keine Setter und Getter hinzufügte, nachdem ich dem "Wrapper" und dem "Student" Setter und Getter hinzugefügt hatte, funktionierte es wie ein Zauber.

Jackson beschwert sich, weil er in Ihrer Klasse Wrapper kein Feld finden kann, das "Wrapper" heißt. Dies geschieht, weil Ihr JSON-Objekt eine Eigenschaft namens "Wrapper" hat.

Ich denke, die Lösung besteht darin, das Feld Ihrer Wrapper-Klasse in "Wrapper" anstelle von "Studenten" umzubenennen.

Ich habe die folgende Methode ausprobiert und sie funktioniert für das Lesen im JSON-Format mit Jackson. Verwenden Sie die bereits vorgeschlagene Lösung von: annotating getter with@JsonProperty("wrapper")

Deine Wrapper-Klasse

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

Mein Vorschlag für eine Wrapper-Klasse

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")
}

Dies würde Ihnen jedoch die Ausgabe des Formats geben:

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

Weitere Informationen finden Sie unter https://github.com/FasterXML/jackson-annotations

Hoffe das hilft

Diese Lösung ist generisch beim Lesen von JSON-Streams und muss nur einige Felder abrufen, während Felder, die in Ihren Domänenklassen nicht korrekt zugeordnet sind, ignoriert werden können:

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

Eine detaillierte Lösung wäre die Verwendung eines Tools wie jsonschema2pojo, um die erforderlichen Domänenklassen wie Student automatisch aus dem Schema der json-Antwort zu generieren. Letzteres können Sie mit jedem Online-Konverter von JSON in Schema ausführen.

Kommentieren Sie die Feldschüler wie folgt, da die Namen der Eigenschaften json und java nicht übereinstimmen

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

Wie niemand sonst erwähnt hat, dachte ich würde ...

Problem ist, dass Ihre Eigenschaft in Ihrem JSON "Wrapper" heißt und Ihre Eigenschaft in Wrapper.class "Studenten" heißt.

Also entweder...

1. Korrigieren Sie den Namen der Eigenschaft entweder in der Klasse oder in JSON.
2. Kommentieren Sie Ihre Eigenschaftsvariable gemäß dem Kommentar von StaxMan.
3. Kommentieren Sie den Setter (falls Sie einen haben)

Setzen Sie Ihre Klassenfelder nicht privat auf öffentlich .

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

Was für mich funktionierte, war, das Eigentum öffentlich zu machen. Es hat das Problem für mich gelöst.

Entweder ändern

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

zu

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

---- oder ----

Ändern Sie Ihre JSON-Zeichenfolge in

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

Deine Eingabe

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

Gibt an, dass es sich um ein Objekt mit einem Feld namens "Wrapper" handelt, bei dem es sich um eine Sammlung von Schülern handelt. Meine Empfehlung wäre also:

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

wo Wrapperist definiert als

class Wrapper {
    List<Student> wrapper;
}

Das neue Firebase Android brachte einige große Änderungen mit sich. unter der Kopie des Dokuments:

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

Aktualisieren Sie Ihre Java-Modellobjekte

Wie beim 2.x SDK konvertiert Firebase Database automatisch Java-Objekte, an die Sie übergeben, DatabaseReference.setValue()in JSON und kann JSON mithilfe von in Java-Objekte lesen DataSnapshot.getValue().

Wenn Sie im neuen SDK JSON in ein Java-Objekt mit lesen DataSnapshot.getValue(), werden unbekannte Eigenschaften im JSON jetzt standardmäßig ignoriert, sodass Sie sie nicht mehr benötigen @JsonIgnoreExtraProperties(ignoreUnknown=true).

Um Felder / Getter beim Schreiben eines Java-Objekts in JSON auszuschließen, wird jetzt die Annotation @Excludeanstelle von aufgerufen @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)

Wenn Ihr JSON eine zusätzliche Eigenschaft enthält, die sich nicht in Ihrer Java-Klasse befindet, wird diese Warnung in den Protokolldateien angezeigt:

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

Sie können diese Warnung entfernen, indem Sie @IgnoreExtraPropertiesIhrer Klasse eine Anmerkung hinzufügen. Wenn Sie möchten, dass sich die Firebase-Datenbank wie im 2.x SDK verhält und eine Ausnahme auslöst, wenn unbekannte Eigenschaften vorhanden sind, können Sie @ThrowOnExtraPropertiesIhrer Klasse eine Anmerkung hinzufügen.

Für meinen Teil die einzige Zeile

@JsonIgnoreProperties(ignoreUnknown = true)

hat auch nicht funktioniert.

Einfach hinzufügen

@JsonInclude(Include.NON_EMPTY)

Jackson 2.4.0

Das hat bei mir perfekt funktioniert

objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

Ich habe dieses Problem behoben, indem ich einfach die Signaturen meiner Setter- und Getter-Methoden meiner POJO-Klasse geändert habe. Ich musste lediglich die getObject- Methode so ändern, dass sie dem entspricht , wonach der Mapper suchte. In meinem Fall hatte ich ursprünglich eine getImageUrl , aber die JSON-Daten hatten image_url, was den Mapper abwarf. Ich habe sowohl meinen Setter als auch meinen Getter in getImage_url und setImage_url geändert .

Hoffe das hilft.

Das POJO sollte definiert sein als

Antwortklasse

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

Wrapper-Klasse

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

und Mapper, um den Wert zu lesen

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

Dies kann eine sehr späte Antwort sein, aber nur das Ändern des POJO in dieses sollte die im Problem bereitgestellte JSON-Zeichenfolge lösen (da die Eingabezeichenfolge nicht in Ihrer Kontrolle liegt, wie Sie sagten):

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

Eine andere Möglichkeit ist diese Eigenschaft in den application.properties spring.jackson.deserialization.fail-on-unknown-properties=false, für die keine weitere Codeänderung in Ihrer Anwendung erforderlich ist. Und wenn Sie glauben, dass der Vertrag stabil ist, können Sie diese Eigenschaft entfernen oder als wahr markieren.

Dies ist möglicherweise nicht das gleiche Problem wie das OP, aber falls jemand mit dem gleichen Fehler wie ich hierher gekommen ist, hilft dies ihm, sein Problem zu lösen. Ich habe den gleichen Fehler wie beim OP erhalten, als ich einen ObjectMapper aus einer anderen Abhängigkeit als die JsonProperty-Annotation verwendet habe.

Das funktioniert:

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

Funktioniert nicht:

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 hat mich hierher gebracht und ich war überrascht, die Antworten zu sehen ... alle schlugen vor , den Fehler zu umgehen ( der später in der Entwicklung immer 4-fach zurückbeißt ), anstatt ihn zu lösen, bis dieser Gentleman durch das Vertrauen in SO wiederhergestellt wurde!

objectMapper.readValue(responseBody, TargetClass.class)

wird verwendet, um einen json-String in ein Klassenobjekt zu konvertieren. Was fehlt, ist, dass der TargetClassöffentliche Ter get/ ter haben sollte set. Gleiches fehlt auch im Fragefragment von OP! :) :)

via lombok sollte deine klasse wie unten funktionieren !!

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

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;

@JsonIgnoreProperties