如何在JPA中实现共享library_code的Borrow复合主键实体映射？

首先明确你的数据库模型和现有代码背景：
你的数据库有4张固定表：

• Libraries：主键为code
• Persons：复合主键是name + library_code（library_code关联Libraries，同时作为主键一部分）
• Books：复合主键是title + library_code（library_code关联Libraries，同时作为主键一部分）
• Borrows：复合主键是person_name + book_title + library_code，且library_code必须和Persons、Books的对应字段完全一致

你已经完成了前三个实体的JPA映射：

@Entity
class Library {
    @Id
    private String code;
}

@Embeddable
class PersonId implements Serializable {
    private String name;
    private String library_code;
}

@Entity
class Person {
    @EmbeddedId
    private PersonId id;
}

@Embeddable
class BookId implements Serializable {
    private String title;
    private String library_code;
}

@Entity
class Book {
    @EmbeddedId
    private BookId id;
}

你想通过嵌套PersonId和BookId来实现Borrow实体的嵌入式ID，这个思路完全可行，但直接写会导致library_code被重复映射成两个字段，不符合你的需求。下面是最优的实现方式：

完整的Borrow实体实现代码 #

import java.io.Serializable;
import java.util.Objects;
import jakarta.persistence.*; // 注意：Spring Boot 3+用jakarta.persistence，JPA 2.x版本用javax.persistence

@Embeddable
class BorrowId implements Serializable {
    // 单独定义共享的library_code，作为Borrow主键的核心部分
    private String library_code;

    // 嵌套PersonId，覆盖其字段映射，确保library_code复用同一个列
    @Embedded
    @AttributeOverrides({
        @AttributeOverride(name = "name", column = @Column(name = "person_name")),
        // 把PersonId的library_code指向当前的library_code列，禁止插入更新避免重复操作
        @AttributeOverride(name = "library_code", column = @Column(name = "library_code", insertable = false, updatable = false))
    })
    private PersonId person;

    // 嵌套BookId，同样处理library_code的映射
    @Embedded
    @AttributeOverrides({
        @AttributeOverride(name = "title", column = @Column(name = "book_title")),
        @AttributeOverride(name = "library_code", column = @Column(name = "library_code", insertable = false, updatable = false))
    })
    private BookId book;

    // JPA要求嵌入式ID必须有无参构造函数
    public BorrowId() {}

    // 自定义构造函数，添加一致性校验避免数据不一致
    public BorrowId(String library_code, PersonId person, BookId book) {
        this.library_code = library_code;
        this.person = person;
        this.book = book;

        // 强制校验：Person和Book的library_code必须和Borrow的一致
        if (!library_code.equals(person.getLibrary_code()) || !library_code.equals(book.getLibrary_code())) {
            throw new IllegalArgumentException("Person和Book必须属于同一个图书馆！");
        }
    }

    // 必须实现getter/setter方法
    public String getLibrary_code() { return library_code; }
    public void setLibrary_code(String library_code) { this.library_code = library_code; }
    public PersonId getPerson() { return person; }
    public void setPerson(PersonId person) { this.person = person; }
    public BookId getBook() { return book; }
    public void setBook(BookId book) { this.book = book; }

    // 必须实现equals和hashCode，JPA依赖这个判断实体相等性
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        BorrowId borrowId = (BorrowId) o;
        return Objects.equals(library_code, borrowId.library_code) &&
               Objects.equals(person, borrowId.person) &&
               Objects.equals(book, borrowId.book);
    }

    @Override
    public int hashCode() {
        return Objects.hash(library_code, person, book);
    }
}

@Entity
@Table(name = "Borrows")
class Borrow {
    @EmbeddedId
    private BorrowId id;

    // 无参构造函数
    public Borrow() {}

    // 带ID的构造函数
    public Borrow(BorrowId id) {
        this.id = id;
    }

    // getter/setter方法
    public BorrowId getId() { return id; }
    public void setId(BorrowId id) { this.id = id; }
}

关键实现说明 #

1. 共享字段映射：在BorrowId中单独定义library_code直接对应数据库列；通过@AttributeOverride让PersonId和BookId里的library_code复用这个列，同时设置insertable=false, updatable=false，避免JPA尝试重复操作该字段。
2. 数据一致性校验：在构造函数中添加强制校验，确保PersonId、BookId和BorrowId的library_code完全一致，从代码层面避免脏数据。
3. JPA规范兼容：严格遵循JPA要求，实现Serializable接口、添加无参构造函数，以及正确的equals和hashCode方法，保证实体持久化操作正常运行。

这样既实现了你想要的嵌套嵌入式ID结构，又满足数据库中library_code共享的要求，完全不需要修改现有数据库模型。

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