Fastjson 简介与使用指南 – wiki基地

作者： /

Fastjson 简介与使用指南：高性能 JSON 库的深度解析

Fastjson 是一款由阿里巴巴开发的 Java JSON 处理工具包，以其高性能和易用性著称，广泛应用于各种 Java 应用中，尤其是在需要快速序列化和反序列化 JSON 数据的场景。本文将深入探讨 Fastjson 的各个方面，从其背景、特性、使用方法、常见问题，到高级用法和性能优化，力求提供一份详尽的 Fastjson 使用指南。

1. Fastjson 的背景与特性

在 Java 开发中，处理 JSON 数据是常见任务。 传统上，开发者可以使用 JDK 自带的 JSON API，或者选择第三方库，例如 Jackson、Gson、Fastjson 等。 这些库各具特色，在性能、易用性、功能等方面有所差异。

Fastjson 诞生于阿里巴巴内部，最初用于解决大规模 Web 应用中的 JSON 数据处理需求。经过不断优化和完善，它逐渐成为一个开源项目，并迅速获得了广泛的应用。Fastjson 的主要特性包括：

  • 高性能： 这是 Fastjson 最显著的优势。 Fastjson 采用了多种优化策略，例如直接字节码生成、缓存机制等，使其在序列化和反序列化 JSON 数据时具有极快的速度。 相比于其他 JSON 库，Fastjson 通常在性能测试中表现出色。

  • 易用性： Fastjson 提供了简单易用的 API，开发者可以轻松地将 Java 对象转换为 JSON 字符串，或将 JSON 字符串转换为 Java 对象。

  • 完整性： Fastjson 支持完整的 JSON 标准，包括各种数据类型（数字、字符串、布尔值、数组、对象、null 等）和嵌套结构。

  • 功能丰富： 除了基本的序列化和反序列化功能，Fastjson 还提供了许多高级特性，例如自定义序列化器和反序列化器、JSONPath 支持、循环引用处理等。

  • 轻量级： Fastjson 的 JAR 包体积相对较小，便于集成到各种 Java 项目中。

2. Fastjson 的基本使用

首先，需要在项目中引入 Fastjson 的依赖。如果使用 Maven，可以在 pom.xml 文件中添加以下依赖：

xml
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.83</version> <!-- 使用最新版本 -->
</dependency>

2.1 序列化 (Java 对象 -> JSON 字符串)

使用 JSON.toJSONString() 方法可以将 Java 对象序列化为 JSON 字符串。

“`java
import com.alibaba.fastjson.JSON;

public class User {
private int id;
private String name;
private String email;

// 省略构造函数、Getter 和 Setter 方法

public User(int id, String name, String email) {
    this.id = id;
    this.name = name;
    this.email = email;
}

public int getId() {
    return id;
}

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

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public String getEmail() {
    return email;
}

public void setEmail(String email) {
    this.email = email;
}

public static void main(String[] args) {
    User user = new User(1, "John Doe", "[email protected]");
    String jsonString = JSON.toJSONString(user);
    System.out.println(jsonString);  // 输出: {"email":"[email protected]","id":1,"name":"John Doe"}
}

}
“`

2.2 反序列化 (JSON 字符串 -> Java 对象)

使用 JSON.parseObject() 方法可以将 JSON 字符串反序列化为 Java 对象。

“`java
import com.alibaba.fastjson.JSON;

public class User {
private int id;
private String name;
private String email;

// 省略构造函数、Getter 和 Setter 方法

public User(int id, String name, String email) {
    this.id = id;
    this.name = name;
    this.email = email;
}

public int getId() {
    return id;
}

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

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public String getEmail() {
    return email;
}

public void setEmail(String email) {
    this.email = email;
}


public static void main(String[] args) {
    String jsonString = "{\"email\":\"[email protected]\",\"id\":1,\"name\":\"John Doe\"}";
    User user = JSON.parseObject(jsonString, User.class);
    System.out.println(user.getName());  // 输出: John Doe
}

}
“`

2.3 序列化 List 和 Map

Fastjson 同样可以轻松地序列化 List 和 Map 对象。

“`java
import com.alibaba.fastjson.JSON;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class FastJsonListMapExample {

public static void main(String[] args) {
    // 序列化 List
    List<String> names = new ArrayList<>();
    names.add("Alice");
    names.add("Bob");
    names.add("Charlie");

    String jsonListString = JSON.toJSONString(names);
    System.out.println("List JSON: " + jsonListString); // 输出: List JSON: ["Alice","Bob","Charlie"]

    // 序列化 Map
    Map<String, Object> person = new HashMap<>();
    person.put("name", "David");
    person.put("age", 30);
    person.put("city", "New York");

    String jsonMapString = JSON.toJSONString(person);
    System.out.println("Map JSON: " + jsonMapString); // 输出: Map JSON: {"city":"New York","age":30,"name":"David"}
}

}
“`

2.4 反序列化 List 和 Map

