掌握JSON处理：json-lib库的使用与实践

本文还有配套的精品资源，点击获取

简介：JSON是一种广泛应用于Web应用的数据交换格式， json-lib 库提供了丰富的API来实现Java对象与JSON格式的转换。它支持多种数据类型转换，兼容Java SE和Java EE环境，并且有多个版本以适配不同的Java运行时环境。开发者可以根据项目需求选择合适的 json-lib 版本，并通过其提供的方法实现高效的序列化与反序列化。同时，开发者应关注性能，必要时与其他JSON库进行对比测试。本指南将介绍如何引入 json-lib 依赖、进行对象与JSON之间的转换，以及进行JSON数据操作和自定义序列化的技巧。

1. JSON数据格式介绍

在本章节中，我们将首先了解JSON（JavaScript Object Notation）的基本概念，它是一种轻量级的数据交换格式，易于人阅读和编写，同时也易于机器解析和生成。随后，我们将探讨JSON的结构，包括对象、数组、字符串、数字、布尔值和null等数据类型，以及它们如何在实际应用中被组织和传输。本章还将简要介绍JSON的使用场景和它在Web服务中的流行度，为进一步深入学习json-lib库打下坚实基础。

{
  "name": "JSON",
  "type": "Data Format",
  "origin": "JavaScript"
}

1.1 JSON基本概念

JSON最初是由Douglas Crockford提出的，它基于JavaScript的一个子集，但JSON是一个完全独立的语言无关的数据格式。它的主要特点包括：

• 易于阅读和编写 ：JSON的语法简洁明了，人类很容易理解。
• 易于机器解析 ：JSON的结构简单，计算机程序可以很轻松地解析和生成JSON格式的数据。
• 轻量级 ：由于其简单性，JSON比XML等数据交换格式占用更少的带宽。

1.2 JSON数据类型和结构

JSON支持的数据类型包括：

• 对象 ：一组键值对的无序集合，例如 {"name": "John", "age": 30}
• 数组 ：有序元素的集合，例如 ["apple", "banana"]
• 字符串 ：文本数据，使用双引号括起来，例如 "Hello World!"
• 数字 ：例如 123 或 3.14159
• 布尔值 ： true 或 false
• null ：表示空值

JSON数据结构通常表现为嵌套的对象和数组，使得数据层次清晰，非常适合描述复杂的数据结构。

2. json-lib库功能与特点

2.1 json-lib库的基本概念

2.1.1 json-lib库的起源和发展

json-lib库是早期为了简化Java中JSON数据格式处理而开发的一个库。其灵感来源于JavaScript中的JSON对象以及PHP中的json_encode和json_decode函数。自2006年发布以来，json-lib一直是处理JSON数据的一个流行选择，尤其在处理复杂的数据结构时，由于其直接通过反射机制将Java对象转换成JSON格式，因此受到了许多开发者的青睐。

json-lib通过其独特的API，使得开发者可以轻松地在Java对象和JSON字符串之间进行转换。随着时间的推移，json-lib经历了多次迭代和改进，引入了对XML格式的支持，增强了对复杂数据类型的处理能力，例如支持日期类型和自定义类的序列化与反序列化。

2.1.2 json-lib库与其他库的比较

json-lib库的诞生与当时流行的XML作为数据交换格式的时代背景紧密相关，而随后JSON的崛起，使得诸如Jackson、Gson等库的出现，提供了更为轻量、高效和灵活的JSON处理能力。与这些现代库相比，json-lib在性能和易用性上可能略显逊色，尤其是在处理大型数据集或需要高度定制化的序列化与反序列化策略时。

然而，json-lib也有一些独特之处，比如其对XML格式的支持，这在其他一些只专注于JSON的库中是不具备的。虽然如此，由于其较早的开发起点和未跟上最新Java版本的更新，json-lib现在主要被仍在维护老系统或因特定需求而必须使用的老项目所使用。

2.2 json-lib库的核心功能

2.2.1 json-lib库对JSON格式的支持

json-lib库的核心功能之一是对JSON格式的支持。json-lib提供了丰富的API，使得开发者能够直接在Java对象和JSON字符串之间进行相互转换。这种转换过程是通过反射实现的，开发者可以简单地调用相应的API方法，而无需手动构造JSON字符串。

