Beispielcode zum Serialisieren und Deserialisieren von Java Enum-Enumerationen und JSON in Jackson

Überblick

--Übersetzen Sie zwischen Java Enum-Aufzählung und Werten in JSON --Verwenden Sie die von Jackson bereitgestellten abstrakten Klassen JsonSerializer und JsonDeserializer

Betriebsüberprüfungsumgebung

Java 11 (AdoptOpenJDK 11.0.6+10)
Jackson Databind 2.10.3
Gradle 6.2.1
macOS Catalina

Beispielcode

package com.example.humansex;

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;

import java.io.IOException;

/**
 * ISO 5218 (Code für die Notation des menschlichen Geschlechts)Ein Aufzählungstyp, der darstellt.
 *Geschlechtscode:Unbekannt=0,männlich=1,Weiblich=2,Unzutreffend=9
 */
public enum HumanSex {

  /**
   *Unbekannt=0,männlich=1,Weiblich=2,Unzutreffend=9
   */
  NOT_KNOWN(0), MALE(1), FEMALE(2), NOT_APPLICABLE(9);

  private final int code;

  private HumanSex(int code) {
    this.code = code;
  }

  /**
   *Gibt den Geschlechtscode zurück.
   */
  public int getCode() {
    return code;
  }

  /**
   *Gibt eine HumanSex-Aufzählungskonstante zurück, die dem Geschlechtscode entspricht.
   *
   * @Parametercode Geschlechtscode
   * @Rückgabe der HumanSex-Aufzählungskonstante
   */
  public static HumanSex codeOf(int code) {
    for (HumanSex value : HumanSex.values()) {
      if (code == value.getCode()) {
        return value;
      }
    }
    return null; //Stimmt nicht überein
  }

  /**
   *Eine Klasse, die ein HumanSex-Objekt in JSON serialisiert.
   */
  public static class Serializer extends JsonSerializer<HumanSex> {

    /**
     *Geschlechtscode für das HumanSex-Objekt beim Generieren von JSON(Integer Wert)Konvertieren zu.
     */
    @Override
    public void serialize(HumanSex value, JsonGenerator generator, SerializerProvider serializers) throws IOException {
      generator.writeNumber(value.getCode());
    }
  }

  /**
   *Eine Klasse, die ein HumanSex-Objekt von JSON deserialisiert.
   */
  public static class Deserializer extends JsonDeserializer<HumanSex> {

    /**
     *Geschlechtscode beim Parsen von JSON(Integer Wert)Zu einem HumanSex-Objekt.
     */
    @Override
    public HumanSex deserialize(JsonParser parser, DeserializationContext context) throws IOException {
      return HumanSex.codeOf(parser.getIntValue());
    }
  }
}

package com.example;

import com.example.humansex.HumanSex;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;

import java.util.ArrayList;
import java.util.List;

public class MyData {

  public List<Person> personList = new ArrayList<>();

  @Override
  public String toString() {
    StringBuilder buf = new StringBuilder();
    for (Person person : personList) {
      buf.append(person + System.lineSeparator());
    }
    return buf.toString();
  }

  public static class Person {

    public String name;

    //Geben Sie die Klasse an, die beim Generieren und Analysieren von JSON von Jackson mit einer Anmerkung verwendet werden soll
    @JsonSerialize(using = HumanSex.Serializer.class)
    @JsonDeserialize(using = HumanSex.Deserializer.class)
    public HumanSex sex;

    public Person() {
    }

    public Person(String name, HumanSex sex) {
      this.name = name;
      this.sex = sex;
    }

    @Override
    public String toString() {
      return "name=[" + name + "], sex=[" + sex.toString() + "]";
    }
  }
}

package com.example;

import com.example.humansex.HumanSex;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.io.IOException;
import java.io.StringWriter;

public class App {

  public static void main(String[] args) throws IOException {

    //Datenobjekt generieren
    MyData inputData = new MyData();
    inputData.personList.add(new MyData.Person("Peko",   HumanSex.NOT_KNOWN));
    inputData.personList.add(new MyData.Person("Anubis", HumanSex.MALE));
    inputData.personList.add(new MyData.Person("Isis",   HumanSex.FEMALE));
    inputData.personList.add(new MyData.Person("Robot",  HumanSex.NOT_APPLICABLE));

    //Generieren Sie eine JSON-Zeichenfolge aus einem Datenobjekt in Jackson
    StringWriter out = new StringWriter();
    new ObjectMapper().writerWithDefaultPrettyPrinter().writeValue(out, inputData);
    String json = out.toString();

    //JSON-Zeichenfolge ausgeben
    System.out.println("***** Mydata → JSON *****");
    System.out.println(json);

    //Analysieren Sie die JSON-Zeichenfolge in Jackson und konvertieren Sie sie in ein Datenobjekt
    MyData outputData = new ObjectMapper().readValue(json, MyData.class);

    //Zeichenfolgendarstellung des Objekts ausgeben
    System.out.println("***** JSON → Mydata *****");
    System.out.println(outputData);
  }
}

Gradle-Konfigurationsdatei

Bereiten Sie eine Konfigurationsdatei build.gradle für das Erstellen und Ausführen mit Gradle vor.

build.gradle 
plugins {
  id 'java'
  id 'application'
}

group 'org.example'
version '0.0.1'

sourceCompatibility = 11

repositories {
  mavenCentral()
}

dependencies {
  implementation 'com.fasterxml.jackson.core:jackson-databind:2.10.3'
}

application {
  mainClassName = 'com.example.App'
}

Ausführungsergebnis

***** Mydata → JSON *****
{
  "personList" : [ {
    "name" : "Peko",
    "sex" : 0
  }, {
    "name" : "Anubis",
    "sex" : 1
  }, {
    "name" : "Isis",
    "sex" : 2
  }, {
    "name" : "Robot",
    "sex" : 9
  } ]
}
***** JSON → Mydata *****
name=[Peko], sex=[NOT_KNOWN]
name=[Anubis], sex=[MALE]
name=[Isis], sex=[FEMALE]
name=[Robot], sex=[NOT_APPLICABLE]