Java 有人能帮助我理解以下与hibernate中的继承策略相关的逻辑吗？

本文摘自一本名为《使用hibernate实现Spring持久化》的书，作者描述了hibernate中每个具体类一个表继承策略的缺点。在给定的示例中，学生和教师是Person类的子类，Person与Address类关联。我无法理解下面给出的这个特殊论点：-

对多态关联的支持不完善：当 父类与另一个持久类相关联。在我们的例子中， 假设Person与Address类关联，那么Student和 教师也与地址关联。映射此类层次结构的步骤 根据这种方法，我们的数据库中需要这四个表 模式：个人、学生、教师和地址如果地址有 与个人的多对一关系（可能不止一个人有 相同的地址），则地址表应提供外键 参考所有个人、学生和教师表，以便建立 数据库级关系，但这是不可能的。

---

为什么地址表不能为PERSON、STUDENT和TEACHER表提供外键引用

假设您有三个不同的数据库表

PERSON

、

STUDENT

和

TEACHER

，您将如何定义表

ADDRESS

上的外键约束

CONSTRAINT FOREIGN KEY fk_address_owner
ADDRESS.owner_id
REFERENCES (which table?) (id)

---

如您所见，您必须指向三个数据库表。这是不可能的。

假设您有三个不同的数据库表

PERSON

、

STUDENT

和

TEACHER

，您将如何定义表

ADDRESS

上的外键约束

CONSTRAINT FOREIGN KEY fk_address_owner
ADDRESS.owner_id
REFERENCES (which table?) (id)

---

如您所见，您必须指向三个数据库表。这是不可能的。

在

继承类型中。每个类的表

不可能实现

地址

与

人

有多对一关系。Hibernate不创建关联

但是可以在

学生

和

地址

之间创建单向一对多。以下是

地址

实体：

@Entity
public class Address {
    @Id
    @GeneratedValue
    private Long id;
    private String address;

    public Address() {
    }

@Entity
@Table(name = "persons")
@Inheritance(strategy = InheritanceType.JOINED)
public class Person {

    @Id
    @GeneratedValue
    private Long id;
    private String name;

    @OneToMany(mappedBy="person")
    private List<Address> addresses;

    public Person() {
    }

个人

实体是：

@Entity
@Table(name = "persons")
@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
public class Person {

    @Id
    @GeneratedValue
    private Long id;
    private String name;

    public Person() {
    }

@Entity
@Table(name = "students")
public class Student extends Person {
    @OneToMany(mappedBy="student")
    private List<Address> addresses;

    public Student() {
    }

@Entity
@Table(name = "persons")
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
public class Person {

    @Id
    @GeneratedValue
    private Long id;
    private String name;

    @OneToMany(mappedBy="person")
    private List<Address> addresses;

    public Person() {
    }

@Entity
@Table(name = "students")
public class Student extends Person {

    private String studentEmail;

    public Student() {
    }

Student

实体子类

Person

实体：

@Entity
@Table(name = "students")
public class Student extends Person {
    @OneToMany()
    @JoinColumn(name = "student_id", referencedColumnName = "id")
    private List<Address> addresses;

    public Student() {
    }

@Entity
public class Address {
    @Id
    @GeneratedValue
    private Long id;
    private String address;

     @ManyToOne
     private Person person;

    public Address() {
    }

    @Entity
    public class Address {
        @Id
        @GeneratedValue
        private Long id;
        private String address;

         @ManyToOne
         private Person person;

        public Address() {
        }

可以实现

学生

和

地址

之间的双向关联：

@Entity
public class Address {
    @Id
    @GeneratedValue
    private Long id;
    private String address;

    @ManyToOne
    private Student student;

    public Address() {
    }

而

学生

实体是：

@Entity
@Table(name = "persons")
@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
public class Person {

    @Id
    @GeneratedValue
    private Long id;
    private String name;

    public Person() {
    }

@Entity
@Table(name = "students")
public class Student extends Person {
    @OneToMany(mappedBy="student")
    private List<Address> addresses;

    public Student() {
    }

@Entity
@Table(name = "persons")
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
public class Person {

    @Id
    @GeneratedValue
    private Long id;
    private String name;

    @OneToMany(mappedBy="person")
    private List<Address> addresses;

    public Person() {
    }

@Entity
@Table(name = "students")
public class Student extends Person {

    private String studentEmail;

    public Student() {
    }

个人

实体：

@Entity
public class Address {
    @Id
    @GeneratedValue
    private Long id;
    private String address;

    public Address() {
    }

@Entity
@Table(name = "persons")
@Inheritance(strategy = InheritanceType.JOINED)
public class Person {

    @Id
    @GeneratedValue
    private Long id;
    private String name;

    @OneToMany(mappedBy="person")
    private List<Address> addresses;

