it-swarm.com.de

Wie kann Jackson angewiesen werden, ein Feld während der Serialisierung zu ignorieren, wenn sein Wert Null ist?

Wie kann Jackson so konfiguriert werden, dass ein Feldwert während der Serialisierung ignoriert wird, wenn der Wert dieses Felds null ist?.

Zum Beispiel:

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; 
}
640
ams

Um Serialisierungseigenschaften mit Nullwerten unter Verwendung von Jackson> 2.0 zu unterdrücken, können Sie ObjectMapper direkt konfigurieren oder die Annotation @JsonInclude verwenden:

_mapper.setSerializationInclusion(Include.NON_NULL);
_

oder:

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

Alternativ können Sie _@JsonInclude_ in einem Getter verwenden, damit das Attribut angezeigt wird, wenn der Wert nicht null ist.

Ein vollständigeres Beispiel finden Sie in meine Antwort bis So verhindern Sie, dass Nullwerte in einer Map und Nullfelder in einer Bean durch Jackson serialisiert werden .

1037

Verwenden Sie bei Jackson> 1.9.11 und <2.x die Annotation @JsonSerialize, um dies zu tun:

@JsonSerialize(include=JsonSerialize.Inclusion.NON_NULL)

124
WTK

Um nur die anderen Antworten zu erläutern: Wenn Sie das Auslassen von Nullwerten auf Feldbasis steuern müssen, können Sie das betreffende Feld mit Anmerkungen versehen (oder alternativ den Getter des Felds mit Anmerkungen versehen).

Beispiel - hier wird nur fieldOne von json weggelassen, wenn es null ist. fieldTwo wird immer eingeschlossen, unabhängig davon, ob es null ist.

public class Foo {

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

    private String fieldTwo;
}

Kommentieren Sie die Klasse, um standardmäßig alle Nullwerte in der Klasse auszulassen. Anmerkungen pro Feld/Getter können weiterhin verwendet werden, um diese Standardeinstellung bei Bedarf zu überschreiben.

Beispiel - hier fieldOne und fieldTwo werden von json ausgelassen, wenn sie jeweils null sind, da dies die Standardeinstellung der Klassenanmerkung ist. fieldThree überschreibt jedoch die Standardeinstellung und wird aufgrund der Anmerkung auf dem Feld immer eingeschlossen.

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

    private String fieldOne;

    private String fieldTwo;

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

UPDATE

Das obige ist für Jackson 2. Für frühere Versionen von Jackson müssen Sie Folgendes verwenden:

@JsonSerialize(include=JsonSerialize.Inclusion.NON_NULL) 

anstatt von

@JsonInclude(JsonInclude.Include.NON_NULL)

Wenn dieses Update nützlich ist, stimmen Sie die Antwort von ZiglioUK weiter oben ab. Es wurde auf die neuere Anmerkung von Jackson 2 hingewiesen, lange bevor ich meine Antwort aktualisiert habe, um sie zu verwenden!

111
davnicwil

Verwenden Sie in Jackson 2.x:

@JsonInclude(JsonInclude.Include.NON_NULL)
58
ZiglioUK

Sie können die folgende Mapper-Konfiguration verwenden:

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

Seit 2.5 können Sie Benutzer:

mapper.setSerializationInclusion(Include.NON_NULL);
35
Eren Yilmaz

Sie können application.properties einstellen:

spring.jackson.default-property-inclusion=non_null

oder application.yaml:

spring:
  jackson:
    default-property-inclusion: non_null

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

18
Yury

in meinem Fall

@JsonInclude(Include.NON_EMPTY)

hat es geschafft.

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

sollte arbeiten.

Include.NON_EMPTY gibt an, dass die Eigenschaft serialisiert wird, wenn ihr Wert nicht null und nicht leer ist. Include.NON_NULL gibt an, dass die Eigenschaft serialisiert wird, wenn ihr Wert nicht null ist.

7
Neha Gangwar

Wenn Sie sich in Spring Boot befinden, können Sie den jackson ObjectMapper direkt über Eigenschaftendateien anpassen.

Beispiel application.yml:

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

Mögliche Werte sind:

always|non_null|non_absent|non_default|non_empty

Weitere Informationen: https://docs.spring.io/spring-boot/docs/current/reference/html/howto-spring-mvc.html#howto-customize-the-jackson-objectmapper

5
acdcjunior

Dies funktioniert in Spring Boot 2.0.3+ und Jackson 2.0 +

import com.fasterxml.jackson.annotation.JsonInclude;

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

Wenn Sie diese Regel zu allen Modellen in Jackson 2.6+ hinzufügen möchten, verwenden Sie:

mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
5
Ilia Kurtov

Für Jackson 2.5 verwenden Sie:

@JsonInclude(content=Include.NON_NULL)
3
Bilal BBB

Wenn Sie versuchen, eine Liste von Objekten zu serialisieren, von denen eines null ist, wird das Element null auch mit json aufgenommen

mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

wird darin enden, dass:

[{myObject}, null]

um dies zu bekommen:

[{myObject}]

man kann so etwas machen wie:

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

TIPP: Wenn Sie DropWizard verwenden, können Sie den von Jersey verwendeten ObjectMapper mit environment.getObjectMapper () abrufen.

2
user3474985

Das beunruhigt mich schon seit einiger Zeit und ich habe endlich das Problem gefunden. Das Problem war auf einen falschen Import zurückzuführen. Früher hatte ich verwendet

com.fasterxml.jackson.databind.annotation.JsonSerialize

Welches war veraltet. Ersetzen Sie einfach den Import durch

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

und benutze es als

@JsonSerialize(include=Inclusion.NON_NULL)
2
user3443646

Globale Konfiguration, wenn Sie Spring verwenden

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

}
2
Xelian

Jackson 2.x + verwenden

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

Außerdem müssen Sie Ihren Ansatz ändern, wenn Sie Map myVariable wie in der Dokumentation beschrieben verwenden, um Nullen zu beseitigen:

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
0
atom88