Spring Boot中Jackson序列化嵌套对象缺失及层级限制问题

针对你遇到的FournitureOrder的fourniture字段缺失、同时需要限制Fourniture不返回orders列表的问题，这里提供三种可行的实现方式：

方法一：使用Jackson注解直接控制实体序列化 #

通过Jackson的注解可以快速在实体层控制序列化规则，同时解决循环引用问题：

实体代码示例 #

Person 实体

@Entity
public class Person {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    
    @OneToMany(mappedBy = "person", cascade = CascadeType.ALL)
    @JsonManagedReference // 标记主动序列化的关联，避免循环引用
    private List<FournitureOrder> orders;
    
    // 省略getter、setter、构造器
}

FournitureOrder 实体

@Entity
public class FournitureOrder {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @ManyToOne
    @JoinColumn(name = "person_id")
    @JsonBackReference // 标记反向关联，不序列化回Person，避免循环
    private Person person;
    
    @ManyToOne
    @JoinColumn(name = "fourniture_id")
    @JsonInclude(JsonInclude.Include.ALWAYS) // 强制序列化该字段，解决缺失问题
    private Fourniture fourniture;
    
    // 省略getter、setter、构造器
}

Fourniture 实体

@Entity
public class Fourniture {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String type;
    
    @OneToMany(mappedBy = "fourniture", cascade = CascadeType.ALL)
    @JsonIgnore // 直接忽略orders字段，序列化时不返回
    private List<FournitureOrder> orders;
    
    // 省略getter、setter、构造器
}

这种方式优点是快速实现，无需额外代码；缺点是序列化规则和实体耦合，后续如果API需求变化，需要修改实体类。

方法二：使用DTO（数据传输对象）解耦实体与API响应 #

这是生产环境中更推荐的方式，通过DTO定义API返回的结构，完全解耦JPA实体和响应格式：

DTO代码示例 #

FournitureDTO

public class FournitureDTO {
    private Long id;
    private String name;
    private String type;
    
    // 仅保留需要返回的字段，不包含orders
    // 省略getter、setter、全参/无参构造器
}

FournitureOrderDTO

public class FournitureOrderDTO {
    private Long id;
    private FournitureDTO fourniture;
    
    // 根据需求可选是否保留Person的信息（比如只存personId）
    // 省略getter、setter、构造器
}

PersonDTO

public class PersonDTO {
    private Long id;
    private String name;
    private List<FournitureOrderDTO> orders;
    
    // 省略getter、setter、构造器
}

服务层转换逻辑 #

@Service
public class PersonService {
    @Autowired
    private PersonRepository personRepository;
    
    public PersonDTO getPersonById(Long id) {
        Person person = personRepository.findById(id)
                .orElseThrow(() -> new RuntimeException("Person not found"));
        
        PersonDTO personDTO = new PersonDTO();
        personDTO.setId(person.getId());
        personDTO.setName(person.getName());
        
        // 手动转换实体到DTO，也可以用ModelMapper、MapStruct等工具简化
        List<FournitureOrderDTO> orderDTOs = person.getOrders().stream()
                .map(order -> {
                    FournitureOrderDTO orderDTO = new FournitureOrderDTO();
                    orderDTO.setId(order.getId());
                    
                    FournitureDTO fournitureDTO = new FournitureDTO();
                    fournitureDTO.setId(order.getFourniture().getId());
                    fournitureDTO.setName(order.getFourniture().getName());
                    fournitureDTO.setType(order.getFourniture().getType());
                    
                    orderDTO.setFourniture(fournitureDTO);
                    return orderDTO;
                })
                .collect(Collectors.toList());
        
        personDTO.setOrders(orderDTOs);
        return personDTO;
    }
}

控制器返回DTO #

@RestController
@RequestMapping("/api/persons")
public class PersonController {
    @Autowired
    private PersonService personService;
    
    @GetMapping("/{id}")
    public ResponseEntity<PersonDTO> getPerson(@PathVariable Long id) {
        return ResponseEntity.ok(personService.getPersonById(id));
    }
}

这种方式优点是完全解耦，API结构变更不影响实体，扩展性强；缺点是需要额外编写DTO和转换逻辑（可以用MapStruct等工具自动生成转换代码）。

方法三：使用Spring Data Projections简化查询与序列化 #

如果只是简单的字段筛选，可以用Spring Data的Projection功能，直接在查询时定义返回的字段结构：

Projection接口定义 #

FournitureProjection

public interface FournitureProjection {
    Long getId();
    String getName();
    String getType();
    // 不定义getOrders()方法，序列化时就不会返回该字段
}

FournitureOrderProjection

public interface FournitureOrderProjection {
    Long getId();
    FournitureProjection getFourniture();
    // 可选：如果需要Person信息，可定义PersonProjection接口
}

PersonProjection

public interface PersonProjection {
    Long getId();
    String getName();
    List<FournitureOrderProjection> getOrders();
}

Repository层查询方法 #

public interface PersonRepository extends JpaRepository<Person, Long> {
    PersonProjection findProjectedById(Long id);
}

控制器返回Projection #

@GetMapping("/{id}")
public ResponseEntity<PersonProjection> getPerson(@PathVariable Long id) {
    return ResponseEntity.ok(personRepository.findProjectedById(id));
}

这种方式优点是无需编写DTO和转换逻辑，代码简洁；缺点是仅适合简单的字段筛选场景，复杂的API结构还是需要DTO。

内容的提问来源于stack exchange，提问作者ZAKARYAE ADMI