基于Hibernate的在线电影订票系统实体建模方案咨询

需求 #

• 存在影院（Theater）；
• 影院包含座位（Seat）；
• 影院内会放映特定电影（Movie）的场次（Show）；
• 用户（User）可为场次预订座位；
• (Show + Seat)组合需唯一，且仅能被一位用户预订（无需考虑支付失败/重新预订场景）

初步实体设计 #

########################################

Theater
    - name: String
    - seats: List<Seats> 
Seat
    - name: String
    - theater: Theater
Movie
    - name: String
Show
    - theater: Theater
    - movie: Movie
    - startTime: LocalDateTime
    - endTime: LocalDateTime
User
    - name: String
    - email: String

########################################

Booking
    - user: User
    - bookedShowSeats: List<ShowSeat>
ShowSeat
    - show: Show
    - seat: Seat

########################################

咨询问题 #

1. 是否可不创建ShowSeat实体来建模关系？曾尝试@Embeddable但未成功；
2. 如何为(Show + Seat)组合设置唯一约束？

问题解答 #

1. 能否不创建ShowSeat实体？ #

可以不用单独创建ShowSeat实体，但需要调整关联映射的方式。你之前尝试@Embeddable失败，通常是因为没处理好复合元素的序列化和关联映射逻辑。

具体实现方案（@ElementCollection + @Embeddable）

适合不需要为Show+Seat组合附加额外属性（如预订价格、状态）的场景：
首先定义可嵌入的复合类：

@Embeddable
public class ShowSeatEmbeddable implements Serializable {
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "show_id")
    private Show show;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "seat_id")
    private Seat seat;

    // 必须提供无参构造函数，以及重写equals和hashCode方法
    public ShowSeatEmbeddable() {}

    public ShowSeatEmbeddable(Show show, Seat seat) {
        this.show = show;
        this.seat = seat;
    }

    // getter、setter方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        ShowSeatEmbeddable that = (ShowSeatEmbeddable) o;
        return Objects.equals(show.getId(), that.show.getId()) && Objects.equals(seat.getId(), that.seat.getId());
    }

    @Override
    public int hashCode() {
        return Objects.hash(show.getId(), seat.getId());
    }
}

然后修改Booking实体，用@ElementCollection关联这个可嵌入类：

@Entity
public class Booking {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "user_id")
    private User user;

    @ElementCollection
    @CollectionTable(
        name = "booking_show_seats",
        joinColumns = @JoinColumn(name = "booking_id")
    )
    private List<ShowSeatEmbeddable> bookedShowSeats;

    // 其他属性和方法
}

注意事项

这种方式下，Show+Seat的组合没有独立的主键，依赖于Booking的关联。如果后续需要单独查询某个场次的座位预订情况（比如查某场电影哪些座位被订了），单独的ShowSeat实体会更方便——因为可以直接通过ShowSeat的Repository查询，不用绕到Booking中过滤。

2. 如何为(Show + Seat)组合设置唯一约束？ #

分两种场景处理：

场景一：使用ShowSeat实体

有两种常用方式：

方式1：复合主键（推荐）

通过@EmbeddedId或@IdClass定义复合主键，天然保证Show+Seat的唯一性：

// 定义复合主键类
@Embeddable
public class ShowSeatId implements Serializable {
    @Column(name = "show_id")
    private Long showId;

    @Column(name = "seat_id")
    private Long seatId;

    // 无参构造函数、getter、setter，重写equals和hashCode
    public ShowSeatId() {}

    public ShowSeatId(Long showId, Long seatId) {
        this.showId = showId;
        this.seatId = seatId;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        ShowSeatId that = (ShowSeatId) o;
        return Objects.equals(showId, that.showId) && Objects.equals(seatId, that.seatId);
    }

    @Override
    public int hashCode() {
        return Objects.hash(showId, seatId);
    }
}

// ShowSeat实体
@Entity
public class ShowSeat {
    @EmbeddedId
    private ShowSeatId id;

    @ManyToOne(fetch = FetchType.LAZY)
    @MapsId("showId") // 将show字段映射到复合主键的showId
    @JoinColumn(name = "show_id")
    private Show show;

    @ManyToOne(fetch = FetchType.LAZY)
    @MapsId("seatId") // 将seat字段映射到复合主键的seatId
    @JoinColumn(name = "seat_id")
    private Seat seat;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "booking_id")
    private Booking booking;

    // 其他属性和方法
}

Hibernate会自动在数据库层面为复合主键创建唯一约束，确保同一个Show+Seat组合不会重复。

方式2：普通主键 + 表级唯一约束

如果不想用复合主键，可以在ShowSeat实体的@Table注解中添加唯一约束：

@Entity
@Table(uniqueConstraints = {
    @UniqueConstraint(columnNames = {"show_id", "seat_id"})
})
public class ShowSeat {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "show_id")
    private Show show;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "seat_id")
    private Seat seat;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "booking_id")
    private Booking booking;

    // 其他属性和方法
}

场景二：不使用ShowSeat实体（@Embeddable方式）

需要在@CollectionTable中添加唯一约束，确保booking_show_seats表中show_id和seat_id的组合唯一：

@Entity
public class Booking {
    // 其他属性...

    @ElementCollection
    @CollectionTable(
        name = "booking_show_seats",
        joinColumns = @JoinColumn(name = "booking_id"),
        uniqueConstraints = @UniqueConstraint(columnNames = {"show_id", "seat_id"})
    )
    private List<ShowSeatEmbeddable> bookedShowSeats;

    // 其他方法...
}

这样数据库会自动为这两个字段创建唯一索引，防止同一个Show+Seat被关联到多个Booking。

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