Fastjson-Kurzanleitung

Fastjson-Einführung

Fastjson ist eine Java-Bibliothek, die Java-Objekte in das JSON-Format konvertieren kann und natürlich auch JSON-Zeichenfolgen in Java-Objekte umwandeln kann.

Fastjson kann mit jedem Java-Objekt arbeiten, sogar mit bereits vorhandenen Objekten ohne Quellcode.

Fastjson-Quellcode-Adresse:https://github.com/alibaba/fastjson

Fastjson chinesisches Wiki:https://github.com/alibaba/fastjson/wiki/Quick-Start-CN

Fastjson-Funktionen

Bietet Parsing-Werkzeuge sowohl für serverseitige als auch für Android-Clients mit guter Leistung.
Bietet die Methoden toJSONString() und parseObject(), um zwischen Java-Objekten und JSON zu konvertieren. Der Aufruf der Methode toJSONString konvertiert ein Objekt in einen JSON-String, während die Methode parseObject das Gegenteil bewirkt und einen JSON-String in ein Objekt konvertiert.
Ermöglicht die Konvertierung bereits vorhandener unveränderlicher Objekte (nur Klasse, kein Quellcode).
Umfassende Unterstützung für Java-Generics.
Ermöglicht eine benutzerdefinierte Darstellung von Objekten und benutzerdefinierte Serialisierungsklassen.
Unterstützt beliebig komplexe Objekte (mit tiefen Vererbungshierarchien und umfangreicher Verwendung generischer Typen).

Download und Verwendung

Sie können es direkt aus dem Maven Central Repository herunterladen:

https://repo1.maven.org/maven2/com/alibaba/fastjson/

Oder konfigurieren Sie die Maven-Abhängigkeit:

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>x.x.x</version>
</dependency>

wobeix.x.xdie Versionsnummer ist. Verwenden Sie nach Bedarf eine bestimmte Version, und die neueste Version wird empfohlen.

Java-Objekte in das JSON-Format konvertieren

Definieren Sie die folgende Person-JavaBean:

Beispiel

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-Getter und -Setter
}

Sie können JSON.toJSONString() verwenden, um ein Java-Objekt in ein JSON-Objekt umzuwandeln:

private List<Person> listOfPersons = new ArrayList<Person>();

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

Die Ausgabe ist:

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

Wir können auch die Ausgabe anpassen und die Feldreihenfolge, das Datumsanzeigeformat, Serialisierungs-Flags usw. steuern.

Als Nächstes aktualisieren wir das Bean und fügen ein paar Felder hinzu:

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

Im obigen Code haben wir die grundlegenden Parameterkategorien aufgeführt und die @JSONField-Annotation verwendet, um eine benutzerdefinierte Konvertierung zu implementieren:

format Der Parameter wird verwendet, um diedate-Eigenschaft zu formatieren.
Standardmäßig kann die FastJson-Bibliothek Java-Bean-Entitäten serialisieren, aber wir könnenserialize verwenden, um Felder anzugeben, die nicht serialisiert werden sollen.
Verwenden Sieordinal den Parameter, um die Reihenfolge der Felder anzugeben.

Somit wird die obige Ausgabe zu:

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

@JSONField

Die Zielobjekte von @JSONField:

1. Feld
2. Setter- und Getter-Methoden

Hinweis:Wenn FastJson Operationen ausführt, geschieht dies auf Basis von Getter- und Setter-Methoden, nicht auf Basis von Feldern.

Hinweis:Wenn eine Eigenschaft privat ist, muss sie eine Set-Methode haben; andernfalls ist eine Deserialisierung unmöglich.

span style="color: #000000; font-weight: bold;">package com.alibaba.fastjson.annotation;

public @interface JSONField {
// Konfiguriert die Reihenfolge von Serialisierung und Deserialisierung; wird erst ab Version 1.1.42 unterstützt
int ordinal() default 0;

// Gibt den Namen des Felds an
String name() default "";

// Gibt das Format des Felds an; nützlich für Datumsformate
String format() default "";

// Ob serialisiert werden soll
boolean serialize() default true;

// Ob deserialisiert werden soll
boolean deserialize() default true;
}

2. JSONField-Konfigurationsmethoden

FieldInfo kann an Getter-/Setter-Methoden oder Feldern konfiguriert werden. Zum Beispiel:

2.1 An Getter/Setter konfiguriert

public class A {
private int id;

@JSONField(name="ID")
public int getId() {return id;}
@JSONField(name="ID")
public void setId(int value) {this.id = id;}
}

2.2 Am Feld konfiguriert

public class A {
@JSONField(name="ID")
private int id;

public int getId() {return id;}
public void setId(int value) {this.id = id;}
}

3. Verwenden von format zum Konfigurieren der Datumsformatierung

