Jak powiedzieć Jacksonowi, aby ignorował pole podczas serializacji, jeśli jego wartość jest zerowa?

W jaki sposób Jackson można skonfigurować tak, aby ignorował wartość pola podczas serializacji, jeśli wartość tego pola jest równa null.

Na przykład:

public class SomeClass {
   // what jackson annotation causes jackson to skip over this value if it is null but will 
   // serialize it otherwise 
   private String someValue; 
}

Aby wyłączyć serializowanie właściwości z wartościami zerowymi przy użyciu Jackson> 2.0, możesz skonfigurować ObjectMapperbezpośrednio lub skorzystać z @JsonIncludeadnotacji:

mapper.setSerializationInclusion(Include.NON_NULL);

lub:

@JsonInclude(Include.NON_NULL)
class Foo
{
  String bar;
}

Alternatywnie można użyć @JsonIncludew module pobierającym, aby atrybut był wyświetlany, jeśli wartość nie jest równa null.

Bardziej kompletny przykład jest dostępny w mojej odpowiedzi na temat sposobu zapobiegania serializacji wartości pustych w Mapie i zerowych pól w fasoli przez Jackson .

W przypadku Jackson> 1.9.11 i <2.x użyj @JsonSerializeadnotacji, aby to zrobić:

@JsonSerialize(include=JsonSerialize.Inclusion.NON_NULL)

Aby rozwinąć inne odpowiedzi - jeśli chcesz kontrolować pomijanie wartości pustych dla poszczególnych pól, dodaj adnotację do danego pola (lub alternatywnie adnotację „getter” pola).

przykład - tutaj fieldOnezostanie odrzucony z json tylko, jeśli jest pusty. fieldTwozawsze będzie uwzględniony, niezależnie od tego, czy jest pusty.

public class Foo {

    @JsonInclude(JsonInclude.Include.NON_NULL) 
    private String fieldOne;

    private String fieldTwo;
}

Aby domyślnie pominąć wszystkie wartości null w klasie, należy opisać klasę. W razie potrzeby można nadal używać adnotacji dla pól / getterów.

przykład - tutaj fieldOnei fieldTwozostaną odrzucone z json, jeśli są odpowiednio null, ponieważ jest to ustawienie domyślne ustawione przez adnotację klasy. fieldThreezastąpi to ustawienie domyślne i zawsze zostanie uwzględnione, z uwagi na adnotację w polu.

@JsonInclude(JsonInclude.Include.NON_NULL)
public class Foo {

    private String fieldOne;

    private String fieldTwo;

    @JsonInclude(JsonInclude.Include.ALWAYS)
    private String fieldThree;
}

AKTUALIZACJA

Powyższe dotyczy Jackson 2 . W przypadku wcześniejszych wersji Jacksona musisz użyć:

@JsonSerialize(include=JsonSerialize.Inclusion.NON_NULL) 

zamiast

@JsonInclude(JsonInclude.Include.NON_NULL)

Jeśli ta aktualizacja jest przydatna, proszę głosować za odpowiedzią ZiglioUK poniżej, wskazywała ona na nowszą adnotację Jackson 2 na długo przed zaktualizowaniem mojej odpowiedzi, aby z niej skorzystać!

W Jackson 2.x użyj:

@JsonInclude(JsonInclude.Include.NON_NULL)

Możesz użyć następującej konfiguracji mapowania:

mapper.getSerializationConfig().setSerializationInclusion(Inclusion.NON_NULL);

Od wersji 2.5 możesz:

mapper.setSerializationInclusion(Include.NON_NULL);

Możesz ustawić application.properties:

spring.jackson.default-property-inclusion=non_null

lub application.yaml:

spring:
  jackson:
    default-property-inclusion: non_null

http://docs.spring.io/spring-boot/docs/current/reference/html/common-application-properties.html

w moim przypadku

@JsonInclude(Include.NON_EMPTY)

sprawiło, że zadziałało.

@JsonInclude(JsonInclude.Include.NON_NULL)
@JsonInclude(JsonInclude.Include.NON_EMPTY)

powinno działać.

Include.NON_EMPTYwskazuje, że właściwość jest serializowana, jeśli jej wartość nie jest równa null i nie jest pusta. Include.NON_NULLwskazuje, że właściwość jest serializowana, jeśli jej wartość nie jest równa null.

Jeśli chcesz dodać tę regułę do wszystkich modeli w Jackson 2.6+, użyj:

mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

Jeśli w Spring Boot , możesz dostosować jackson ObjectMapperbezpośrednio poprzez pliki właściwości.

Przykład application.yml:

spring:
  jackson:
    default-property-inclusion: non_null # only include props if non-null

Możliwe wartości to:

always|non_null|non_absent|non_default|non_empty

Więcej informacji: https://docs.spring.io/spring-boot/docs/current/reference/html/howto-spring-mvc.html#howto-customize-the-jackson-objectmapper

Działa to w Spring boot 2.0.3+ i Jackson 2.0+

import com.fasterxml.jackson.annotation.JsonInclude;