在实现转换时，json-lib会自动处理Java对象中的属性，包括基本数据类型、对象属性以及数组、列表等集合类型。它还能够处理复杂的对象图，例如嵌套对象和对象间的循环引用。

2.2.2 json-lib库对XML格式的支持

除了支持JSON格式，json-lib还提供了对XML格式的支持。它允许开发者将Java对象转换成XML字符串，也可以将XML字符串解析回Java对象。这一特性对于那些需要同时与JSON和XML数据格式打交道的应用来说非常有用。

通过使用json-lib，开发者可以利用同一套API来处理JSON和XML数据，这简化了代码的复杂度，使得数据处理逻辑更加清晰。不过需要注意的是，虽然json-lib提供了对XML的支持，但其功能和性能可能不如专门处理XML的库，如JAXB或XStream。

2.2.3 json-lib库对各种数据类型的转换

json-lib不仅能够处理标准的Java数据类型，还能够处理一些特定的数据类型。例如，它提供了对日期对象的支持，允许开发者直接在JSON字符串中保留日期信息。此外，json-lib还能够处理Map、Properties以及Calendar等特殊数据类型的转换。

json-lib在处理复杂数据类型时，例如自定义对象，它会使用反射机制来遍历对象的属性，并进行相应的序列化或反序列化。它还支持将对象中的null值进行过滤，避免在JSON字符串中生成不必要的null字段。

import net.sf.json.JSONObject;

// 示例：将一个包含特殊数据类型的Java对象转换为JSON字符串
public class SpecialTypesExample {
    public static void main(String[] args) {
        SpecialObject specialObj = new SpecialObject();
        specialObj.setString("Hello JSON-lib");
        specialObj.setDate(new Date());

        JSONObject jsonObject = JSONObject.fromObject(specialObj);
        System.out.println(jsonObject.toString());
    }
}

class SpecialObject {
    private String string;
    private Date date;

    // Getters and Setters...
}

在上述代码示例中，我们创建了一个包含字符串和日期的 SpecialObject 对象，并使用 JSONObject.fromObject() 方法将其转换为JSON对象。json-lib自动处理了日期类型的转换，使其在JSON字符串中以 "yyyy-MM-dd HH:mm:ss" 格式展现。

json-lib的这种灵活性和对不同数据类型的广泛支持，使其成为处理JSON数据的一个非常有用的库，尤其是在那些数据类型较为复杂的应用场景中。

通过本章节的介绍，我们深入了解了json-lib库的基本概念、起源和发展以及与其他库的比较，并重点探讨了其核心功能，包括对JSON和XML格式的支持，以及如何处理各种数据类型的转换。在下一章中，我们将探索json-lib在Java环境下的应用，包括在Java SE和Java EE环境中的配置、使用以及性能测试。

3. Java环境下的json-lib应用

3.1 Java SE环境下的json-lib应用

3.1.1 Java SE环境的json-lib配置和使用

在Java SE环境中，json-lib库能够提供强大的JSON处理能力。首先，需要将json-lib库添加到项目的类路径中。如果使用Maven进行项目管理，可以在 pom.xml 文件中添加以下依赖：

<dependency>
    <groupId>net.sf.json-lib</groupId>
    <artifactId>json-lib</artifactId>
    <version>2.4</version>
</dependency>

对于非Maven项目，需下载json-lib的jar文件，并手动添加到项目的 /lib 目录下。

一旦完成配置，便可以开始在Java SE环境中使用json-lib库。以下是一个简单的示例，展示了如何使用json-lib将Java对象序列化为JSON字符串：

import net.sf.json.JSONObject;

public class JsonLibExample {
    public static void main(String[] args) {
        JSONObject json = new JSONObject();
        json.put("name", "John Doe");
        json.put("age", 30);
        json.put("email", "john.***");

        System.out.println(json.toString());
    }
}

以上代码创建了一个 JSONObject 实例，并添加了三个键值对。调用 toString() 方法后，会得到一个格式化的JSON字符串。

3.1.2 Java SE环境的json-lib性能测试

