Sérialiser une énumération dans une application Web Spring Boot

Enum est une bonne structure pour définir un ensemble de valeurs limitées et bien définies à l'intérieur du domaine de notre application. Ils pourraient aider à éviter les états impossibles dans notre base de code.

Le scénario

Utilisons une application Web de prise de notes comme exemple pour montrer les manières possibles de sérialiser et de désérialiser une valeur eum.

Nous allons l'implémenter en utilisant Spring Boot 3.3.x et MongoDB.

Nous définissons une classe d'énumération Type pour représenter les types de tâches autorisés dans l'application : événements et activités.

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

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

   public String getValue() {
       return value;
    }

}

Notre cours Todo

public class Todo {

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

    private Type type;

    ...
    ...

}

Nous allons analyser la sérialisation des énumérations dans ces scénarios :

1. Enum comme paramètre de requête.
2. Enum dans le cadre d'une requête de corps JSON.
3. Enum comme champ d'un document MongoDB.

Enum comme paramètre de requête

Dans ce scénario, nous n'avons besoin que d'une méthode de désérialisation car nous souhaitons passer d'une valeur de chaîne à une énumération.

Ci-dessous un extrait de code représentant la méthode Controller pour lire toutes les tâches par types, le type est passé en paramètre de requête.

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

Le paramètre de requête est une chaîne, nous devons donc définir un convertisseur approprié pour le transformer.
Dans la méthode convert, nous appelons Type.fromString, une méthode statique créée dans la classe enum, qui sera également utilisée dans d'autres scénarios. Le code de la méthode fromString est présenté dans le scénario suivant.

public class StringToType implements Converter<string type> {

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

}
</string>

Le convertisseur doit être enregistré dans l'application.

@Configuration
public class Config implements WebMvcConfigurer {

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

Maintenant, lorsque nous utiliserons Type comme RequestParam, le convertisseur StringToType sera utilisé pour essayer de convertir les valeurs de chaîne dans notre énumération.

Enum dans le cadre de la requête du corps JSON

Pour gérer correctement l'énumération en tant que champ du contenu du corps JSON, nous devons ajouter du code à la classe Type enum.

Nous devons utiliser l'annotation @JsonValue pour marquer le champ comme valeur à utiliser pour sérialiser l'énumération.
Ensuite, nous devrions ajouter une carte statique à l'intérieur de l'énumération pour mapper le type avec la représentation sous forme de chaîne associée.

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

}
</string>

Enum en tant que champ d'un document MongoDB.

Pour gérer la sérialisation/désérialisation d'une énumération dans un document MongoDB nous devons utiliser l'annotation @ValueConverter qui lie un champ du document avec une classe PropertyValueConverter spécifique.

Dans l'exemple, le type de champ Type est lié au MongoEnumConverter qui fournit des méthodes de lecture et d'écriture pour gérer la conversion.

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

}

En détail dans la méthode read, nous appelons Type.fromString à partir de la classe enum pour essayer de convertir la chaîne en une instance de Type valide.

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

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

   public String getValue() {
       return value;
    }

}

En conclusion

Dans cet article, j'ai présenté quelques façons de gérer la sérialisation/désérialisation d'une classe enum dans un scénario Web typique. Spring et la bibliothèque Jackson offrent quelques fonctionnalités pour simplifier ce travail.

Le code est accessible au public dans ce référentiel Gitlab.

Les codes présentés dans cet article sont sous licence CC0.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!