Jackson-Anmerkungen verstehen

Jackson ist eine beliebte Bibliothek in Java, die zum Konvertieren von Java-Objekten in JSON und umgekehrt verwendet wird. Das leistungsstarke Annotationssystem ermöglicht es Entwicklern, den Serialisierungs- und Deserialisierungsprozess nach ihren Bedürfnissen anzupassen. In diesem Artikel werden wir verschiedene Jackson-Anmerkungen umfassend erkunden und detaillierte Erklärungen sowie Codebeispiele für jede Anmerkung bereitstellen.

1. Jackson-Serialisierungsanmerkungen

Die Serialisierung ist der Prozess der Umwandlung eines Java-Objekts in eine JSON-Darstellung. Hier sind die wichtigsten Serialisierungsanmerkungen:

@JsonProperty

Die @JsonProperty-Anmerkung wird verwendet, um den Eigenschaftsnamen in der JSON-Ausgabe anzugeben. Sie kann auch verwendet werden, um eine Eigenschaft als erforderlich zu kennzeichnen.

import com.fasterxml.jackson.annotation.JsonProperty;

    public class User {
        @JsonProperty("user_name")
        private String name;

        @JsonProperty(required = true)
        private String email;

        // Getter und Setter
    }

@JsonIgnore

Die @JsonIgnore-Anmerkung wird verwendet, um ein Feld von der Serialisierung auszuschließen. Dies ist nützlich, wenn Sie sensible Informationen verbergen oder zirkuläre Referenzen vermeiden möchten.

import com.fasterxml.jackson.annotation.JsonIgnore;

    public class User {
        private String name;

        @JsonIgnore
        private String password; // Wird nicht in der JSON-Ausgabe enthalten sein

        // Getter und Setter
    }

@JsonInclude

Die @JsonInclude-Anmerkung gibt an, welche Eigenschaften basierend auf bestimmten Kriterien in die Serialisierung einbezogen werden. Sie kann verwendet werden, um null-Werte oder leere Sammlungen in der Ausgabe zu vermeiden.

import com.fasterxml.jackson.annotation.JsonInclude;
    import com.fasterxml.jackson.annotation.JsonInclude.Include;

    public class User {
        private String name;

        @JsonInclude(Include.NON_NULL) // Nur einbeziehen, wenn nicht null
        private String email;

        @JsonInclude(Include.NON_EMPTY) // Nur einbeziehen, wenn nicht leer
        private List roles;

        // Getter und Setter
    }

@JsonFormat

Die @JsonFormat-Anmerkung wird verwendet, um das Format von Datum- und Zeit-Eigenschaften während der Serialisierung anzugeben.

import com.fasterxml.jackson.annotation.JsonFormat;

    public class Event {
        private String title;

        @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss")
        private Date eventDate;

        // Getter und Setter
    }

@JsonAutoDetect

Die @JsonAutoDetect-Anmerkung ermöglicht es Ihnen, die Sichtbarkeit von Eigenschaften während der Serialisierung und Deserialisierung zu steuern. Sie lässt Sie festlegen, welche Felder basierend auf ihrer Sichtbarkeit (öffentlich, geschützt usw.) zugänglich sind.

import com.fasterxml.jackson.annotation.JsonAutoDetect;
    import com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility;

    @JsonAutoDetect(fieldVisibility = Visibility.ANY) // Alle Felder unabhängig von der Sichtbarkeit serialisieren
    public class User {
        private String name; // Privates Feld wird trotzdem einbezogen

        // Getter und Setter
    }

2. Jackson-Deserialisierungsanmerkungen

Die Deserialisierung ist der Prozess der Umwandlung von JSON zurück in Java-Objekte. Hier sind die wichtigen Deserialisierungsanmerkungen:

@JsonCreator

Die @JsonCreator-Anmerkung wird verwendet, um einen Konstruktor oder eine Fabrikmethode anzugeben, die Jackson verwenden soll, um eine Instanz der Klasse während der Deserialisierung zu erstellen.

import com.fasterxml.jackson.annotation.JsonCreator;
    import com.fasterxml.jackson.annotation.JsonProperty;

    public class User {
        private String name;
        private String email;

        @JsonCreator
        public User(@JsonProperty("user_name") String name, @JsonProperty("email") String email) {
            this.name = name;
            this.email = email;
        }

        // Getter und Setter
    }

@JsonSetter

Die @JsonSetter-Anmerkung ermöglicht es Ihnen, eine Methode anzugeben, die verwendet werden soll, um eine Eigenschaft während der Deserialisierung zu setzen.

import com.fasterxml.jackson.annotation.JsonSetter;

    public class User {
        private String name;

        @JsonSetter("user_name")
        public void setName(String name) {
            this.name = name;
        }

        // Getter
    }

3. Jackson-Eigenschaftseinbeziehungsanmerkungen

Diese Anmerkungen steuern die Einbeziehung von Eigenschaften während der Serialisierung:

@JsonInclude

Wir haben dies bereits im Serialisierungsabschnitt besprochen, aber es gilt sowohl für die Serialisierung als auch für die Deserialisierung. Es hilft, unnötige Daten zu vermeiden.