可以使用 JSON.parseArray() 和 JSON.parseObject() 方法反序列化 List 和 Map。

“`java
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;

import java.util.List;
import java.util.Map;

public class FastJsonListMapExample {

public static void main(String[] args) {
    // 反序列化 List
    String jsonListString = "[\"Alice\",\"Bob\",\"Charlie\"]";
    List<String> names = JSON.parseArray(jsonListString, String.class);
    System.out.println("List: " + names); // 输出: List: [Alice, Bob, Charlie]

    // 反序列化 Map
    String jsonMapString = "{\"city\":\"New York\",\"age\":30,\"name\":\"David\"}";
    Map<String, Object> person = JSON.parseObject(jsonMapString, new TypeReference<Map<String, Object>>() {}.getType());
    System.out.println("Map: " + person); // 输出: Map: {city=New York, age=30, name=David}
}

}
“`

3. Fastjson 的高级用法

3.1 自定义序列化器和反序列化器

Fastjson 允许开发者自定义序列化器和反序列化器，以满足特定的需求。例如，可以自定义日期格式、处理枚举类型、忽略某些字段等。

“`java
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.JSONSerializer;
import com.alibaba.fastjson.serializer.ObjectSerializer;
import com.alibaba.fastjson.parser.DefaultJSONParser;
import com.alibaba.fastjson.parser.JSONToken;
import com.alibaba.fastjson.parser.deserializer.ObjectDeserializer;

import java.io.IOException;
import java.lang.reflect.Type;
import java.text.SimpleDateFormat;
import java.util.Date;

// 自定义日期序列化器
class CustomDateSerializer implements ObjectSerializer {
private final SimpleDateFormat dateFormat = new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”);

@Override
public void write(JSONSerializer serializer, Object object, Object fieldName, Type fieldType, int features) throws IOException {
    if (object == null) {
        serializer.getWriter().writeNull();
        return;
    }
    Date date = (Date) object;
    String formattedDate = dateFormat.format(date);
    serializer.getWriter().writeString(formattedDate);
}

}

// 自定义日期反序列化器
class CustomDateDeserializer implements ObjectDeserializer {
private final SimpleDateFormat dateFormat = new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”);

@Override
public <T> T deserialze(DefaultJSONParser parser, Type type, Object fieldName) {
    String dateString = parser.lexer().stringVal();
    try {
        return (T) dateFormat.parse(dateString);
    } catch (Exception e) {
        return null;
    }
}

@Override
public int getFastMatchToken() {
    return JSONToken.LITERAL_STRING;
}

}

public class DateExample {
private Date birthDate;

public DateExample(Date birthDate) {
    this.birthDate = birthDate;
}

public Date getBirthDate() {
    return birthDate;
}

public void setBirthDate(Date birthDate) {
    this.birthDate = birthDate;
}

public static void main(String[] args) {
    // 注册自定义序列化器和反序列化器
    com.alibaba.fastjson.serializer.SerializeConfig serializeConfig = new com.alibaba.fastjson.serializer.SerializeConfig();
    serializeConfig.put(Date.class, new CustomDateSerializer());

    com.alibaba.fastjson.parser.ParserConfig parserConfig = new com.alibaba.fastjson.parser.ParserConfig();
    parserConfig.put(Date.class, new CustomDateDeserializer());

    DateExample example = new DateExample(new Date());
    String jsonString = JSON.toJSONString(example, serializeConfig);
    System.out.println("Serialized Date: " + jsonString);

    DateExample deserializedExample = JSON.parseObject(jsonString, DateExample.class, parserConfig);
    System.out.println("Deserialized Date: " + deserializedExample.getBirthDate());
}

}
“`

3.2 JSONPath 支持

Fastjson 提供了 JSONPath 功能，允许开发者使用类似于 XPath 的语法来查询 JSON 数据。

“`java
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.JSONPath;

public class JsonPathExample {
public static void main(String[] args) {
String jsonString = “{\n” +
” \”store\”: {\n” +
” \”book\”: [\n” +
” {\n” +
” \”category\”: \”reference\”,\n” +
” \”author\”: \”Nigel Rees\”,\n” +
” \”title\”: \”Sayings of the Century\”,\n” +
” \”price\”: 8.95\n” +
” },\n” +
” {\n” +
” \”category\”: \”fiction\”,\n” +
” \”author\”: \”Evelyn Waugh\”,\n” +
” \”title\”: \”Sword of Honour\”,\n” +
” \”price\”: 12.99\n” +
” }\n” +
” ],\n” +
” \”bicycle\”: {\n” +
” \”color\”: \”red\”,\n” +
” \”price\”: 19.95\n” +
” }\n” +
” }\n” +
“}”;

    JSONObject jsonObject = JSON.parseObject(jsonString);

    // 获取所有书的作者
    JSONArray authors = (JSONArray) JSONPath.eval(jsonObject, "$.store.book[*].author");
    System.out.println("Authors: " + authors); // 输出: Authors: ["Nigel Rees","Evelyn Waugh"]

    // 获取价格大于 10 的书的标题
    JSONArray titles = (JSONArray) JSONPath.eval(jsonObject, "$.store.book[?(@.price > 10)].title");
    System.out.println("Titles of books with price > 10: " + titles); // 输出: Titles of books with price > 10: ["Sword of Honour"]

    // 获取自行车的颜色
    String color = (String) JSONPath.eval(jsonObject, "$.store.bicycle.color");
    System.out.println("Bicycle color: " + color); // 输出: Bicycle color: red
}

}
“`

