Serialisieren einer Enumeration in einer Spring Boot-Webanwendung

Enum ist eine gute Struktur, um eine Reihe begrenzter und klar definierter Werte innerhalb der Domäne unserer Anwendung zu definieren. Sie könnten dazu beitragen, unmögliche Zustände in unserer Codebasis zu verhindern.

Das Szenario

Lassen Sie uns als Beispiel eine Notizen-Webanwendung verwenden, um die möglichen Möglichkeiten zum Serialisieren und Deserialisieren eines EUM-Werts zu zeigen.

Wir werden es mit Spring Boot 3.3.x und MongoDB implementieren.

Wir definieren eine Type-Enum-Klasse, um die zulässigen Arten von Aufgaben innerhalb der Anwendung darzustellen: Ereignisse und Aktivitäten.

public enum Type {
    EVENT("event"),
    ACTIVITY("activity");

    private Type(String value) {
       this.value = value;
    }

   public String getValue() {
       return value;
    }

}

Unser Todo-Kurs

public class Todo {

    private String id;
    private String name;
    private boolean completed;

    private Type type;

    ...
    ...

}

Wir werden die Enum-Serialisierung in diesen Szenarien analysieren:

1. Enum als Abfrageparameter.
2. Enum als Teil einer JSON-Body-Anfrage.
3. Enum als Feld eines MongoDB-Dokuments.

Enum als Abfrageparameter

In diesem Szenario benötigen wir nur eine Deserialisierungsmethode, da wir an der Umwandlung von einem Zeichenfolgenwert in eine Aufzählung interessiert sind.

Unterhalb eines Codeausschnitts, der die Controller-Methode zum Lesen aller Aufgaben nach Typ darstellt, wird der Typ als Abfrageparameter übergeben.

 public Collection<Todo> read(@RequestParam(required = false) Type type) {
     ...
     ...
 }

Der Abfrageparameter ist eine Zeichenfolge, daher müssen wir einen geeigneten Konverter definieren, um ihn umzuwandeln.
Innerhalb der Convert-Methode rufen wir Type.fromString auf, eine statische Methode, die in der Enum-Klasse erstellt wurde und auch in anderen Szenarien verwendet wird. Der Code der fromString-Methode wird im nächsten Szenario vorgestellt.

public class StringToType implements Converter<String, Type> {

    @Override
    public Type convert(String source) {
        return Type.fromString(source);
    }

}

Der Konverter muss in der Anwendung registriert sein.

@Configuration
public class Config implements WebMvcConfigurer {

    @Override
    public void addFormatters(FormatterRegistry registry) {
        registry.addConverter(new StringToType());
        WebMvcConfigurer.super.addFormatters(registry);
    }
}

Wenn wir nun Type als RequestParam verwenden, wird der StringToType-Konverter verwendet, um zu versuchen, String-Werte in unserer Enumeration zu konvertieren.

Enum als Teil der JSON-Textanforderung

Um die Enumeration als Feld des JSON-Textinhalts korrekt zu verwalten, sollten wir der Enum-Type-Klasse etwas Code hinzufügen.

Wir müssen die Annotation @JsonValue verwenden, um das Feld als den Wert zu markieren, der für die Serialisierung der Aufzählung verwendet werden soll.
Dann sollten wir eine statische Zuordnung innerhalb der Aufzählung hinzufügen, um den Typ der zugehörigen Zeichenfolgendarstellung zuzuordnen.

public enum Type {
    EVENT("event"),
    ACTIVITY("activity");

    @JsonValue
    private String value;

    private static Map<String, Type> enumMap;

    private Type(String value) {
        this.value = value;
    }

    static {
        enumMap = Stream.of(values()).collect(Collectors.toMap(t -> t.value, t -> t));
    }

    public static Type fromString(String value) {
        return enumMap.get(value);
    }

    public String getValue() {
        return value;
    }

}

Enum als Feld eines MongoDB-Dokuments.

Um die Serialisierung/Deserialisierung einer Aufzählung in einem MongoDB-Dokument zu verwalten, müssen wir die Annotation @ValueConverter verwenden, die ein Feld des Dokuments mit einer bestimmten PropertyValueConverter-Klasse verbindet.

Im Beispiel ist der Feldtyptyp an den MongoEnumConverter gebunden, der Lese- und Schreibmethoden zur Verwaltung der Konvertierung bereitstellt.

@Document(collection = "todo")
@TypeAlias("todo")
public class Todo {

    @Id
    private String id;
    private String name;
    private boolean completed;

    @ValueConverter(MongoEnumConverter.class)
    private Type type;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public boolean isCompleted() {
        return completed;
    }

    public void setCompleted(boolean completed) {
        this.completed = completed;
    }

    public Type getType() {
        return type;
    }

    public void setType(Type type) {
        this.type = type;
    }

}

Im Detail rufen wir in der Lesemethode Type.fromString aus der Enum-Klasse auf, um zu versuchen, den String in eine gültige Type-Instanz zu konvertieren.

public enum Type {
    EVENT("event"),
    ACTIVITY("activity");

    private Type(String value) {
       this.value = value;
    }

   public String getValue() {
       return value;
    }

}

Abschließend

In diesem Artikel habe ich einige Möglichkeiten vorgestellt, die Serialisierung/Deserialisierung einer Enum-Klasse in einem typischen Webszenario zu verwalten. Spring und die Jackson-Bibliothek bieten einige Einrichtungen, um diese Arbeit zu vereinfachen.

Der Code ist in diesem Gitlab-Repository öffentlich verfügbar.

Der in diesem Artikel vorgestellte Code steht unter der CC0-Lizenz.

Das obige ist der detaillierte Inhalt vonSerialisieren einer Enumeration in einer Spring Boot-Webanwendung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!