Ein Leitfaden für FastJson

1. Überblick

FastJson ist eine kompakte Java-Bibliothek, mit der JSON-Zeichenfolgen effektiv in Java-Objekte konvertiert werden und umgekehrt.

In diesem Artikel werden wir uns mit mehreren konkreten und praktischen Anwendungen der FastJson-Bibliothek befassen.

2. Maven-Konfiguration

Um mit FastJson arbeiten zu können, müssen wir dies zunächst zu unserenpom.xml hinzufügen:


    com.alibaba
    fastjson
    1.2.13

Und als kurze Anmerkung:here’s the most updated version der Bibliothek in Maven Central.

3. Konvertieren Sie Java-Objekte in das JSON-Format

Definieren wir die folgende Java-Bean vonPerson:

public class Person {

    @JSONField(name = "AGE")
    private int age;

    @JSONField(name = "FULL NAME")
    private String fullName;

    @JSONField(name = "DATE OF BIRTH")
    private Date dateOfBirth;

    public Person(int age, String fullName, Date dateOfBirth) {
        super();
        this.age = age;
        this.fullName= fullName;
        this.dateOfBirth = dateOfBirth;
    }

    // standard getters & setters
}

Wir könnenJSON.toJSONString() verwenden, um ein Java-Objekt in einen JSON-String zu konvertieren:

private List listOfPersons = new ArrayList();

@Before
public void setUp() {
    listOfPersons.add(new Person(15, "John Doe", new Date()));
    listOfPersons.add(new Person(20, "Janette Doe", new Date()));
}

@Test
public void whenJavaList_thanConvertToJsonCorrect() {
    String jsonOutput= JSON.toJSONString(listOfPersons);
}

Und hier ist das Ergebnis:

[
    {
        "AGE":15,
        "DATE OF BIRTH":1468962431394,
        "FULL NAME":"John Doe"
    },
    {
        "AGE":20,
        "DATE OF BIRTH":1468962431394,
        "FULL NAME":"Janette Doe"
    }
]

Wir können auch weiter gehen und mit der Anpassung der Ausgabe beginnen und Dinge wieordering, Datumformatting oderserialization Flags steuern.

Beispiel: Lassen Sie uns die Bean aktualisieren und ein paar weitere Felder hinzufügen:

@JSONField(name="AGE", serialize=false)
private int age;

@JSONField(name="LAST NAME", ordinal = 2)
private String lastName;

@JSONField(name="FIRST NAME", ordinal = 1)
private String firstName;

@JSONField(name="DATE OF BIRTH", format="dd/MM/yyyy", ordinal = 3)
private Date dateOfBirth;

Hier ist eine Liste der grundlegendsten Parameter, die wir zusammen mit der Annotation@JSONFieldverwenden können, um den Konvertierungsprozess anzupassen:

Der Parameterformat wird verwendet, um das Attributdate richtig zu formatieren
Standardmäßig serialisiert die FastJson-Bibliothek die Java-Bean vollständig, wir können jedoch den Parameterserialize verwenden, um die Serialisierung für bestimmte Felder zu ignorieren
Der Parameterordinal wird verwendet, um die Feldreihenfolge anzugeben

Und hier ist die neue Ausgabe:

[
    {
        "FIRST NAME":"Doe",
        "LAST NAME":"Jhon",
        "DATE OF BIRTH":"19/07/2016"
    },
    {
        "FIRST NAME":"Doe",
        "LAST NAME":"Janette",
        "DATE OF BIRTH":"19/07/2016"
    }
]

FastJson unterstützt auch eine sehr interessanteBeanToArray serialization-Funktion:

String jsonOutput= JSON.toJSONString(listOfPersons, SerializerFeature.BeanToArray);

So sieht die Ausgabe in diesem Fall aus:

[
    [
        15,
        1469003271063,
        "John Doe"
    ],
    [
        20,
        1469003271063,
        "Janette Doe"
    ]
]

4. Erstellen Sie JSON-Objekte

Wie beiother JSON libraries ist das Erstellen eines JSON-Objekts von Grund auf ziemlich einfach. Es geht nur darum,JSONObject- undJSONArray-Objekte zu kombinieren:

@Test
public void whenGenerateJson_thanGenerationCorrect() throws ParseException {
    JSONArray jsonArray = new JSONArray();
    for (int i = 0; i < 2; i++) {
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("AGE", 10);
        jsonObject.put("FULL NAME", "Doe " + i);
        jsonObject.put("DATE OF BIRTH", "2016/12/12 12:12:12");
        jsonArray.add(jsonObject);
    }
    String jsonOutput = jsonArray.toJSONString();
}

Und so sieht die Ausgabe hier aus:

[
   {
      "AGE":"10",
      "DATE OF BIRTH":"2016/12/12 12:12:12",
      "FULL NAME":"Doe 0"
   },
   {
      "AGE":"10",
      "DATE OF BIRTH":"2016/12/12 12:12:12",
      "FULL NAME":"Doe 1"
   }
]

5. Analysieren Sie JSON-Strings in Java-Objekte

Nachdem wir nun wissen, wie Sie ein JSON-Objekt von Grund auf neu erstellen und Java-Objekte in ihre JSON-Darstellungen konvertieren, konzentrieren wir uns darauf, wie eine JSON-Darstellung analysiert wird:

@Test
public void whenJson_thanConvertToObjectCorrect() {
    Person person = new Person(20, "John", "Doe", new Date());
    String jsonObject = JSON.toJSONString(person);
    Person newPerson = JSON.parseObject(jsonObject, Person.class);

    assertEquals(newPerson.getAge(), 0); // if we set serialize to false
    assertEquals(newPerson.getFullName(), listOfPersons.get(0).getFullName());
}

