Jackson: Was passiert, wenn eine Immobilie fehlt?

Was passiert, wenn ich kommentieren Konstruktor-parameter mit @JsonProperty aber das Json nicht angeben, der dieser Eigenschaft. Welchen Wert hat der Konstruktor bekommen?

Für Fragen wie diese, ich möchte nur schreiben, ein Beispiel-Programm und sehen, was passiert.

Folgenden ist so ein Beispiel-Programm.

import org.codehaus.jackson.annotate.JsonProperty;
import org.codehaus.jackson.map.ObjectMapper;

public class JacksonFoo
{
  public static void main(String[] args) throws Exception
  {
    ObjectMapper mapper = new ObjectMapper();

    //{"name":"Fred","id":42}
    String jsonInput1 = "{\"name\":\"Fred\",\"id\":42}";
    Bar bar1 = mapper.readValue(jsonInput1, Bar.class);
    System.out.println(bar1);
    //output: 
    //Bar: name=Fred, id=42

    //{"name":"James"}
    String jsonInput2 = "{\"name\":\"James\"}";
    Bar bar2 = mapper.readValue(jsonInput2, Bar.class);
    System.out.println(bar2);
    //output:
    //Bar: name=James, id=0

    //{"id":7}
    String jsonInput3 = "{\"id\":7}";
    Bar bar3 = mapper.readValue(jsonInput3, Bar.class);
    System.out.println(bar3);
    //output:
    //Bar: name=null, id=7
  }
}

class Bar
{
  private String name = "BLANK";
  private int id = -1;

  Bar(@JsonProperty("name") String n, @JsonProperty("id") int i)
  {
    name = n;
    id = i;
  }

  @Override
  public String toString()
  {
    return String.format("Bar: name=%s, id=%d", name, id);
  }
}

Das Ergebnis ist, dass der Konstruktor übergeben wird der Standardwert für den Datentyp.

Wie kann ich unterscheiden zwischen einer Eigenschaft mit einem null-Wert im Vergleich zu einer Immobilie, die nicht in der JSON?

Ein einfacher Ansatz wäre, zu überprüfen, ob ein default-Wert post Deserialisierung Verarbeitung, da, wenn das element in der JSON-hatte aber einen null-Wert, dann wird der null-Wert verwendet werden würde, um zu ersetzen Sie alle Standard-Wert erhält, wird die entsprechende Java-Bereich. Zum Beispiel:

import org.codehaus.jackson.annotate.JsonAutoDetect.Visibility;
import org.codehaus.jackson.annotate.JsonMethod;
import org.codehaus.jackson.map.ObjectMapper;

public class JacksonFooToo
{
  public static void main(String[] args) throws Exception
  {
    ObjectMapper mapper = new ObjectMapper().setVisibility(JsonMethod.FIELD, Visibility.ANY);

    //{"name":null,"id":99}
    String jsonInput1 = "{\"name\":null,\"id\":99}";
    BarToo barToo1 = mapper.readValue(jsonInput1, BarToo.class);
    System.out.println(barToo1);
    //output:
    //BarToo: name=null, id=99

    //{"id":99}
    String jsonInput2 = "{\"id\":99}";
    BarToo barToo2 = mapper.readValue(jsonInput2, BarToo.class);
    System.out.println(barToo2);
    //output:
    //BarToo: name=BLANK, id=99

    //Interrogate barToo1 and barToo2 for 
    //the current value of the name field.
    //If it's null, then it was null in the JSON.
    //If it's BLANK, then it was missing in the JSON.
  }
}

class BarToo
{
  String name = "BLANK";
  int id = -1;

  @Override
  public String toString()
  {
    return String.format("BarToo: name=%s, id=%d", name, id);
  }
}

Ein weiterer Ansatz wäre die Implementierung einer benutzerdefinierten deserializer, der überprüft, ob die benötigten JSON-Elemente. Und noch ein weiterer Ansatz wäre es, melden Sie sich ein enhancement-request mit der Jackson-Projekt an http://jira.codehaus.org/browse/JACKSON

InformationsquelleAutor der Antwort Programmer Bruce

Ich denke mit etwas in der Art von eine Option Klasse, wo Nichts, das Objekt würde mir sagen, wenn es solch einen Wert hat oder nicht. Hat jemand schon sowas gemacht mit Jackson (in Java, nicht Scala, et al)?

InformationsquelleAutor der Antwort Roberto

eine weitere option ist überprüfen das Objekt nach der Deserialisierung entweder manuell oder über Rahmenwerke wie java bean validation, oder, wenn Sie der Frühling, der Frühling-Validierung unterstützen.

InformationsquelleAutor der Antwort abdel