@JsonInclude(JsonInclude.Include.NON_NULL)
public class ApiDTO
{
    // your class variable and 
    // methods
}

W przypadku Jackson 2.5 użyj:

@JsonInclude(content=Include.NON_NULL)

Martwiło mnie to od dłuższego czasu i w końcu znalazłem problem. Przyczyną tego problemu był niewłaściwy import. Wcześniej używałem

com.fasterxml.jackson.databind.annotation.JsonSerialize

Który był przestarzały. Po prostu zastąp import przez

import org.codehaus.jackson.map.annotate.JsonSerialize;
import org.codehaus.jackson.map.annotate.JsonSerialize.Inclusion;

i użyj go jako

@JsonSerialize(include=Inclusion.NON_NULL)

Konfiguracja globalna, jeśli korzystasz z Spring

@Configuration
public class JsonConfigurations {

    @Bean
    public Jackson2ObjectMapperBuilder objectMapperBuilder() {
        Jackson2ObjectMapperBuilder builder = new Jackson2ObjectMapperBuilder();
        builder.serializationInclusion(JsonInclude.Include.NON_NULL);
        builder.serializationInclusion(JsonInclude.Include.NON_EMPTY);
        builder.failOnUnknownProperties(false);
        return builder;
    }

}

Jeśli próbujesz serializować listę obiektów, a jeden z nich ma wartość NULL, skończysz, włączając element NULL w JSON, nawet jeśli

mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

spowoduje:

[{myObject},null]

aby to uzyskać:

[{myObject}]

można zrobić coś takiego:

mapper.getSerializerProvider().setNullValueSerializer(new JsonSerializer<Object>() {
        @Override
        public void serialize(Object obj, JsonGenerator jsonGen, SerializerProvider unused)
                throws IOException
        {
            //IGNORES NULL VALUES!
        }
    });

WSKAZÓWKA: Jeśli korzystasz z DropWizard, możesz odzyskać dane ObjectMapperużywane przez Jersey za pomocąenvironment.getObjectMapper()

Mamy wiele odpowiedzi na to pytanie. Ta odpowiedź może być pomocna w niektórych scenariuszach. Jeśli chcesz zignorować wartości zerowe, możesz użyć NOT_NULL na poziomie klasy. jak poniżej

@JsonInclude(Include.NON_NULL)
class Foo
{
  String bar;
}

Czasami może być konieczne zignorowanie pustych wartości, na przykład zainicjowanie tablicy tablicowej, ale na tej liście nie ma żadnych elementów. W tym czasie użycie adnotacji NOT_EMPTY w celu zignorowania pustych pól wartości

@JsonInclude(Include.NON_EMPTY)
class Foo
{
  String bar;
}

Jackson 2.x + użycie

mapper.getSerializationConfig().withSerializationInclusion(JsonInclude.Include.NON_NULL);

Musisz także zmienić swoje podejście, używając Map myVariable zgodnie z opisem w dokumentacji, aby wyeliminować wartości null:

From documentation:
com.fasterxml.jackson.annotation.JsonInclude

@JacksonAnnotation
@Target(value={ANNOTATION_TYPE, FIELD, METHOD, PARAMETER, TYPE})
@Retention(value=RUNTIME)
Annotation used to indicate when value of the annotated property (when used for a field, method or constructor parameter), or all properties of the annotated class, is to be serialized. Without annotation property values are always included, but by using this annotation one can specify simple exclusion rules to reduce amount of properties to write out.

*Note that the main inclusion criteria (one annotated with value) is checked on Java object level, for the annotated type, and NOT on JSON output -- so even with Include.NON_NULL it is possible that JSON null values are output, if object reference in question is not `null`. An example is java.util.concurrent.atomic.AtomicReference instance constructed to reference null value: such a value would be serialized as JSON null, and not filtered out.

To base inclusion on value of contained value(s), you will typically also need to specify content() annotation; for example, specifying only value as Include.NON_EMPTY for a {link java.util.Map} would exclude Maps with no values, but would include Maps with `null` values. To exclude Map with only `null` value, you would use both annotations like so:
public class Bean {
   @JsonInclude(value=Include.NON_EMPTY, content=Include.NON_NULL)
   public Map<String,String> entries;
}

Similarly you could Maps that only contain "empty" elements, or "non-default" values (see Include.NON_EMPTY and Include.NON_DEFAULT for more details).
In addition to `Map`s, `content` concept is also supported for referential types (like java.util.concurrent.atomic.AtomicReference). Note that `content` is NOT currently (as of Jackson 2.9) supported for arrays or java.util.Collections, but supported may be added in future versions.
Since:
2.0

Przypadek pierwszy

@JsonInclude(JsonInclude.Include.NON_NULL)
private String someString;

Przypadek drugi

@JsonInclude(JsonInclude.Include.NON_EMPTY)
private String someString;

Jeśli someStringma wartość null, zostanie zignorowany w obu przypadkach. Jeśli someStringjest „”, można to zignorować tylko w przypadku drugim.

To samo dla List = nulllubList.size() = 0