Java+JPA配置JSON对象获取层级 避免实体循环序列化

首先明确：JPA本身不负责JSON序列化，双向关联导致的无限循环是JSON序列化框架（如Jackson）处理双向引用时的问题，而控制序列化层级也需要通过序列化框架或结合JPA投影实现，并非直接通过JPA配置完成。以下是几种可行方案：

方案一：使用Jackson注解控制关联与层级（快速解决） #

通过Jackson的注解直接干预序列化过程，既解决无限循环，又能控制到3层结构：

方式1：@JsonIgnoreProperties 精准控制层级 #

在关联字段上标注@JsonIgnoreProperties，指定忽略对方的关联字段，形成3层终止的结构：

@Entity
public class Product {
    @Id
    private Long id;
    private String productName;

    @ManyToOne(fetch = FetchType.LAZY)
    // 序列化Product时，忽略Supplier中的products字段
    @JsonIgnoreProperties("products")
    private Supplier supplier;

    // getter、setter省略
}

@Entity
public class Supplier {
    @Id
    private Long id;
    private String supplierName;

    @OneToMany(mappedBy = "supplier")
    // 序列化Supplier时，忽略Product中的supplier字段
    @JsonIgnoreProperties("supplier")
    private List<Product> products;

    // getter、setter省略
}

此配置下，序列化结构为：Product(1层) → Supplier(2层) → Product列表(3层)，到第3层时Product的supplier被忽略，不会继续循环。

方式2：@JsonManagedReference + @JsonBackReference（解决循环但层级受限） #

适合仅需终止循环，不需要保留3层结构的场景：

@Entity
public class Product {
    @Id
    private Long id;
    private String productName;

    @ManyToOne(fetch = FetchType.LAZY)
    // 主动端：正常序列化关联对象
    @JsonManagedReference
    private Supplier supplier;

    // getter、setter省略
}

@Entity
public class Supplier {
    @Id
    private Long id;
    private String supplierName;

    @OneToMany(mappedBy = "supplier")
    // 被动端：序列化时忽略关联对象，彻底终止循环
    @JsonBackReference
    private List<Product> products;

    // getter、setter省略
}

这种方式会让Supplier的products字段不被序列化，最终结构只有Product → Supplier两层。

方案二：JPA DTO投影（推荐，性能与可控性最优） #

通过定义DTO(Data Transfer Object)明确指定各层级需要返回的字段，结合JPA的投影查询，从根源避免加载不必要的关联对象，同时精准控制3层结构：

1. 定义层级DTO #

// 第1层：完整Product信息，包含SupplierDTO
public class ProductDTO {
    private Long id;
    private String productName;
    private SupplierDTO supplier;

    // 构造函数对应JPA查询投影
    public ProductDTO(Long id, String productName, SupplierDTO supplier) {
        this.id = id;
        this.productName = productName;
        this.supplier = supplier;
    }

    // getter省略
}

// 第2层：完整Supplier信息，包含ProductMinDTO列表
public class SupplierDTO {
    private Long id;
    private String supplierName;
    private List<ProductMinDTO> products;

    public SupplierDTO(Long id, String supplierName, List<ProductMinDTO> products) {
        this.id = id;
        this.supplierName = supplierName;
        this.products = products;
    }

    // getter省略
}

// 第3层：简化Product信息，无Supplier关联（终止层级）
public class ProductMinDTO {
    private Long id;
    private String productName;

    public ProductMinDTO(Long id, String productName) {
        this.id = id;
        this.productName = productName;
    }

    // getter省略
}

2. JPA投影查询 #

在Repository中编写查询，直接构造DTO返回：

@Repository
public interface ProductRepository extends JpaRepository<Product, Long> {
    @Query("SELECT new com.example.dto.ProductDTO(p.id, p.productName, " +
           "new com.example.dto.SupplierDTO(s.id, s.supplierName, " +
           "SELECT new com.example.dto.ProductMinDTO(p2.id, p2.productName) FROM Product p2 WHERE p2.supplier = s)) " +
           "FROM Product p LEFT JOIN p.supplier s WHERE p.id = :productId")
    ProductDTO findProductWithThreeLevels(@Param("productId") Long productId);
}

此方式仅查询需要的字段，避免了JPA的懒加载或全量加载，性能更优，且完全不会出现序列化循环。

方案三：自定义Jackson序列化器（通用层级控制） #

通过自定义序列化器跟踪当前序列化深度，超过3层时仅序列化ID等核心字段，适合需要全局控制层级的场景：

1. 实现深度控制序列化器 #

public class DepthLimitSerializerModifier extends BeanSerializerModifier {
    // 指定最大序列化深度为3
    private static final int MAX_DEPTH = 3;

    @Override
    public JsonSerializer<?> modifySerializer(SerializationConfig config, BeanDescription beanDesc, JsonSerializer<?> serializer) {
        if (serializer instanceof BeanSerializerBase) {
            return new DepthLimitSerializer((BeanSerializerBase) serializer);
        }
        return serializer;
    }

    private static class DepthLimitSerializer extends BeanSerializerBase {
        public DepthLimitSerializer(BeanSerializerBase source) {
            super(source);
        }

        @Override
        protected void serializeFields(Object bean, JsonGenerator gen, SerializerProvider provider) throws IOException {
            // 获取当前序列化深度，默认从1开始
            Integer currentDepth = (Integer) gen.getCurrentValueStack().stream()
                    .filter(o -> o instanceof Integer)
                    .findFirst()
                    .orElse(1);

            if (currentDepth > MAX_DEPTH) {
                // 超过深度，仅序列化ID（假设实体继承BaseEntity，包含getId()方法）
                gen.writeNumberField("id", ((BaseEntity) bean).getId());
                return;
            }

            // 深度+1，传递给下一层级
            gen.getCurrentValueStack().push(currentDepth + 1);
            try {
                super.serializeFields(bean, gen, provider);
            } finally {
                gen.getCurrentValueStack().pop();
            }
        }
    }
}

2. 注册序列化器到Jackson #

@Configuration
public class JacksonConfig {
    @Bean
    public ObjectMapper objectMapper() {
        ObjectMapper objectMapper = new ObjectMapper();
        // 注册自定义序列化器修饰器
        objectMapper.registerModule(new SimpleModule()
                .setSerializerModifier(new DepthLimitSerializerModifier()));
        return objectMapper;
    }
}

此方式会全局控制所有实体的序列化深度，超过3层时仅输出ID，有效避免循环与层级过深。

内容的提问来源于stack exchange，提问作者jonathan gonzalez