JAVA Json 序列化异常？循环引用与 Lazy Loading 导致的栈溢出问题

JSON 序列化异常：循环引用与 Lazy Loading 导致的栈溢出

大家好，今天我们来聊聊在使用 Java 进行 JSON 序列化时，经常会遇到的一个棘手问题：循环引用和 Lazy Loading 导致的栈溢出。这个问题在稍微复杂一点的系统中几乎是不可避免的，理解其原理和掌握解决方案对于编写健壮的 JSON 处理代码至关重要。

什么是 JSON 序列化？

首先，我们快速回顾一下 JSON 序列化的概念。JSON (JavaScript Object Notation) 是一种轻量级的数据交换格式，易于人阅读和编写，同时也易于机器解析和生成。在 Java 中，JSON 序列化指的是将 Java 对象转换为 JSON 字符串的过程。

例如，我们有一个简单的 Java 类 Person:

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = 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;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + ''' +
                ", age=" + age +
                '}';
    }
}

使用 Gson 库，我们可以将 Person 对象序列化为 JSON 字符串：

import com.google.gson.Gson;

public class SerializationExample {
    public static void main(String[] args) {
        Person person = new Person("Alice", 30);
        Gson gson = new Gson();
        String json = gson.toJson(person);
        System.out.println(json); // 输出: {"name":"Alice","age":30}
    }
}

这个过程很简单，但当对象之间存在复杂的关联关系时，问题就出现了。

循环引用：问题的根源

循环引用是指两个或多个对象相互引用，形成一个闭环。例如，考虑以下 Employee 和 Department 类：

public class Employee {
    private String name;
    private Department department;

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

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

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + ''' +
                ", department=" + department +
                '}';
    }
}

public class Department {
    private String name;
    private Employee manager;

    public Department(String name, Employee manager) {
        this.name = name;
        this.manager = manager;
    }

    public String getName() {
        return name;
    }

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

    public Employee getManager() {
        return manager;
    }

    public void setManager(Employee manager) {
        this.manager = manager;
    }