span style="color: #000000; font-weight: bold;">public class A {
// Konfigurieren der Datumsserialisierung und -deserialisierung zur Verwendung des Datumsformats yyyyMMdd
@JSONField(format="yyyyMMdd")
public Date date;
}

4. Verwenden von serialize/deserialize zur Angabe der Nicht-Serialisierung von Feldern

span style="color: #000000; font-weight: bold;">public class A {
@JSONField(serialize=false)
public Date date;
}

public class A {
@JSONField(deserialize=false)
public Date date;
}

5. Verwenden von ordinal zur Angabe der Feldreihenfolge

Standardmäßig serialisiert fastjson ein Java-Bean basierend auf der alphabetischen Reihenfolge des fieldName. Sie können die Feldreihenfolge mit ordinal angeben. Diese Funktion erfordert Version 1.1.42 oder höher.

span style="color: #000000; font-weight: bold;">public static class VO {
@JSONField(ordinal = 3)
private int f0;

@JSONField(ordinal = 2)
private int f1;

@JSONField(ordinal = 1)
private int f2;
}

FastJson unterstützt auch die BeanToArray-Serialisierung:

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

Die Ausgabe ist:

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

Erstellen von JSON-Objekten

Das Erstellen von JSON-Objekten ist sehr einfach. Verwenden Sie einfach JSONObject (das von fastJson bereitgestellte JSON-Objekt) und JSONArray (das von fastJson bereitgestellte JSON-Array-Objekt).

Wir können JSONObject als Map<String,Object> behandeln, mit der Ausnahme, dass JSONObject umfangreichere und bequemere Methoden zum Bearbeiten von Objekteigenschaften bietet. Schauen wir uns den Quellcode an.

Ähnlich können wir JSONArray als List<Object> behandeln und JSONArray als eine Sammlung von JSONObject-Objekten betrachten.

Darüber hinaus, da JSONObject und JSONArray von JSON erben, können beide auch direkt verwendet werden, um zwischen JSON-Format-Strings und JSON-Objekten oder JavaBeans zu konvertieren. Um Verwirrung zu vermeiden, verwenden wir jedoch weiterhin JSON.

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

Die Ausgabe ist:

[
   {
      "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"
   }
]

Konvertieren von JSON-Strings in Java-Objekte

Nachdem wir gelernt haben, wie man JSON-Objekte erstellt und Java-Objekte in JSON-Strings umwandelt, müssen wir verstehen, wie man JSON parst:

@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); // Wenn wir die Serialisierung auf false setzen
assertEquals(newPerson.getFullName(), listOfPersons.get(0).getFullName());
}

Wir können JSON.parseObject() verwenden, um JSON-Strings in Java-Objekte umzuwandeln.

Hinweis: Beim Deserialisieren in ein Objekt muss ein standardmäßiger Konstruktor ohne Argumente vorhanden sein; andernfalls wird eine Ausnahme ausgelöst:

com.alibaba.fastjson.JSONException: default constructor not found.

Das Folgende ist ein einfaches Beispiel für einen Test:

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

@JSONField deserializeOptionale Parameter können Felder angeben, die nicht deserialisiert werden sollen.

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

Die Ausgabe ist:

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

ContextValueFilter zum Konfigurieren der JSON-Konvertierung verwenden

In manchen Szenarien müssen Sie beim Filtern von Werten Informationen über das besitzende JavaBean abrufen, einschließlich seines Typs, seiner Felder, Methoden usw. In fastjson-1.2.9 wird ContextValueFilter bereitgestellt, ähnlich dem in früheren Versionen bereitgestellten ValueFilter, jedoch mit einem zusätzlichen verfügbaren BeanContext-Parameter.

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

Im obigen Beispiel haben wir das Feld DATE OF BIRTH ausgeblendet und Felder herausgefiltert, deren Namen John nicht enthalten:

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

Verwendung von NameFilter und SerializeConfig

NameFilter: Den Schlüssel während der Serialisierung ändern.

SerializeConfig: Intern ist es ein Map-Container, dessen Hauptfunktion darin besteht, die jedem Java-Typ entsprechende Serialisierungsklasse zu konfigurieren und aufzuzeichnen.

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

Im Beispiel haben wir den Filter formatName mithilfe der anonymen Klasse NameFilter deklariert, um Feldnamen zu verarbeiten. Der neu erstellte Filter wird der Klasse Person zugeordnet und dann der globalen Instanz hinzugefügt, die eine statische Eigenschaft in der Klasse SerializeConfig ist.

Jetzt können wir Objekte einfach in das JSON-Format konvertieren.

Beachten Sie, dass wir toJSONStringWithDateFormat() anstelle von toJSONString() verwenden, wodurch Datumsangaben schneller formatiert werden können.

Ausgabeergebnis:

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