json-lib库在Java SE环境下的性能测试通常涉及序列化和反序列化的操作。进行性能测试的目的是评估在处理大量数据时json-lib的效率和响应时间。

在Java SE环境下，可以使用JMeter或自定义的测试脚本来模拟实际应用场景，通过比较不同操作所消耗的时间来评估性能。以下是一个使用Java自带的 System.nanoTime() 方法进行性能测试的示例代码：

import net.sf.json.JSONObject;
import java.util.HashMap;
import java.util.Map;

public class JsonLibPerformanceTest {
    public static void main(String[] args) {
        int iterations = 10000;
        long startTime, endTime;
        Map<String, Object> map = new HashMap<>();

        for (int i = 0; i < iterations; i++) {
            map.put("name", "John Doe " + i);
            map.put("age", 30 + i);
            map.put("email", "john.doe" + i + "@***");
        }

        startTime = System.nanoTime();
        for (int i = 0; i < iterations; i++) {
            JSONObject json = JSONObject.fromObject(map);
            json.toString();
        }
        endTime = System.nanoTime();

        System.out.println("Total time for JSON serialization: " + (endTime - startTime) / 1000000 + " ms");
    }
}

测试结果会显示整个序列化过程的总耗时，从而可以评估json-lib在实际应用中的表现。

3.2 Java EE环境下的json-lib应用

3.2.1 Java EE环境的json-lib配置和使用

Java EE环境提供了一个更加丰富的运行时环境，可以将json-lib应用于Web应用中。和Java SE环境类似，json-lib的依赖需要添加到项目的类路径中。不过，在Java EE环境中，通常使用构建工具如Maven或Gradle来管理依赖。

一个典型的json-lib配置在Java EE项目中的方式如下，以Maven为例：

<dependency>
    <groupId>net.sf.json-lib</groupId>
    <artifactId>json-lib</artifactId>
    <version>2.4</version>
</dependency>

下面示例展示了在Java EE环境中如何将一个简单的Java对象转换为JSON格式的字符串：

import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class JsonLibServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response) {
        response.setContentType("text/html;charset=UTF-8");
        JSONArray array = new JSONArray();
        for (int i = 0; i < 10; i++) {
            JSONObject json = new JSONObject();
            json.put("index", i);
            json.put("value", "value " + i);
            array.put(json);
        }

        String jsonResponse = array.toString();
        response.getWriter().write(jsonResponse);
    }
}

这个Servlet会响应HTTP GET请求，生成一个包含10个JSON对象的 JSONArray ，并输出为JSON字符串。

3.2.2 Java EE环境的json-lib性能测试

在Java EE环境中，性能测试通常涉及到Web应用的整体响应时间，包括处理客户端请求、执行业务逻辑以及序列化和反序列化的开销。性能测试可以在Web服务器上运行，比如Tomcat, Jetty, Glassfish等。

为了测试json-lib的性能，可以使用Apache JMeter这样的工具来模拟高并发请求。首先，需要设置JMeter测试计划来模拟用户发起的请求。然后，可以运行测试并分析结果，关注响应时间、吞吐量等性能指标。

在实际测试中，可能会出现多种场景的测试结果。例如，当序列化的对象包含大量字段时，json-lib可能无法达到最优性能。针对这种情况，可以考虑对数据进行分批处理，或者更换不同的JSON库来优化性能。

3.3 json-lib版本选择与依赖管理

3.3.1 json-lib的版本选择

在选择json-lib的版本时，需要考虑库的成熟度、社区活跃度和与当前Java版本的兼容性。考虑到json-lib相对较为老旧，建议选择一个稳定的版本，以避免潜在的兼容性问题。截止到知识截止点，版本 2.4 是json-lib的一个相对稳定的版本。

选择版本时，可以通过查阅Maven中央仓库的json-lib库页面，了解各个版本的发布日期和特性变更。此外，对于Java 9及以上版本的项目，要确保所选json-lib版本与Java的模块化兼容，或者使用适当的JVM参数来兼容。

3.3.2 json-lib的依赖管理

在依赖管理方面，使用Maven或Gradle等构建工具可以方便地管理json-lib及其依赖。对于Maven项目，建议在 pom.xml 文件中管理版本，以确保项目中所有模块使用相同的库版本。以下是一个典型的json-lib依赖管理配置：

