Fastjson Introduction

Fastjson is a Java library that can convert Java objects into JSON format, and of course it can also convert JSON strings into Java objects.

Fastjson can operate on any Java object, even pre-existing objects without source code.

Fastjson source code address:https://github.com/alibaba/fastjson

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

Fastjson Features

• Provides parsing tools for both server-side and Android clients, with good performance.
• Provides toJSONString() and parseObject() methods to convert between Java objects and JSON. Calling the toJSONString method converts an object into a JSON string, while the parseObject method does the reverse, converting a JSON string into an object.
• Allows conversion of pre-existing immutable objects (only class, no source code).
• Extensive support for Java generics.
• Allows custom representation of objects and custom serialization classes.
• Supports arbitrarily complex objects (with deep inheritance hierarchies and extensive use of generic types).

Download and Usage

You can download it directly from the Maven Central Repository:

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

Or configure the Maven dependency:

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

wherex.x.xis the version number. Use a specific version as needed, and the latest version is recommended.

Convert Java Objects to JSON Format

Define the following Person JavaBean:

You can use JSON.toJSONString() to convert a Java object into a JSON object:

The output is:

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

We can also customize the output and control field ordering, date display format, serialization flags, etc.

Next, let's update the bean and add a few fields:

In the above code, we listed the basic parameter categories and used the @JSONField annotation to implement custom conversion:

• format The parameter is used to formatdatethe property.
• By default, the FastJson library can serialize Java bean entities, but we can useserialize to specify fields not to be serialized.
• Useordinal the parameter to specify the order of fields.

Thus, the output above becomes:

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

The target objects of @JSONField:

• 1. Field
• 2. Setter and Getter methods

Note:When FastJson performs operations, it does so based on getter and setter methods, not based on fields.

Note:If a property is private, it must have a set method; otherwise, deserialization is impossible.

2. JSONField Configuration Methods

FieldInfo can be configured on getter/setter methods or fields. For example:

2.1 Configured on getter/setter

2.2 Configured on field

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

3. Using format to Configure Date Formatting

4. Using serialize/deserialize to Specify Non-Serialization of Fields

5. Using ordinal to Specify Field Order

By default, fastjson serializes a Java bean based on the alphabetical order of fieldName. You can specify the field order with ordinal. This feature requires version 1.1.42 or higher.

FastJson also supports BeanToArray serialization:

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

The output is:

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

Creating JSON Objects

Creating JSON objects is very simple. Just use JSONObject (the JSON object provided by fastJson) and JSONArray (the JSON array object provided by fastJson).

We can treat JSONObject as a Map<String,Object>, except that JSONObject provides richer and more convenient methods for manipulating object properties. Let's take a look at the source code.

Similarly, we can treat JSONArray as a List<Object>, and can regard JSONArray as a collection of JSONObject objects.

In addition, since JSONObject and JSONArray inherit from JSON, both can also be used directly to convert between JSON format strings and JSON objects or JavaBeans. However, to avoid confusion, we still use JSON.

The output is:

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

Converting JSON Strings to Java Objects

Now that we have learned how to create JSON objects and convert Java objects to JSON strings, we need to understand how to parse JSON:

We can use JSON.parseObject() to convert JSON strings into Java objects.

Note: when deserializing into an object, a default no-argument constructor must be present; otherwise, an exception will be thrown:

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

The following is a simple example test:

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

@JSONField deserializeOptional parameters can specify fields not to be deserialized.

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

The output is:

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

Using ContextValueFilter to Configure JSON Conversion

In some scenarios, when filtering values, you need to obtain information about the owning JavaBean, including its type, fields, methods, etc. In fastjson-1.2.9, ContextValueFilter is provided, similar to the ValueFilter provided in previous versions, but with an additional BeanContext parameter available.

In the above example, we hid the DATE OF BIRTH field and filtered out fields whose names do not contain John:

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

Using NameFilter and SerializeConfig

NameFilter: Modify the Key during serialization.

SerializeConfig: Internally it is a map container whose main function is to configure and record the serialization class corresponding to each Java type.

In the example, we declared the formatName filter using the NameFilter anonymous class to handle field names. The newly created filter is associated with the Person class, then added to the global instance, which is a static property in the SerializeConfig class.

Now we can easily convert objects to JSON format.

Note that we use toJSONStringWithDateFormat() instead of toJSONString(), which can format dates more quickly.

Output result:

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