Jackson z JSON: Nierozpoznane pole, nie oznaczone jako ignorowalne

Muszę przekonwertować określony ciąg JSON na obiekt Java. Używam Jacksona do obsługi JSON. Nie mam kontroli nad wejściem JSON (czytam z serwisu internetowego). Oto moje dane wejściowe JSON:

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

Oto uproszczony przypadek użycia:

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

Moja klasa jednostek to:

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

Moja klasa Wrapper to w zasadzie obiekt kontenerowy, za pomocą którego otrzymuję moją listę uczniów:

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

Ciągle pojawia się ten błąd i „otoki” powraca null. Nie jestem pewien, czego brakuje. Czy ktoś może pomóc?

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)

Możesz użyć adnotacji Jacksona na poziomie klasy:

import com.fasterxml.jackson.annotation.JsonIgnoreProperties

@JsonIgnoreProperties
class { ... }

Zignoruje każdą właściwość, której nie zdefiniowałeś w swoim POJO. Bardzo przydatne, gdy szukasz tylko kilku właściwości w JSON i nie chcesz pisać całego mapowania. Więcej informacji na stronie Jacksona . Jeśli chcesz zignorować dowolną niezadeklarowaną właściwość, napisz:

@JsonIgnoreProperties(ignoreUnknown = true)

Możesz użyć

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

Zignoruje wszystkie właściwości, które nie zostały zadeklarowane.

Pierwsza odpowiedź jest prawie poprawna, ale potrzebna jest zmiana metody pobierającej, NIE pole - pole jest prywatne (i nie jest automatycznie wykrywane); ponadto, gettery mają pierwszeństwo przed polami, jeśli oba są widoczne. (Istnieją również sposoby, aby pola prywatne były widoczne, ale jeśli chcesz mieć getter, nie ma większego sensu)

Więc getter powinien zostać nazwany getWrapper() lub opatrzony adnotacjami:

@JsonProperty("wrapper")

Jeśli wolisz nazwę metody pobierającej taką, jaka jest.

używając Jackson 2.6.0, to zadziałało dla mnie:

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

i z ustawieniem:

@JsonIgnoreProperties(ignoreUnknown = true)

można to osiągnąć na 2 sposoby:

1. Zaznacz POJO, aby zignorować nieznane właściwości

   @JsonIgnoreProperties(ignoreUnknown = true)

2. Skonfiguruj ObjectMapper, który serializuje / odserializowuje POJO / json, jak poniżej:

   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) 

To po prostu doskonale działało dla mnie

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

@JsonIgnoreProperties(ignoreUnknown = true) adnotacja nie.

Działa to lepiej niż Wszystkie, zapoznaj się z tą właściwością.

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

Jeśli korzystasz z Jackson 2.0

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

Zgodnie z dokumentem możesz zignorować wybrane pola lub wszystkie pola nieznane:

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

Działa dla mnie z następującym kodem:

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

Dodanie seterów i getterów rozwiązało problem , czułem, że rzeczywistym problemem jest to, jak go rozwiązać, ale nie jak pomijać / ignorować błąd. Pojawił się błąd „ Pole nierozpoznane… nie oznaczone jako ignorowalne… ”

Chociaż używam poniższej adnotacji na szczycie klasy, nie było w stanie przeanalizować obiektu json i podać danych wejściowych

@JsonIgnoreProperties (ignoreUnknown = true)

Potem zdałem sobie sprawę, że nie dodałem seterów i getterów, po dodaniu seterów i getterów do „Wrapper” i do „Student” działało to jak urok.

Jackson narzeka, ponieważ nie może znaleźć pola w twojej klasie Wrapper, które nazywa się „wrapper”. Robi to, ponieważ obiekt JSON ma właściwość o nazwie „wrapper”.

Myślę, że poprawką jest zmiana nazwy pola klasy Wrapper na „wrapper” zamiast „student”.

Wypróbowałem poniższą metodę i działa ona z takim odczytem formatu JSON z Jacksonem. Skorzystaj z już sugerowanego rozwiązania: adnotacji gettera za pomocą@JsonProperty("wrapper")

Twoja klasa opakowania

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

Moja propozycja klasy opakowania

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

Dałoby to jednak wynik formatu:

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

Aby uzyskać więcej informacji, zobacz https://github.com/FasterXML/jackson-annotations

Mam nadzieję że to pomoże

To rozwiązanie jest ogólne podczas odczytywania strumieni Json i wymaga tylko niektórych pól, a pola niepoprawnie zmapowane w klasach domeny można zignorować:

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

Szczegółowym rozwiązaniem byłoby użycie narzędzia takiego jak jsonschema2pojo do automatycznego generowania wymaganych klas domen, takich jak Student ze schematu odpowiedzi json. Możesz to zrobić za pomocą dowolnego internetowego konwertera json na schemat.

Opisz adnotacje uczniom terenowym, jak poniżej, ponieważ istnieje niedopasowanie w nazwach właściwości json i własności Java

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