    @Override
    public String toString() {
        return "Department{" +
                "name='" + name + ''' +
                ", manager=" + manager +
                '}';
    }
}

现在，我们创建一个 Employee 对象和一个 Department 对象，并让它们相互引用：

public class CircularReferenceExample {
    public static void main(String[] args) {
        Department department = new Department("IT", null);
        Employee employee = new Employee("Bob", department);
        department.setManager(employee);

        Gson gson = new Gson();
        try {
            String json = gson.toJson(employee);
            System.out.println(json);
        } catch (StackOverflowError e) {
            System.err.println("StackOverflowError: " + e.getMessage());
        }
    }
}

这段代码会导致 StackOverflowError。 原因在于，Gson 尝试序列化 employee 对象，然后遇到 department 属性，它又尝试序列化 department 对象，接着又遇到 manager 属性，指向 employee，如此循环往复，导致无限递归，最终耗尽栈空间。

Lazy Loading：雪上加霜

另一个导致栈溢出的常见原因是 Lazy Loading，尤其是在使用 ORM (Object-Relational Mapping) 框架（如 Hibernate 或 JPA）时。Lazy Loading 是一种优化技术，它延迟加载对象的关联属性，直到真正需要访问这些属性时才进行加载。

考虑以下使用 Hibernate 的例子：

@Entity
@Table(name = "orders")
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String orderNumber;

    @ManyToOne(fetch = FetchType.LAZY) // 关键：FetchType.LAZY
    @JoinColumn(name = "customer_id")
    private Customer customer;

    // Getters and setters
    public Long getId() {
        return id;
    }

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

    public String getOrderNumber() {
        return orderNumber;
    }

    public void setOrderNumber(String orderNumber) {
        this.orderNumber = orderNumber;
    }

    public Customer getCustomer() {
        return customer;
    }

    public void setCustomer(Customer customer) {
        this.customer = customer;
    }
}

@Entity
@Table(name = "customers")
public class Customer {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @OneToMany(mappedBy = "customer", fetch = FetchType.LAZY) // 关键：FetchType.LAZY
    private List<Order> orders;

    // Getters and setters
    public Long getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public List<Order> getOrders() {
        return orders;
    }

    public void setOrders(List<Order> orders) {
        this.orders = orders;
    }
}

Order 和 Customer 之间存在关联关系，Order 拥有一个 Customer 属性，Customer 拥有一个 List<Order> 属性。 FetchType.LAZY 表示，在默认情况下，不会立即加载 customer 和 orders 属性。

现在，假设我们从数据库中获取一个 Order 对象，并尝试将其序列化为 JSON：

import com.google.gson.Gson;
import org.hibernate.Hibernate;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class LazyLoadingExample {
    public static void main(String[] args) {
        Configuration configuration = new Configuration().configure();
        SessionFactory sessionFactory = configuration.buildSessionFactory();
        Session session = sessionFactory.openSession();

        Order order = session.get(Order.class, 1L); // 假设存在 id 为 1 的 order

        Gson gson = new Gson();
        try {
            String json = gson.toJson(order);
            System.out.println(json);
        } catch (StackOverflowError e) {
            System.err.println("StackOverflowError: " + e.getMessage());
        } finally {
            session.close();
            sessionFactory.close();
        }
    }
}

在这种情况下，即使没有显式的循环引用，仍然可能发生 StackOverflowError。 当 Gson 尝试序列化 order 对象时，它会访问 order.getCustomer()。由于 customer 属性是 Lazy Loading 的，访问它会导致 Hibernate 尝试从数据库中加载 customer 对象。 如果 Customer 对象又包含一个 Lazy Loading 的 orders 列表，并且在序列化过程中访问了 customer.getOrders()，Hibernate 又会尝试加载 orders 列表，并且列表中的每个 Order 对象又会尝试加载其 Customer，这就可能形成一个隐式的循环，导致栈溢出。

更重要的是，即使没有真正的循环引用，Lazy Loading 也会导致性能问题。每次访问一个 Lazy Loading 的属性，都需要进行数据库查询，这会导致 N+1 查询问题，严重影响性能。

解决循环引用和 Lazy Loading 的方案

现在，我们来讨论如何解决这些问题。

1. 使用 @JsonIgnore 或 @Transient 注解

这是最简单的解决方案之一。通过在不需要序列化的属性上添加 @JsonIgnore (Gson, Jackson) 或 @Transient (Java 标准) 注解，可以告诉 JSON 库忽略该属性。

例如，对于 Employee 和 Department 类的循环引用问题，我们可以在 Employee 类的 department 属性上添加 @JsonIgnore:

import com.google.gson.annotations.JsonIgnore;

public class Employee {
    private String name;
    @JsonIgnore
    private Department department;

    // ... (其他代码)
}

或者，可以使用 @Transient 注解：

import java.beans.Transient;

public class Employee {
    private String name;
    @Transient
    private Department department;

    // ... (其他代码)
}

对于 Lazy Loading，也可以使用相同的方法。例如，在 Customer 类的 orders 属性上添加 @JsonIgnore：

import com.google.gson.annotations.JsonIgnore;

@Entity
@Table(name = "customers")
public class Customer {
    // ... (其他代码)

    @OneToMany(mappedBy = "customer", fetch = FetchType.LAZY)
    @JsonIgnore
    private List<Order> orders;

    // ... (其他代码)
}

优点:

• 简单易用，只需添加注解即可。

缺点:

• 可能会丢失一些需要序列化的信息。
• 修改了实体类的定义，可能影响其他业务逻辑。
• 不适用于所有场景，例如，如果需要序列化一部分关联对象，但避免循环引用，这种方法就无能为力了。

2. 使用 @JsonIdentityInfo 注解 (Jackson)

@JsonIdentityInfo 注解可以用来跟踪已经序列化的对象，避免重复序列化相同的对象，从而解决循环引用问题。 这个注解是Jackson库提供的。

import com.fasterxml.jackson.annotation.JsonIdentityInfo;
import com.fasterxml.jackson.annotation.ObjectIdGenerators;

@JsonIdentityInfo(
        generator = ObjectIdGenerators.PropertyGenerator.class,
        property = "id")
public class Employee {
    private Long id;
    private String name;
    private Department department;

    // ... (Getters and setters)
    public Long getId() {
        return id;
    }

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

@JsonIdentityInfo(
        generator = ObjectIdGenerators.PropertyGenerator.class,
        property = "id")
public class Department {
    private Long id;
    private String name;
    private Employee manager;

    // ... (Getters and setters)

    public Long getId() {
        return id;
    }

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

在这个例子中，@JsonIdentityInfo 注解告诉 Jackson 使用 id 属性作为对象的唯一标识符。 当 Jackson 遇到一个已经序列化的对象时，它会使用对象的 ID 来代替整个对象，从而避免循环引用。 第一次序列化 Employee 对象时，会输出完整的对象信息。 再次遇到相同的 Employee 对象时，只会输出其 ID。

优点:

• 可以保留所有的对象信息，避免信息丢失。
• 不需要修改实体类的定义。

缺点:

• 只能解决循环引用问题，不能解决 Lazy Loading 问题。
• 依赖 Jackson 库。
• 输出的 JSON 结构可能比较复杂，可读性较差。

3. 使用 DTO (Data Transfer Object)

DTO 是一种专门用于数据传输的对象，它只包含需要传输的数据，不包含任何业务逻辑。 通过使用 DTO，可以避免序列化整个实体对象，从而解决循环引用和 Lazy Loading 问题。

首先，创建 EmployeeDTO 和 DepartmentDTO 类：

public class EmployeeDTO {
    private Long id;
    private String name;
    private Long departmentId; // 只包含 department 的 ID

    public EmployeeDTO(Employee employee) {
        this.id = employee.getId();
        this.name = employee.getName();
        this.departmentId = employee.getDepartment().getId();
    }

    // Getters and setters
    public Long getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public Long getDepartmentId() {
        return departmentId;
    }

    public void setDepartmentId(Long departmentId) {
        this.departmentId = departmentId;
    }
}

public class DepartmentDTO {
    private Long id;
    private String name;
    private Long managerId; // 只包含 manager 的 ID

    public DepartmentDTO(Department department) {
        this.id = department.getId();
        this.name = department.getName();
        this.managerId = department.getManager().getId();
    }

    // Getters and setters
    public Long getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public Long getManagerId() {
        return managerId;
    }

    public void setManagerId(Long managerId) {
        this.managerId = managerId;
    }
}

然后，在序列化之前，将实体对象转换为 DTO 对象：

public class DTOExample {
    public static void main(String[] args) {
        Department department = new Department("IT", null);
        Employee employee = new Employee("Bob", department);
        department.setManager(employee);

        EmployeeDTO employeeDTO = new EmployeeDTO(employee);

        Gson gson = new Gson();
        String json = gson.toJson(employeeDTO);
        System.out.println(json);
    }
}

优点:

• 可以完全控制序列化的数据，避免循环引用和 Lazy Loading 问题。
• 可以提高性能，只传输需要的数据。
• 解耦了实体类和 JSON 序列化逻辑。

缺点:

• 需要创建额外的 DTO 类。
• 需要在实体类和 DTO 类之间进行转换，增加了代码量。
• 如果实体类的结构经常变化，DTO 类也需要频繁修改。

4. 使用自定义序列化器

自定义序列化器可以完全控制 JSON 序列化的过程，可以根据需要序列化特定的属性，避免循环引用和 Lazy Loading 问题。

以 Gson 为例，可以创建一个自定义的 EmployeeSerializer:

import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonSerializationContext;
import com.google.gson.JsonSerializer;

import java.lang.reflect.Type;

public class EmployeeSerializer implements JsonSerializer<Employee> {
    @Override
    public JsonElement serialize(Employee employee, Type typeOfSrc, JsonSerializationContext context) {
        JsonObject jsonObject = new JsonObject();
        jsonObject.addProperty("id", employee.getId());
        jsonObject.addProperty("name", employee.getName());
        jsonObject.addProperty("departmentId", employee.getDepartment().getId()); // 只序列化 department 的 ID
        return jsonObject;
    }
}

然后，在创建 Gson 对象时，注册该序列化器：

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

public class CustomSerializerExample {
    public static void main(String[] args) {
        Department department = new Department("IT", null);
        Employee employee = new Employee("Bob", department);
        department.setManager(employee);

        GsonBuilder gsonBuilder = new GsonBuilder();
        gsonBuilder.registerTypeAdapter(Employee.class, new EmployeeSerializer());
        Gson gson = gsonBuilder.create();

        String json = gson.toJson(employee);
        System.out.println(json);
    }
}

优点:

• 可以完全控制 JSON 序列化的过程。
• 可以根据需要序列化特定的属性。
• 可以避免循环引用和 Lazy Loading 问题。

缺点:

• 需要编写大量的代码。
• 需要了解 JSON 库的内部机制。
• 维护成本较高。

5. Hibernate.initialize() 方法

对于 Hibernate Lazy Loading 问题，可以使用 Hibernate.initialize() 方法强制加载 Lazy Loading 的属性。 但是，这种方法并不推荐，因为它会破坏 Lazy Loading 的初衷，导致性能问题。

import org.hibernate.Hibernate;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateInitializeExample {
    public static void main(String[] args) {
        Configuration configuration = new Configuration().configure();
        SessionFactory sessionFactory = configuration.buildSessionFactory();
        Session session = sessionFactory.openSession();

        Order order = session.get(Order.class, 1L); // 假设存在 id 为 1 的 order
        Hibernate.initialize(order.getCustomer()); // 强制加载 customer 属性

        Gson gson = new Gson();
        String json = gson.toJson(order);
        System.out.println(json);

        session.close();
        sessionFactory.close();
    }
}

优点:

• 可以解决 Lazy Loading 问题。

缺点:

• 会破坏 Lazy Loading 的初衷，导致性能问题。
• 不适用于所有场景，例如，如果需要序列化大量的 Lazy Loading 属性，会导致大量的数据库查询。

6. 使用 Jackson 的 @JsonManagedReference 和 @JsonBackReference

这两个注解是 Jackson 库提供的，用于解决父子关系的循环引用问题。@JsonManagedReference 注解用于父对象，表示该属性是正向引用，应该被序列化。@JsonBackReference 注解用于子对象，表示该属性是反向引用，不应该被序列化。

import com.fasterxml.jackson.annotation.JsonBackReference;
import com.fasterxml.jackson.annotation.JsonManagedReference;

public class Employee {
    private Long id;
    private String name;
    @JsonManagedReference
    private Department department;

    // ... (Getters and setters)
}

public class Department {
    private Long id;
    private String name;
    @JsonBackReference
    private Employee manager;

    // ... (Getters and setters)
}

优点:

• 可以解决父子关系的循环引用问题。
• 不需要修改实体类的定义。

缺点:

• 只能解决父子关系的循环引用问题，不适用于其他类型的循环引用。
• 依赖 Jackson 库。

如何选择合适的方案？

选择哪种方案取决于具体的需求和场景。

方案	优点	缺点	适用场景
@JsonIgnore 或 @Transient	简单易用	可能会丢失信息，修改实体类定义	只需要忽略少量属性，对性能要求不高
@JsonIdentityInfo (Jackson)	保留所有信息，不需要修改实体类定义	只能解决循环引用问题，依赖 Jackson 库，输出 JSON 结构可能复杂	需要保留所有对象信息，且系统已经使用了 Jackson 库
DTO	完全控制序列化数据，提高性能，解耦实体类和 JSON 序列化逻辑	需要创建额外的 DTO 类，需要进行转换，如果实体类结构经常变化，DTO 类也需要频繁修改	需要完全控制序列化的数据，提高性能，解耦实体类和 JSON 序列化逻辑
自定义序列化器	完全控制 JSON 序列化过程，可以序列化特定的属性	需要编写大量代码，需要了解 JSON 库的内部机制，维护成本高	需要非常精细地控制 JSON 序列化过程，例如，需要对不同的对象进行不同的序列化处理
Hibernate.initialize()	可以解决 Lazy Loading 问题	会破坏 Lazy Loading 的初衷，导致性能问题，不适用于所有场景	极少数情况下，需要强制加载 Lazy Loading 的属性，并且对性能要求不高
@JsonManagedReference 和 @JsonBackReference (Jackson)	解决父子关系的循环引用	只能解决父子关系的循环引用问题，依赖 Jackson 库	系统使用了Jackson库，并且是标准的父子关系

额外的建议

• 避免过度关联: 在设计数据模型时，尽量避免过度关联，减少循环引用的可能性。
• 使用分页查询: 在处理大量数据时，使用分页查询可以避免一次性加载所有数据，从而减少 Lazy Loading 带来的问题。
• 开启 Session 的事务: 在序列化 Lazy Loading 的属性时，确保 Session 处于事务中，否则可能会出现 LazyInitializationException 异常。
• 监控性能: 使用性能监控工具，可以及时发现 Lazy Loading 导致的性能问题。

总结概括

循环引用和 Lazy Loading 是 Java JSON 序列化中常见的陷阱。 通过选择合适的解决方案，例如使用 @JsonIgnore、@JsonIdentityInfo、DTO 或自定义序列化器，可以有效地避免这些问题。 在实际开发中，需要根据具体的需求和场景，选择最合适的方案。