Ignorera Null Fields med Jackson i Java och Spring Boot

Nollvärden uppstår mycket i mjukvaruutveckling, och korrekt hantering av null värderingar kan förvandlas till en vetenskap i sig. Jackson är de-facto-biblioteket för serialisering och deserialisering av Java-objekt – och ett vanligt scenario avser serialisering av objekt som har null fält.

I den här korta handledningen tar vi en titt på hur du kan ignorera nollfält när du serialiserar en POJO med Jackson.

Ändra ObjectMapper-inställningarna

Jacksons ObjectMapper är det centrala API:et som mappar objekt till serialiserade värden. Naturligtvis kan du justera och anpassa hur det fungerar genom olika flaggor, varav en är:

objectMapper.setSerializationInclusion(Include.NON_NULL);

När du serialiserar med denna mappare kommer egenskaper endast att inkluderas om de inte är null.

Detta sätter flaggan globalt för alla objekt som serialiseras med objectMapper exempel. Om du arbetar med Spring Boot och den ObjectMapper den förlitar sig på inte är exponerad, kan du ändra flaggan i application.properties fil:

spring.jackson.default-property-inclusion = non_null

Eller, om du använder application.yml:

spring:
  jackson:
    default-property-inclusion: non_null

Notera: Äldre versioner av Spring används spring.jackson.serialization-inclusion=non_null istället för spring.jackson.default-property-inclusion=non_null.

Alternativt kan du dra tillbaka och ersätta standarden ObjectMapper instans genom att registrera en ny @Primary @Bean, Som heter objectMapper(), som åsidosätter standardimplementeringen och tillåter fullständig anpassning över instansen som kommer att användas som standard vid serialisering och avserialisering:

@Bean
@Primary
public ObjectMapper objectMapper() {
    return new ObjectMapper()
      .setSerializationInclusion(JsonInclude.Include.NON_NULL);
}

Denna @Bean borde gå in valfri fil som är kommenterad med @Configuration annotation, och är ofta placerad antingen i en specialiserad konfigurationsklass eller huvudklassen i Spring Boot-applikationen.

Ändra Jackson2ObjectMapperBuilder-instansen

Våren använder HttpMessageConverters för att konvertera mellan HTTP-meddelanden och objekt. Standardomvandlarna är ObjectMapper och XmlMapper instanser som instansierats via Jackson2ObjectMapperBuilder.

Istället för att manuellt tillhandahålla den primära ObjectMapper (ersätter den som tillhandahålls av byggaren), kan du instruera Spring on hur man bygger objektavbildaren istället. Detta gör att Spring kan göra sina konfigurationer på hög nivå utan att du manipulerar objekten på lägre nivå, samtidigt som du anpassar hur det fungerar. Dessutom kan du också anpassa XmlMapper så här i ett svep.

För att anpassa byggaren registrerar du en ny @Bean of Jackson2ObjectMapperBuilderCustomizer typ, som anpassar och returnerar byggaren:

@Bean
public Jackson2ObjectMapperBuilderCustomizer customBuilder() {
    return builder -> {
      builder.serializationInclusion(JsonInclude.Include.NON_NULL);
    }
}

@JsonInkludera anteckning

I andra änden av spektrumet kan vi använda annoteringar, som ett lågkodsalternativ! Anteckningar kan användas på klassnivå eller metodnivå:

@JsonInclude(JsonInclude.Include.NON_NULL)

Detta gör att du kan anpassa endast vissa klasser, istället för det globala beteendet hos objektmapparen.

Notera: Från och med Jackson 2.0 är anteckningens värde JsonInclude.Include.NON_NULL. För tidigare versioner, använd include=JsonSerialize.Inclusion.NON_NULL.

@JsonInkludera på klassnivå

När du ansöker @JsonInclude på klassnivå sträcker sig annoteringen till alla getters och seters:

@Entity(name="property")
@JsonInclude(JsonInclude.Include.NON_NULL)
public class Property implements Serializable {
    private static final long serialVersionUID = 1L;
    
    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private String id;

    @Column(name="transaction_type")
    private TransactionType transactionType;

    @Column(name="property_type")
    private PropertyType propertyType;
    
    
}

Varje givet fält som har en null värdet kommer inte att serialiseras.

@JsonInkludera på metodnivå

Alternativt kan du använda annoteringen på metodnivå som det mest detaljerade alternativet:

@Entity(name="property")
public class Property implements Serializable {
    private static final long serialVersionUID = 1L;
    
    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private String id;

    @Column(name="transaction_type")
    @JsonInclude(JsonInclude.Include.NON_NULL)
    private TransactionType transactionType;

    @Column(name="property_type")
    private PropertyType propertyType;
    
    
}

I det här utdraget – annoteringen tillämpas endast på TransactionType fält.

Slutsats

I den här guiden har du lärt dig hur du ignorerar nollfält i Jackson, med Java och Spring Boot. Detta kan uppnås globalt genom att ersätta det underliggande implicita ObjectMapper instans och anpassa beteendet för den nya primära bönan du registrerar.

Alternativt kan du anpassa Jackson2ObjectMapperBuilder som bygger ObjectMapper för din applikation istället för att ersätta den redan byggda. För en lösning med låg kod – du kan ändra spring.jackson.default-property-inclusion egendom i dina fastighetsfiler.

Slutligen – du kan använda @JsonInclude anteckning på klassnivå eller metodnivå.