Jak nikt inny nie wspomniał, myślałem, że ...

Problem polega na tym, że twoja własność w twoim JSON nazywa się „wrapper”, a twoja własność w Wrapper.class nazywa się „studentami”.

Więc albo ...

1. Popraw nazwę właściwości w klasie lub JSON.
2. Opisz adnotację o zmiennej właściwości zgodnie z komentarzem StaxMan.
3. Zanotuj setera (jeśli go masz)

Zestaw publiczny wasze pola klasy nie prywatny .

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

To, co zadziałało, to upublicznienie nieruchomości. To rozwiązało problem dla mnie.

Albo zmień

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

do

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

---- lub ----

Zmień ciąg JSON na

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

Twój wkład

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

wskazuje, że jest to Obiekt z polem o nazwie „opakowanie”, który jest Kolekcją Studentów. Więc moim zaleceniem byłoby

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

gdzie Wrapperjest zdefiniowany jako

class Wrapper {
    List<Student> wrapper;
}

Nowy Firebase Android wprowadził ogromne zmiany; poniżej kopii dokumentu:

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

Zaktualizuj obiekty modelu Java

Podobnie jak w przypadku zestawu SDK 2.x, Firebase Database automatycznie przekonwertuje obiekty Java, które przekazujesz DatabaseReference.setValue()na JSON i może czytać JSON na obiekty Java za pomocą DataSnapshot.getValue().

W nowym zestawie SDK podczas odczytywania JSON do obiektu Java za pomocą DataSnapshot.getValue()nieznanych właściwości w JSON są teraz domyślnie ignorowane, więc nie jest już potrzebne @JsonIgnoreExtraProperties(ignoreUnknown=true).

Aby wykluczyć pola / gettery podczas zapisywania obiektu Java w JSON, adnotacja jest teraz wywoływana @Excludezamiast @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)

Jeśli w twoim JSON istnieje dodatkowa właściwość, która nie znajduje się w twojej klasie Java, zobaczysz to ostrzeżenie w plikach dziennika:

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

Możesz pozbyć się tego ostrzeżenia, umieszczając @IgnoreExtraPropertiesadnotację na swojej klasie. Jeśli chcesz, aby Firebase Database zachowywała się tak, jak miało to miejsce w zestawie SDK 2.x i zgłasza wyjątek, jeśli istnieją nieznane właściwości, możesz umieścić @ThrowOnExtraPropertiesadnotację na swojej klasie.

Z mojej strony jedyna linia

@JsonIgnoreProperties(ignoreUnknown = true)

też nie działał.

Poprostu dodaj

@JsonInclude(Include.NON_EMPTY)

Jackson 2.4.0

To działało idealnie dla mnie

objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

Rozwiązałem ten problem, po prostu zmieniając podpisy mojego setera i metody pobierające mojej klasy POJO. Wszystko, co musiałem zrobić, to zmienić getObject metodę , tak aby pasowała do tego, czego szukał program mapujący. W moim przypadku miałem getImageUrl oryginalnie, ale dane JSON miał IMAGE_URL który rzuca mapowania off. Zmieniłem zarówno settera, jak i gettery na getImage_url i setImage_url .

Mam nadzieję że to pomoże.

POJO należy zdefiniować jako

Klasa reakcji

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

Klasa opakowania

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

i program mapujący do odczytu wartości

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

Może to być bardzo późna odpowiedź, ale sama zmiana POJO na to powinna rozwiązać ciąg json podany w problemie (ponieważ, jak powiedziałeś, łańcuch wejściowy nie jest w twojej kontroli):

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

Inną możliwością jest ta właściwość w pliku application.properties spring.jackson.deserialization.fail-on-unknown-properties=false, która nie wymaga żadnej innej zmiany kodu w aplikacji. A jeśli uważasz, że umowa jest stabilna, możesz usunąć tę właściwość lub oznaczyć ją jako prawdziwą.

To może nie być ten sam problem, który miał OP, ale w przypadku, gdy ktoś tu przyszedł z tym samym błędem, który miałem, pomoże to rozwiązać jego problem. Dostałem ten sam błąd co OP, gdy użyłem ObjectMapper z innej zależności niż adnotacja JsonProperty.

To działa:

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

Nie działa:

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 mnie tu przyprowadził i byłem zaskoczony, widząc odpowiedzi ... wszystkie sugerowały pominięcie błędu ( który zawsze rozwija się 4 razy później w rozwoju ) zamiast rozwiązywania go, dopóki ten dżentelmen nie odzyskał wiary w SO!

objectMapper.readValue(responseBody, TargetClass.class)

służy do konwersji ciągu json na obiekt klasy, brakuje tylko tego, że TargetClasspowinien mieć publiczny getter / setters. Tego samego brakuje również we fragmencie pytania OP! :)

przez lombok Twoja klasa jak poniżej powinna działać !!

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

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;

@JsonIgnoreProperties