<dependency>
    <groupId>net.sf.json-lib</groupId>
    <artifactId>json-lib</artifactId>
    <version>2.4</version>
</dependency>

对于Gradle项目，可以在 build.gradle 文件中添加如下依赖：

dependencies {
    implementation 'net.sf.json-lib:json-lib:2.4'
}

通过集中管理依赖，当需要升级或更换json-lib版本时，只需更改 pom.xml 或 build.gradle 文件中的版本号，并重新构建项目即可。

正确管理json-lib的版本和依赖，不仅可以保证应用的稳定性，还可以帮助维护者更轻松地管理项目依赖。

4. json-lib与Java对象的转换

4.1 Java对象与JSON之间的转换方法

4.1.1 Java对象转JSON的方法

在进行Java对象与JSON数据之间的转换时，json-lib库提供了一套简单而强大的API来实现这一功能。我们可以创建一个 JSONArray 或 JSONObject 对象，并使用它们提供的方法将Java对象的属性映射为JSON格式的字符串。

以下是一个简单的例子，演示如何使用json-lib库将一个Java对象转换为JSON字符串：

import org.json.JSONArray;
import org.json.JSONObject;
import net.sf.json.JSONObject;
import net.sf.json.JsonConfig;

public class JavaToJsonExample {
    public static void main(String[] args) {
        // 创建一个Java对象
        Person person = new Person("张三", 25);

        // 设置json-lib的配置，定义Java对象到JSON的映射规则
        JsonConfig jsonConfig = new JsonConfig();
        jsonConfig.setClassMapping(Person.class, JSONObject.class);

        // 将Java对象转换为JSON对象
        JSONObject jsonObject = JSONObject.fromObject(person, jsonConfig);

        // 输出JSON字符串
        String jsonString = jsonObject.toString();
        System.out.println(jsonString);
    }
}

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // getters and setters
}

执行上述代码后，我们可以得到一个JSON格式的字符串，类似于：

{"age":25,"name":"张三"}

在上面的代码中，我们使用 JSONObject.fromObject 方法，结合 JsonConfig 对象，实现了从Java对象到JSON对象的转换。 JsonConfig 用于定义映射规则，这里我们将 Person 类映射为 JSONObject 类。通过调用 toString() 方法，我们可以将 JSONObject 对象转换成JSON格式的字符串。

4.1.2 JSON转Java对象的方法

相对地，json-lib库也支持将JSON字符串解析成Java对象。这通常用于从网络请求中接收到JSON数据时，将这些数据转换为Java对象以便于处理。以下是一个将JSON字符串转换为Java对象的示例：

import org.json.JSONObject;
import net.sf.json.JSONObject;
import net.sf.json.JsonConfig;
import net.sf.json.util.JSONUtils;

public class JsonToJavaExample {
    public static void main(String[] args) {
        // 创建一个JSON字符串
        String jsonString = "{\"age\":25,\"name\":\"张三\"}";

        // 将JSON字符串转换为JSON对象
        JSONObject jsonObject = JSONObject.fromObject(jsonString);

        // 设置json-lib的配置，定义JSON到Java对象的映射规则
        JsonConfig jsonConfig = new JsonConfig();
        jsonConfig.setClassMappings(new Class[] {JSONObject.class}, new Class[] {Person.class});

        // 将JSON对象转换为Java对象
        Person person = (Person) JSONObject.toBean(jsonObject, Person.class, jsonConfig);

        // 输出Java对象信息
        System.out.println("姓名: " + person.getName() + ", 年龄: " + person.getAge());
    }
}

class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

在这个例子中，我们首先使用 JSONObject.fromObject 方法将JSON格式的字符串转换为一个 JSONObject 对象。然后，我们使用 JsonConfig 类定义了JSON到Java类的映射规则，并通过 JSONObject.toBean 方法将 JSONObject 对象转换为Java对象。

4.2 json-lib的JSON操作API使用

4.2.1 json-lib的JSON解析API使用

json-lib库提供了丰富的API来解析JSON数据。除了上文提到的将JSON字符串转换为Java对象的方法外，json-lib还支持对JSON数据的直接操作。这里我们将介绍如何利用json-lib库提供的API来操作JSON数据。

