Fastjson泛型反序列化实战：解决类型擦除导致的JSON转换问题

在日常的Java开发中，将JSON字符串转换为Java实体对象是一项常见操作。然而，当需要处理包含泛型的复杂对象时，简单的转换可能会遇到类型信息丢失的问题。本文将以Fastjson框架为例，探讨如何优雅且正确地实现JSON字符串到Java泛型实体类对象的转换。

环境与依赖

• 操作系统: Ubuntu 24.04.2 LTS
• JDK: 21.0.2
• 构建工具: Apache Maven 3.9.8
• IDE: IntelliJ IDEA 2025.1.3 (Community Edition)
• 核心库: Fastjson 1.2.83

首先，在项目的pom.xml中引入Fastjson依赖：

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

基础示例与问题初现

我们定义一个简单的泛型实体类 GenericEntity：

import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
public class GenericEntity<E> {
    private E data;
    public GenericEntity() {}
    public GenericEntity(E data) {
        this.data = data;
    }
}

并编写一个通用的JSON工具类 JsonUtil：

import com.alibaba.fastjson.JSON;

public class JsonUtil {
    public static <T> String toJson(T java) {
        return JSON.toJSONString(java);
    }
    public static <T> T toJava(String json, Class<T> clazz) {
        return JSON.parseObject(json, clazz);
    }
}

现在，我们尝试用一个简单的测试来验证基础功能，使用Integer作为泛型参数：

import org.junit.jupiter.api.Test;
public class FastjsonTestCase {
    @Test
    public void testJsonUtil() throws Exception {
        GenericEntity<Integer> entity = JsonUtil.toJava(
                JsonUtil.toJson(new GenericEntity<>(1)),
                GenericEntity.class
        );
        System.out.println(entity.getData() == 1); // 输出：true
    }
}

运行测试，结果符合预期。但问题真的如此简单吗？上面的例子仅使用了Integer这种基本包装类型。由于Java泛型的类型擦除机制，当泛型参数是自定义的复杂对象时，情况会变得不同。

自定义类型引发的类型转换异常

我们定义一个Person类：

import lombok.*;

@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class Person {
    private String name;
}

然后修改测试用例，尝试将JSON反序列化为GenericEntity<Person>：

@Test
public void testJsonUtilWithCustomType() throws Exception {
    GenericEntity<Person> entity = JsonUtil.toJava(
            JsonUtil.toJson(new GenericEntity<>(new Person("zhangsan"))),
            GenericEntity.class
    );
    // 断言失败，抛出 ClassCastException
    assert entity.getData() != null;
    assert entity.getData().getName().equals("zhangsan");
}

运行此测试会抛出java.lang.ClassCastException。虽然成功创建了GenericEntity实例，但其内部的data字段实际被反序列化成了com.alibaba.fastjson.JSONObject，而非期望的Person对象。这是因为在运行时，GenericEntity.class丢失了Person的类型信息。

解决方案一：使用 Type 参数

要正确保留泛型信息，需要借助Java的Type接口。Type是Java中所有类型的公共超接口，此处我们需要使用其子接口ParameterizedType（参数化类型）来描述GenericEntity<Person>。

首先，升级JsonUtil工具类，支持传入Type：

import com.alibaba.fastjson.JSON;
import java.lang.reflect.Type;

public class JsonUtil {
    public static <T> String toJson(T java) {
        return JSON.toJSONString(java);
    }
    public static <T> T toJava(String json, Type type) {
        return JSON.parseObject(json, type);
    }
}

在测试中，我们需要构造出代表GenericEntity<Person>的Type对象。Fastjson提供了ParameterizedTypeImpl来辅助构建：

import com.alibaba.fastjson.util.ParameterizedTypeImpl;
import org.junit.jupiter.api.Test;
import java.lang.reflect.Type;

public class FastjsonTestCase {
    @Test
    public void testWithType() throws Exception {
        GenericEntity<Person> genericEntity = new GenericEntity<>(new Person("zhangsan"));
        String json = JsonUtil.toJson(genericEntity);

        // 构建 ParameterizedType，表示 GenericEntity<Person>
        Type type = new ParameterizedTypeImpl(
                new Type[]{Person.class}, // 泛型实际参数数组
                null,                     // 所有者类型，null表示顶级类
                GenericEntity.class       // 原始类型
        );

        GenericEntity<Person> entity = JsonUtil.toJava(json, type);

        assert entity.getData() != null;
        assert entity.getData().getName().equals("zhangsan"); // 测试通过
    }
}

解决方案二：使用 TypeReference（推荐）

TypeReference是Fastjson提供的一个更便捷的包装类，通过匿名内部类来捕获泛型类型信息。这是更常用且简洁的方式。

再次升级JsonUtil，支持TypeReference：

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;

public class JsonUtil {
    public static <T> String toJson(T java) {
        return JSON.toJSONString(java);
    }
    public static <T> T toJava(String json, TypeReference<T> reference) {
        return JSON.parseObject(json, reference);
    }
}

测试用例变得非常简洁：

import com.alibaba.fastjson.TypeReference;
import org.junit.jupiter.api.Test;

public class FastjsonTestCase {
    @Test
    public void testWithTypeReference() throws Exception {
        GenericEntity<Person> genericEntity = new GenericEntity<>(new Person("zhangsan"));
        String json = JsonUtil.toJson(genericEntity);

        // 使用TypeReference匿名内部类捕获泛型类型
        GenericEntity<Person> entity = JsonUtil.toJava(
                json,
                new TypeReference<GenericEntity<Person>>() {}
        );

        assert entity.getData() != null;
        assert entity.getData().getName().equals("zhangsan"); // 测试通过
    }
}

两种方案的原理与选择

实际上，TypeReference内部机制最终也是将捕获的泛型信息转换为Type接口的实现。查看其源码可知，它利用子类继承来保存泛型参数。

• JSON.parseObject(String, Type)： 更底层，灵活性高，常见于需要动态构造泛型类型的框架代码中，例如编写通用的HTTP客户端或RPC调用封装。
• JSON.parseObject(String, TypeReference)： 语法糖，在编码时通过匿名类明确指定类型，使用更方便，代码可读性更强，是日常开发中的首选。

总结

在处理JSON反序列化，尤其是涉及泛型时，直接使用Class参数会因为Java的类型擦除而丢失泛型信息，导致反序列化结果不正确。通过本文介绍的两种方法：

1. 显式构造ParameterizedTypeImpl并传入Type参数。
2. 使用更便捷的TypeReference匿名内部类。

都可以有效地将完整的泛型类型信息传递给Fastjson，确保复杂对象结构的正确转换。在与Spring Boot等框架集成或进行JSON序列化库选型对比时，理解这一机制尤为重要。根据场景选择合适的方法，可以让我们在开发中更加得心应手。