Spring中双向关联嵌套JPA实体的灵活序列化方案咨询

方案核心逻辑 #

Jackson自带的JSON View功能可以针对不同序列化场景，指定仅序列化标注了对应视图的字段，无需额外创建DTO类，完全适配你的三个需求。

具体实现步骤 #

第一步：定义视图层级接口 #

先创建一个公共的视图类，定义三个场景对应的视图：

public class Views {
    // 基础视图：所有场景通用的基础字段
    public interface Base {}
    // 视图1：用户+名下预订+预订关联房间
    public interface UserWithBookings extends Base {}
    // 视图2：酒店+关联房间列表
    public interface HotelWithRooms extends Base {}
    // 视图3：房间+关联预订+预订关联用户
    public interface RoomWithBookings extends Base {}
}

第二步：给实体类字段加视图注解 #

按照你的需求给每个字段标注对应的视图：

User.java 调整后

@Entity 
@Table(name = "user") 
@Getter @Setter
public class User {
    @Id
    @SequenceGenerator(name="user_sequence", sequenceName="user_sequence",allocationSize = 1)
    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "user_sequence")
    @JsonView(Views.Base.class)
    private Long id;
    @JsonView(Views.Base.class)
    private String first_name;
    @JsonView(Views.Base.class)
    private String last_name;

    @OneToMany(mappedBy = "user")
    @JsonView(Views.UserWithBookings.class) // 仅在查询用户预订场景序列化
    private List<Booking> bookings = new ArrayList<>();
}

Hotel.java 调整后

@Entity 
@Table(name="hotel") 
@Getter @Setter
public class Hotel {
    @Id
    @SequenceGenerator(name="hotel_sequence",sequenceName="hotel_sequence", allocationSize = 1)
    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "hotel_sequence")
    @JsonView(Views.Base.class)
    private Long id;
    @JsonView(Views.Base.class)
    private String name;

    @OneToMany(mappedBy = "hotel")
    @JsonView(Views.HotelWithRooms.class) // 仅在查询酒店房间场景序列化
    private List<Room> rooms = new ArrayList<>();
}

Room.java 调整后

@Entity 
@Table(name = "room") 
@Getter @Setter
public class Room {
    @Id
    @SequenceGenerator( name="room_sequence",sequenceName="room_sequence",allocationSize = 1)
    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "room_sequence")
    @JsonView(Views.Base.class)
    private Long id;
    @JsonView(Views.Base.class)
    private String type;

    @ManyToOne(cascade = CascadeType.ALL)
    @JoinColumn(name="hotel_id", referencedColumnName = "id")
    // 无视图注解，所有场景都不反向序列化酒店，避免冗余
    private Hotel hotel;

    @ManyToMany(mappedBy = "rooms")
    @JsonView(Views.RoomWithBookings.class) // 仅在查询房间预订场景序列化
    private List<Booking> booking = new ArrayList<>();
}

Booking.java 调整后

@Entity 
@Table(name="booking") 
@Getter @Setter
public class Booking {
    @Id
    @SequenceGenerator(name="booking_sequence",sequenceName="booking_sequence",allocationSize = 1)
    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "booking_sequence")
    @JsonView(Views.Base.class)
    private Long id;
    @JsonView(Views.Base.class)
    private double price;
    @JsonView(Views.Base.class)
    private String info;

    @ManyToOne(cascade = CascadeType.ALL)
    @JoinColumn(name="user_id", referencedColumnName = "id")
    @JsonView(Views.RoomWithBookings.class) // 仅在查询房间预订场景序列化关联用户
    private User user;

    @ManyToMany
    @JoinTable(
            name="booking_rooms",
            joinColumns = @JoinColumn(name = "booking_id"),
            inverseJoinColumns = @JoinColumn(name="room_id")
    )
    @JsonView(Views.UserWithBookings.class) // 仅在查询用户预订场景序列化关联房间
    private List<Room> rooms = new ArrayList<>();
}

第三步：Controller层指定序列化视图 #

在对应接口上添加@JsonView注解指定使用的视图即可：

// 需求1：返回用户+预订+房间
@GetMapping("/users/{id}")
@JsonView(Views.UserWithBookings.class)
public User getUserWithBookings(@PathVariable Long id) {
    // 查询时建议用JOIN FETCH提前加载关联数据，避免懒加载异常和N+1问题
    return userRepository.findByIdWithBookingsAndRooms(id);
}

// 需求2：返回酒店+房间列表，排除预订
@GetMapping("/hotels/{id}")
@JsonView(Views.HotelWithRooms.class)
public Hotel getHotelWithRooms(@PathVariable Long id) {
    return hotelRepository.findByIdWithRooms(id);
}

// 需求3：返回房间+预订+用户（无用户其他预订）
@GetMapping("/rooms/{id}/bookings")
@JsonView(Views.RoomWithBookings.class)
public Room getRoomWithBookings(@PathVariable Long id) {
    return roomRepository.findByIdWithBookingsAndUser(id);
}

方案优势 #

1. 完全无需创建DTO类，减少冗余代码，后期实体字段变更仅需修改一处注解即可同步所有场景
2. 天然避免双向关联的循环序列化问题，无需额外配置序列化忽略规则
3. 扩展性极强，后续新增序列化场景仅需新增视图接口，给对应字段补充注解即可

注意事项 #

查询关联数据时建议在Repository层使用JPQL的JOIN FETCH语句一次性加载需要的关联字段，避免JPA懒加载异常和N+1查询问题。

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