@JsonPropertyOrder

Die @JsonPropertyOrder-Anmerkung ermöglicht es Ihnen, die Reihenfolge anzugeben, in der Eigenschaften serialisiert werden.

import com.fasterxml.jackson.annotation.JsonPropertyOrder;

    @JsonPropertyOrder({ "email", "user_name" })
    public class User {
        private String name;
        private String email;

        // Getter und Setter
    }

4. Jackson-Anmerkungen zur polymorphen Typbehandlung

Diese Anmerkungen helfen bei der Handhabung polymorpher Typen während der Serialisierung und Deserialisierung:

@JsonTypeInfo

Die @JsonTypeInfo-Anmerkung wird verwendet, um Typinformationen in JSON für polymorphe Typen einzufügen.

import com.fasterxml.jackson.annotation.JsonSubTypes;
    import com.fasterxml.jackson.annotation.JsonTypeInfo;

    @JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.PROPERTY, property = "type")
    @JsonSubTypes({
        @JsonSubTypes.Type(value = Dog.class, name = "dog"),
        @JsonSubTypes.Type(value = Cat.class, name = "cat")
    })
    public abstract class Animal {
        // Abstrakte Klasse für Tiere
    }

@JsonSubTypes

Diese Anmerkung wird zusammen mit @JsonTypeInfo verwendet, um die Unterklassen für die polymorphe Typbehandlung zu definieren.

5. Jackson-Allgemeinanmerkungen

Dies sind allgemein verwendbare Anmerkungen, die in verschiedenen Szenarien Anwendung finden:

@JsonRootName

Die @JsonRootName-Anmerkung wird verwendet, um den Namen des Wurzelelements in der serialisierten JSON anzugeben.

import com.fasterxml.jackson.annotation.JsonRootName;

    @JsonRootName(value = "user")
    public class User {
        private String name;

        // Getter und Setter
    }

@JsonAnyGetter und @JsonAnySetter

Diese Anmerkungen ermöglichen es Ihnen, dynamische Eigenschaften in Ihrem Objekt zu handhaben.

import com.fasterxml.jackson.annotation.JsonAnyGetter;
    import com.fasterxml.jackson.annotation.JsonAnySetter;

    public class User {
        private String name;
        private Map additionalProperties = new HashMap<>();

        @JsonAnyGetter
        public Map getAdditionalProperties() {
            return additionalProperties;
        }

        @JsonAnySetter
        public void setAdditionalProperty(String name, Object value) {
            this.additionalProperties.put(name, value);
        }
    }

6. @JsonManagedReference und @JsonBackReference

Diese Anmerkungen werden verwendet, um bidirektionale Beziehungen zwischen Objekten zu behandeln, um zirkuläre Referenzen während der Serialisierung zu vermeiden.

import com.fasterxml.jackson.annotation.JsonBackReference;
    import com.fasterxml.jackson.annotation.JsonManagedReference;

    public class User {
        @JsonManagedReference
        private List orders;
    }

    public class Order {
        @JsonBackReference
        private User user;
    }

7. Benutzerdefinierte Jackson-Anmerkungen

Sie können auch Ihre eigenen Anmerkungen erstellen, um spezifische Anforderungen zu erfüllen.

import com.fasterxml.jackson.annotation.JsonProperty;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;

    @Retention(RetentionPolicy.RUNTIME)
    @JsonProperty
    public @interface CustomJsonProperty {
        String value();
    }

8. Jackson MixIn-Anmerkungen

MixIn-Anmerkungen ermöglichen es Ihnen, Anmerkungen zu vorhandenen Klassen hinzuzufügen, ohne sie ändern zu müssen.

import com.fasterxml.jackson.annotation.JsonProperty;

    public abstract class UserMixIn {
        @JsonProperty("user_name")
        String name;
    }

9. Deaktivieren von Jackson-Anmerkungen

Sie können spezifische Funktionen von Jackson mithilfe von Anmerkungen deaktivieren. Zum Beispiel können Sie verhindern, dass Jackson bei leeren Beans fehlschlägt:

import com.fasterxml.jackson.databind.ObjectMapper;
    import com.fasterxml.jackson.databind.SerializationFeature;

    ObjectMapper mapper = new ObjectMapper();
    mapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS); // Deaktivieren des Fehlers bei leeren Beans
    

Fazit

Jackson bietet ein robustes Set von Anmerkungen, das es Entwicklern ermöglicht, anzupassen, wie Java-Objekte in JSON serialisiert und aus JSON deserialisiert werden. Das Verständnis dieser Anmerkungen und ihrer geeigneten Anwendungsfälle ist entscheidend für die Entwicklung effektiver Java-Anwendungen, die mit JSON-Daten interagieren.

Durch die Nutzung der Leistungsfähigkeit von Jackson-Anmerkungen können Sie sicherstellen, dass die Datenverarbeitung Ihrer Anwendung die erforderlichen Anforderungen an Struktur, Sicherheit und Leistung erfüllt.