Wir könnenJSON.parseObject() verwenden, um ein Java-Objekt aus einem JSON-String abzurufen.

Beachten Sie, dass Sie einno-args or default constructor definieren müssen, wenn Sie bereits Ihr eigenes parametrisiertes deklariert haben. Andernfalls wird eincom.alibaba.fastjson.JSONException ausgelöst.

Hier ist die Ausgabe dieses einfachen Tests:

Person [age=20, fullName=John Doe, dateOfBirth=Wed Jul 20 08:51:12 WEST 2016]

Wenn Sie die Optiondeserialize in der Annotation@JSONField verwenden, können Sie die Deserialisierung für ein bestimmtes Feld ignorieren. In diesem Fall wird der Standardwert automatisch auf das ignorierte Feld angewendet:

@JSONField(name = "DATE OF BIRTH", deserialize=false)
private Date dateOfBirth;

Und hier ist das neu erstellte Objekt:

Person [age=20, fullName=John Doe, dateOfBirth=null]

6. Konfigurieren Sie die JSON-Konvertierung mitContextValueFilter

In einigen Szenarien benötigen wir möglicherweisemore control für den Konvertierungsprozess von Java-Objekten in das JSON-Format.

In diesem Fall können wir das ObjektContextValueFilterverwenden, um zusätzliche Filterung und benutzerdefinierte Verarbeitung auf den Konvertierungsfluss anzuwenden:

@Test
public void givenContextFilter_whenJavaObject_thanJsonCorrect() {
    ContextValueFilter valueFilter = new ContextValueFilter () {
        public Object process(
          BeanContext context, Object object, String name, Object value) {
            if (name.equals("DATE OF BIRTH")) {
                return "NOT TO DISCLOSE";
            }
            if (value.equals("John")) {
                return ((String) value).toUpperCase();
            } else {
                return null;
            }
        }
    };
    String jsonOutput = JSON.toJSONString(listOfPersons, valueFilter);
}

In diesem Beispiel haben wir das FeldDATE OF BIRTH ausgeblendet, indem wir einen konstanten Wert erzwungen haben. Außerdem haben wir alle Felder ignoriert, die nichtJohn oderDoe: sind

[
    {
        "FULL NAME":"JOHN DOE",
        "DATE OF BIRTH":"NOT TO DISCLOSE"
    }
]

Wie Sie sehen, ist dies ein ziemlich einfaches Beispiel, aber Sie können dieselben Konzepte natürlich auch für komplexere Szenarien verwenden - indem Sie diese leistungsstarken und kompakten Tools von FastJson in einem realen Projekt kombinieren.

7. Verwenden vonNameFilter undSerializeConfig

FastJson bietet eine Reihe von Tools, mit denen Sie Ihre JSON-Operationen beim Umgang mit beliebigen Objekten anpassen können - Objekte, deren Quellcode wir nicht haben.

Stellen wir uns vor, wir haben eine kompilierte Version der Java-BeanPerson, die ursprünglich in diesem Artikel deklariert wurde, und wir müssen einige Verbesserungen bei der Benennung von Feldern und der grundlegenden Formatierung vornehmen:

@Test
public void givenSerializeConfig_whenJavaObject_thanJsonCorrect() {
    NameFilter formatName = new NameFilter() {
        public String process(Object object, String name, Object value) {
            return name.toLowerCase().replace(" ", "_");
        }
    };

    SerializeConfig.getGlobalInstance().addFilter(Person.class,  formatName);
    String jsonOutput =
      JSON.toJSONStringWithDateFormat(listOfPersons, "yyyy-MM-dd");
}

Wir haben den FilterformatNamemit der anonymen KlasseNameFilterdeklariert, um Feldnamen zu verarbeiten. Der neu erstellte Filter wird der KlassePersonzugeordnet und dann einer globalen Instanz hinzugefügt. Dies ist im Grunde ein statisches Attribut in der KlasseSerializeConfig.

Jetzt können wir unser Objekt bequem in das JSON-Format konvertieren, wie weiter oben in diesem Artikel gezeigt.

Beachten Sie, dass wirtoJSONStringWithDateFormat() anstelle vontoJSONString() verwendet haben, um schnell dieselbe Formatierungsregel auf Datumsfelder anzuwenden.

Und hier ist die Ausgabe:

[
    {
        "full_name":"John Doe",
        "date_of_birth":"2016-07-21"
    },
    {
        "full_name":"Janette Doe",
        "date_of_birth":"2016-07-21"
    }
]

Wie Sie sehen können -the fields names got changed, und der Datumswert wurde richtig formatiert.

Durch die Kombination vonSerializeFilter mitContextValueFilter kann der Konvertierungsprozess für beliebige und komplexe Java-Objekte vollständig gesteuert werden.

8. Fazit

In diesem Artikel wurde gezeigt, wie Sie mit FastJson Java-Beans in JSON-Strings konvertieren und umgekehrt vorgehen. Wir haben auch gezeigt, wie einige dercore features of FastJson verwendet werden, um die JSON-Ausgabe anzupassen.

Wie Sie sehen können,the library offers a relatively simple to use but still very powerful API.JSON.toJSONString and JSON.parseObject are all you need to use in order to meet most of your needs – if not all.

Sie können die in diesem Artikel bereitgestellten Beispiele inlinked GitHub project überprüfen.

TOC

Ein Leitfaden für FastJson