3.3 循环引用处理

当 Java 对象中存在循环引用时，Fastjson 默认会抛出异常。 可以通过配置来处理循环引用，避免异常。

“`java
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;

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

class Employee {
private int id;
private String name;
private Department department;

public Employee(int id, String name, Department department) {
    this.id = id;
    this.name = name;
    this.department = department;
}

public int getId() {
    return id;
}

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

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public Department getDepartment() {
    return department;
}

public void setDepartment(Department department) {
    this.department = department;
}

}

class Department {
private int id;
private String name;
private List employees;

public Department(int id, String name) {
    this.id = id;
    this.name = name;
    this.employees = new ArrayList<>();
}

public int getId() {
    return id;
}

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

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public List<Employee> getEmployees() {
    return employees;
}

public void setEmployees(List<Employee> employees) {
    this.employees = employees;
}

}

public class CycleReferenceExample {
public static void main(String[] args) {
Department department = new Department(1, “IT”);
Employee employee1 = new Employee(101, “Alice”, department);
Employee employee2 = new Employee(102, “Bob”, department);

    department.getEmployees().add(employee1);
    department.getEmployees().add(employee2);

    // 设置循环引用：员工关联部门，部门又关联员工
    // 为了演示，避免栈溢出，这里不设置部门的employees到 employee对象的循环引用

    // 处理循环引用
    String jsonString = JSON.toJSONString(department, SerializerFeature.DisableCircularReferenceDetect);
    System.out.println(jsonString);
}

}
“`

4. Fastjson 的性能优化

虽然 Fastjson 已经具有很高的性能，但仍然可以通过一些技巧来进一步优化其性能：

  • 使用 SerializerFeature 进行配置： SerializerFeature 提供了许多选项，可以控制序列化的行为。例如，可以启用 DisableCircularReferenceDetect 来关闭循环引用检测，启用 WriteClassName 来输出类名，启用 SortField 来对字段进行排序等。根据实际需求选择合适的 SerializerFeature 可以提高性能。

  • 缓存 JSON.parseObject() 和 JSON.toJSONString() 方法的结果： 对于频繁使用的 JSON 数据，可以将其缓存起来，避免重复的序列化和反序列化操作。

  • 避免使用反射： 反射是 Java 中一种动态获取类信息的方式，但其性能相对较低。 Fastjson 默认会使用反射来序列化和反序列化对象。 如果性能要求较高，可以考虑使用自定义序列化器和反序列化器，避免使用反射。

  • 使用合适的版本： Fastjson 的不同版本在性能上可能存在差异。 建议使用最新版本的 Fastjson，通常会包含性能优化。

  • 选择合适的序列化/反序列化方法： Fastjson提供了多个序列化和反序列化方法，例如toJSONString()、 toJSONBytes()、parseObject()、 parse() 等。 根据实际需求选择最合适的方法，可以提高性能。 例如，如果需要将 Java 对象序列化为字节数组，可以使用 toJSONBytes() 方法，避免将 JSON 字符串转换为字节数组的额外开销。

5. Fastjson 的安全性问题

Fastjson 在早期版本中曾出现过一些安全性问题，例如远程代码执行漏洞。 这些漏洞通常是由于 Fastjson 在反序列化过程中，允许用户自定义类名，导致恶意类被加载和执行。

为了避免这些安全性问题，建议采取以下措施：

  • 使用最新版本的 Fastjson： 最新版本的 Fastjson 通常会修复已知的安全漏洞。

  • 不要信任来自不可信来源的 JSON 数据： 尽量避免反序列化来自不可信来源的 JSON 数据。

  • 启用 safeMode： Fastjson 提供了一个 safeMode 选项，可以禁用一些危险的功能，例如自动类型转换。

  • 使用 deny 和 allow 列表： 可以配置 deny 和 allow 列表，限制可以被反序列化的类。

6. 总结

Fastjson 是一款高性能、易用的 Java JSON 处理工具包。 通过本文的介绍，相信你已经对 Fastjson 的背景、特性、使用方法、高级用法、性能优化和安全性问题有了深入的了解。 在实际开发中，可以根据具体的需求选择合适的 Fastjson 功能，并采取必要的安全措施，以确保应用的性能和安全。 随着 Java 生态的不断发展，JSON 处理工具也在不断进步。 开发者应持续关注相关技术的发展动态，以便选择最适合自己的工具。

发表评论

您的邮箱地址不会被公开。 必填项已用 * 标注

滚动至顶部