读取JSON数据

使用json-lib，我们可以轻松地访问和解析JSON对象中的数据：

JSONObject jsonObject = new JSONObject("{\"name\":\"张三\",\"age\":25}");
String name = jsonObject.getString("name");
int age = jsonObject.getInt("age");

在上面的例子中，我们创建了一个 JSONObject 实例，并用一个JSON字符串初始化它。然后我们可以使用 getString 和 getInt 方法来获取相应的属性值。

访问JSON数组

如果JSON数据是一个数组，我们可以使用 JSONArray 类来处理：

JSONArray jsonArray = new JSONArray("[{\"name\":\"张三\",\"age\":25},{\"name\":\"李四\",\"age\":24}]");

for(int i = 0; i < jsonArray.size(); i++) {
    JSONObject person = jsonArray.getJSONObject(i);
    String name = person.getString("name");
    int age = person.getInt("age");
    // 处理每个人的信息...
}

在上述代码中，我们创建了一个 JSONArray 实例，并用一个包含多个对象的JSON数组字符串来初始化它。我们可以通过循环遍历数组，并使用与操作单个 JSONObject 相同的方法来读取每个对象的属性。

4.2.2 json-lib的JSON生成API使用

除了解析JSON数据，json-lib库还提供了创建和修改JSON数据的API。我们可以使用这些API构建新的JSON对象和数组，或者对现有的JSON数据进行修改。

创建JSON对象

我们可以使用 JSONObject 类创建一个新的JSON对象：

JSONObject jsonObject = new JSONObject();
jsonObject.put("name", "王五");
jsonObject.put("age", 30);

System.out.println(jsonObject.toString());

在上面的代码片段中，我们创建了一个新的 JSONObject 实例，并使用 put 方法添加了两个键值对。调用 toString 方法后，我们可以得到一个表示这些键值对的JSON字符串。

创建JSON数组

创建JSON数组的过程类似于创建JSON对象。使用 JSONArray 类，我们可以添加多个JSON对象到一个数组中：

JSONArray jsonArray = new JSONArray();
jsonArray.put(new JSONObject().put("name", "赵六").put("age", 35));
jsonArray.put(new JSONObject().put("name", "钱七").put("age", 40));

System.out.println(jsonArray.toString());

这段代码创建了一个 JSONArray 实例，并向其中添加了两个 JSONObject 对象。每个对象代表一个具有姓名和年龄的简单记录。调用 toString 方法后，我们可以得到一个JSON数组的字符串表示。

通过这些API，我们可以灵活地构建复杂的JSON数据结构，满足不同应用场景的需求。json-lib库的灵活性和强大的功能使其成为了处理JSON数据的强大工具。

表格：json-lib支持的JSON操作API列表

| 操作类型 | 方法名 | 描述 | | -------------- | ----------------------------------------- | ------------------------------------------------------------ | | JSON字符串解析 | JSONObject.fromObject(String json) | 将JSON字符串转换为JSONObject实例。 | | JSON对象创建 | JSONObject() | 创建一个空的JSONObject实例。 | | JSON数组创建 | JSONArray() | 创建一个空的JSONArray实例。 | | JSON字符串生成 | JSONObject.toString() | 将JSONObject实例转换为JSON字符串。 | | JSON数组获取 | JSONArray.getJSONObject(int index) | 根据索引获取JSONArray中的JSONObject实例。 | | 键值对添加 | JSONObject.put(String key, Object value) | 将键值对添加到JSONObject实例中。 | | 集合转换 | JSONObject.toBean(JSONObject, Class) | 将JSONObject实例转换为Java对象，需要指定对象类型和配置信息。 |

mermaid流程图：Java对象与JSON之间的转换流程

graph LR
A[Java对象] -->|转换为| B[JSONObject]
B -->|转换为| C[JSON字符串]
C -->|解析为| D[JSONObject]
D -->|转换为| A[Java对象]

通过上述的讨论，我们可以了解到json-lib库提供了丰富的方法来完成Java对象和JSON数据之间的互相转换。这使得开发者能够在Java应用程序中更加灵活和方便地处理JSON数据。