    public Person() {
    }

Hibernate创建表：

Hibernate: 

    create table Address (
        id bigint not null,
        address varchar(255),
        person_id bigint,
        primary key (id)
    )

Hibernate: 

    create table persons (
        id bigint not null,
        name varchar(255),
        primary key (id)
    )
Hibernate: 

    create table students (
        email varchar(255),
        id bigint not null,
        primary key (id)
    )

Hibernate: 

    alter table Address 
        add constraint FKtaq05im3hxcvufy75xk044251 
        foreign key (person_id) 
        references persons (id)
Hibernate: 

    alter table students 
        add constraint FK9nqs0pkter5l6no6n9v93uyau 
        foreign key (id) 
        references persons (id)

students

table references

persons

table via

FK9nqs0pkter5l6no6n9v93uyau

constraint<代码>地址表格参考人员表格via

FKtaq05im3hxcvufy75xk044251

。这意味着hibernate在

地址

个人实体的集合中处理

学生

实体和

地址

实体之间的一对多。任何子类为

人

的实体都与

地址

实体有一对多关系

使用

InheritanceType.SINGLE_表

可以在

地址

和

学生

之间创建双向多对一。以下是

地址

实体：

@Entity
@Table(name = "students")
public class Student extends Person {
    @OneToMany()
    @JoinColumn(name = "student_id", referencedColumnName = "id")
    private List<Address> addresses;

    public Student() {
    }

@Entity
public class Address {
    @Id
    @GeneratedValue
    private Long id;
    private String address;

     @ManyToOne
     private Person person;

    public Address() {
    }

    @Entity
    public class Address {
        @Id
        @GeneratedValue
        private Long id;
        private String address;

         @ManyToOne
         private Person person;

        public Address() {
        }

个人

实体是：

@Entity
@Table(name = "persons")
@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
public class Person {

    @Id
    @GeneratedValue
    private Long id;
    private String name;

    public Person() {
    }

@Entity
@Table(name = "students")
public class Student extends Person {
    @OneToMany(mappedBy="student")
    private List<Address> addresses;

    public Student() {
    }

@Entity
@Table(name = "persons")
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
public class Person {

    @Id
    @GeneratedValue
    private Long id;
    private String name;

    @OneToMany(mappedBy="person")
    private List<Address> addresses;

    public Person() {
    }

@Entity
@Table(name = "students")
public class Student extends Person {

    private String studentEmail;

    public Student() {
    }

Hibernate为

Student

和

Person

实体中的字段创建单个表：

Hibernate: 

    create table Address (
        id bigint not null,
        address varchar(255),
        person_id bigint,
        primary key (id)
    )

Hibernate: 

    create table persons (
        DTYPE varchar(31) not null,
        id bigint not null,
        name varchar(255),
        studentEmail varchar(255),
        primary key (id)
    )
Hibernate: 

    alter table Address 
        add constraint FKtaq05im3hxcvufy75xk044251 
        foreign key (person_id) 
        references persons (id)

---

学生

实体与

地址

实体有一对多关系，因为

FKtaq05im3hxcvufy75xk044251

约束。

在

继承类型中。每个类的表

不可能实现

地址

与

人

有多对一关系。Hibernate不创建关联

但是可以在

学生

和

地址

之间创建单向一对多。以下是

地址

实体：

@Entity
public class Address {
    @Id
    @GeneratedValue
    private Long id;
    private String address;

    public Address() {
    }

@Entity
@Table(name = "persons")
@Inheritance(strategy = InheritanceType.JOINED)
public class Person {

    @Id
    @GeneratedValue
    private Long id;
    private String name;

    @OneToMany(mappedBy="person")
    private List<Address> addresses;

    public Person() {
    }

个人

实体是：

@Entity
@Table(name = "persons")
@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
public class Person {

    @Id
    @GeneratedValue
    private Long id;
    private String name;

    public Person() {
    }

@Entity
@Table(name = "students")
public class Student extends Person {
    @OneToMany(mappedBy="student")
    private List<Address> addresses;

    public Student() {
    }

@Entity
@Table(name = "persons")
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
public class Person {

    @Id
    @GeneratedValue
    private Long id;
    private String name;

    @OneToMany(mappedBy="person")
    private List<Address> addresses;

    public Person() {
    }

@Entity
@Table(name = "students")
public class Student extends Person {

    private String studentEmail;

    public Student() {
    }

Student

实体子类

Person

实体：

@Entity
@Table(name = "students")
public class Student extends Person {
    @OneToMany()
    @JoinColumn(name = "student_id", referencedColumnName = "id")
    private List<Address> addresses;

    public Student() {
    }

@Entity
public class Address {
    @Id
    @GeneratedValue
    private Long id;
    private String address;

     @ManyToOne
     private Person person;