5. json-lib的高级应用与性能考量

5.1 自定义Java类的序列化与反序列化

在处理复杂数据结构时，json-lib库允许用户自定义Java类的序列化与反序列化方法，以便更灵活地控制数据转换。

5.1.1 自定义Java类的序列化方法

序列化是将Java对象转换成JSON字符串的过程。使用json-lib库，可以通过实现 JSONSerializer 接口来自定义序列化行为。

import org.json.JSONSerializer;
import java.io.StringWriter;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;

public class CustomSerializer implements JSONSerializer {
    @Override
    public String serialize(Object obj) throws InvocationTargetException, IllegalAccessException {
        StringWriter writer = new StringWriter();
        Map map = (Map) obj;
        for (Object key : map.keySet()) {
            String strKey = (String) key;
            Object strValue = map.get(key);
            writer.write("\"" + strKey + "\":");
            // 使用自定义逻辑序列化值
            writer.write(handleValue(strValue));
        }
        return writer.toString();
    }

    private String handleValue(Object value) {
        // 根据值的类型应用自定义序列化规则
        // 此处为简化示例，直接返回字符串表示
        return "\"" + value.toString() + "\"";
    }
}

5.1.2 自定义Java类的反序列化方法

反序列化是将JSON字符串转换回Java对象的过程。我们可以创建自定义的 JSONObject 子类来控制反序列化的逻辑。

import org.json.JSONObject;
import java.lang.reflect.InvocationTargetException;

public class CustomJSONObject extends JSONObject {
    public CustomJSONObject(String string) throws JSONException, InvocationTargetException, IllegalAccessException {
        super(string);
        // 在此添加自定义反序列化逻辑
        // ...
    }
}

5.2 json-lib的性能考量

5.2.1 json-lib的性能测试

性能测试是了解库性能的重要手段。我们可以使用JMeter、Gatling等工具对json-lib进行压力测试，比较不同大小和复杂度的数据转换时间。

5.2.2 json-lib的性能优化建议

• 减少不必要的数据转换 ：在服务端和客户端之间仅传输必要的数据。
• 缓存序列化后的字符串 ：对于频繁发送相同数据的场景，预先序列化并缓存字符串可以减少重复的序列化开销。
• 升级到最新版本 ：通常新版本的库会在性能上有所改进，确保使用的是json-lib的最新版本。

5.3 json-lib与其他JSON库的比较

5.3.1 json-lib与其他JSON库的性能比较

性能比较通常包括序列化速度、内存消耗和CPU使用率等方面。例如，可以将json-lib与Gson、Jackson等流行JSON处理库进行对比。

5.3.2 json-lib与其他JSON库的功能比较

除了性能，功能多样性也是选择库时的重要考量点。json-lib提供了许多独特的功能，如支持XML到JSON的转换，而其他库可能在JSON模式验证、流式处理等方面有更好的支持。

| 功能 | json-lib | Gson | Jackson | |---------------------|----------|------|---------| | Java对象转JSON | 支持 | 支持 | 支持 | | JSON转Java对象 | 支持 | 支持 | 支持 | | XML转JSON | 支持 | 不支持| 不支持 | | JSON模式验证 | 不支持 | 支持 | 支持 | | 流式处理 | 不支持 | 支持 | 支持 |

在选择合适的JSON库时，应该根据项目需求进行权衡，选择最适合的库。json-lib在某些特定用例中仍是非常有价值的选择，特别是在需要处理XML数据和复杂的自定义序列化/反序列化场景中。

本文还有配套的精品资源，点击获取

简介：JSON是一种广泛应用于Web应用的数据交换格式， json-lib 库提供了丰富的API来实现Java对象与JSON格式的转换。它支持多种数据类型转换，兼容Java SE和Java EE环境，并且有多个版本以适配不同的Java运行时环境。开发者可以根据项目需求选择合适的 json-lib 版本，并通过其提供的方法实现高效的序列化与反序列化。同时，开发者应关注性能，必要时与其他JSON库进行对比测试。本指南将介绍如何引入 json-lib 依赖、进行对象与JSON之间的转换，以及进行JSON数据操作和自定义序列化的技巧。

本文还有配套的精品资源，点击获取