    public Address() {
    }

    @Entity
    public class Address {
        @Id
        @GeneratedValue
        private Long id;
        private String address;

         @ManyToOne
         private Person person;

        public Address() {
        }

可以实现

学生

和

地址

之间的双向关联：

@Entity
public class Address {
    @Id
    @GeneratedValue
    private Long id;
    private String address;

    @ManyToOne
    private Student student;

    public Address() {
    }

而

学生

实体是：

@Entity
@Table(name = "persons")
@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
public class Person {

    @Id
    @GeneratedValue
    private Long id;
    private String name;

    public Person() {
    }

@Entity
@Table(name = "students")
public class Student extends Person {
    @OneToMany(mappedBy="student")
    private List<Address> addresses;

    public Student() {
    }

@Entity
@Table(name = "persons")
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
public class Person {

    @Id
    @GeneratedValue
    private Long id;
    private String name;

    @OneToMany(mappedBy="person")
    private List<Address> addresses;

    public Person() {
    }

@Entity
@Table(name = "students")
public class Student extends Person {

    private String studentEmail;

    public Student() {
    }

个人

实体：

@Entity
public class Address {
    @Id
    @GeneratedValue
    private Long id;
    private String address;

    public Address() {
    }

@Entity
@Table(name = "persons")
@Inheritance(strategy = InheritanceType.JOINED)
public class Person {

    @Id
    @GeneratedValue
    private Long id;
    private String name;

    @OneToMany(mappedBy="person")
    private List<Address> addresses;

    public Person() {
    }

Hibernate创建表：

Hibernate: 

    create table Address (
        id bigint not null,
        address varchar(255),
        person_id bigint,
        primary key (id)
    )

Hibernate: 

    create table persons (
        id bigint not null,
        name varchar(255),
        primary key (id)
    )
Hibernate: 

    create table students (
        email varchar(255),
        id bigint not null,
        primary key (id)
    )

Hibernate: 

    alter table Address 
        add constraint FKtaq05im3hxcvufy75xk044251 
        foreign key (person_id) 
        references persons (id)
Hibernate: 

    alter table students 
        add constraint FK9nqs0pkter5l6no6n9v93uyau 
        foreign key (id) 
        references persons (id)

students

table references

persons

table via

FK9nqs0pkter5l6no6n9v93uyau

constraint<代码>地址表格参考人员表格via

FKtaq05im3hxcvufy75xk044251

。这意味着hibernate在

地址

个人实体的集合中处理

学生

实体和

地址

实体之间的一对多。任何子类为

人

的实体都与

地址

实体有一对多关系

使用

InheritanceType.SINGLE_表

可以在

地址

和

学生

之间创建双向多对一。以下是

地址

实体：

@Entity
@Table(name = "students")
public class Student extends Person {
    @OneToMany()
    @JoinColumn(name = "student_id", referencedColumnName = "id")
    private List<Address> addresses;

    public Student() {
    }

@Entity
public class Address {
    @Id
    @GeneratedValue
    private Long id;
    private String address;

     @ManyToOne
     private Person person;

    public Address() {
    }

    @Entity
    public class Address {
        @Id
        @GeneratedValue
        private Long id;
        private String address;

         @ManyToOne
         private Person person;

        public Address() {
        }

个人

实体是：

@Entity
@Table(name = "persons")
@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
public class Person {

    @Id
    @GeneratedValue
    private Long id;
    private String name;

    public Person() {
    }

@Entity
@Table(name = "students")
public class Student extends Person {
    @OneToMany(mappedBy="student")
    private List<Address> addresses;

    public Student() {
    }

@Entity
@Table(name = "persons")
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
public class Person {

    @Id
    @GeneratedValue
    private Long id;
    private String name;

    @OneToMany(mappedBy="person")
    private List<Address> addresses;

    public Person() {
    }

@Entity
@Table(name = "students")
public class Student extends Person {

    private String studentEmail;

    public Student() {
    }

Hibernate为

Student

和

Person

实体中的字段创建单个表：

Hibernate: 

    create table Address (
        id bigint not null,
        address varchar(255),
        person_id bigint,
        primary key (id)
    )

Hibernate: 

    create table persons (
        DTYPE varchar(31) not null,
        id bigint not null,
        name varchar(255),
        studentEmail varchar(255),
        primary key (id)
    )
Hibernate: 

    alter table Address 
        add constraint FKtaq05im3hxcvufy75xk044251 
        foreign key (person_id) 
        references persons (id)

---

学生

实体与

地址

实体有一对多关系，因为

FKtaq05im3hxcvufy75xk044251

约束。

在数据库中，地址表可能有四个表的外键@JaySmith是可能的还是不可能的？在数据库中，地址表可以有四个表的外键@JaySmith这是可能的还是不可能的？