Hibernate 快速入门2 - 关联映射和类继承

2 关联映射

我们知道两个表A、B的映射关系有 1-1, 1-N, M-N

对于每种映射关系，还可以分为单向和双向。即单向 1-1, 其中一端不能访问另外一端。 双向1-1，两端能互访。对于其他映射关系也是一样的。

从编码的角度来说，单向的意思是，A含有类型为B的成员变量，而B没有类型为A的成员变量。双向的意思是，，A含有类型为B的成员变量, B也含有类型为A的成员变量。

下面我们来一一讲解

2.1.1 单向1-1 (A含有B，B不含有A）

对于单项1-1映射，我们用@OneToOne来指明另一端的类，用@JoinColumn来指定外键的关联。

增加一个Professor类。假设一个Professor只教育一个学生，一个学生也只由一个Professor教育。现在我们假设只有Professor能查看学生的信息，学生不能查看Professor的信息.

Student类不变，下面是Professor类:

@Entity
public class Professor {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "professor_id")
    private Integer id;

    private String name;

    @OneToOne(targetEntity = Student.class)
    // FOREIGN KEY (student_id) REFERENCES student_info (id);
    @JoinColumn(name = "student_id", referencedColumnName = "id")
    private Student student;
    
    // getters and setters
}

public static void addProfessor(Integer student_id) {
    Configuration conf = new Configuration().configure();
    StandardServiceRegistry registry = conf.getStandardServiceRegistryBuilder().build();
    try (SessionFactory sessionFactory = conf.buildSessionFactory(registry); Session session = sessionFactory.openSession()) {
        Transaction transaction = session.beginTransaction();

        Professor professor = new Professor();
        professor.setName("james lee");

        Student student = session.get(Student.class, student_id);
        professor.setStudent(student);

        session.save(professor);
        transaction.commit();
    }
}

public static void main(String[] args) {
    addProfessor(10);
}

addProfessor(10)传入10是因为student_info中有id = 10的数据。

启动的时候，我们会发现抛异常了:
Exception in thread "main" org.hibernate.MappingException: Unknown entity: com.example.test.Professor

原来是我们忘了在hibernate.cfg.xml中添加映射类的了。

<mapping class="com.example.test.Professor"/>

添加完后成功启动，我们可以看到新建的professor表：

mysql> select * from professor;
+--------------+-----------+------------+
| professor_id | name      | student_id |
+--------------+-----------+------------+
|            1 | james lee |         10 |
+--------------+-----------+------------+
1 row in set (0.00 sec)

student_info表是没有任何改变的，我这里就不贴出来了。

对Professor.student属性，可以省略@JoinColumn，hibernate会自动生成一个属性来代表Student。但是最好不要这么做。

注意，OneToOne映射，为两个类都建立了表。而在前面一节中，我们把BodyInfo作为Student的一个属性来，BodyInfo用@Embeddable标注了。结果是BodyInfo的所有字段(都是非集合字段)都合并到了Student表中。

2.1.2 双向1-1 （A、B互相包含）

首先，mysql用root登入，先把hibernatedb，删了重新建过，然后再赋予ALL权限给hibernate，向第一章那样。一定要这么做，不然不能正常插入数据。

Professor.java修改如下：

@Entity
public class Professor {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "professor_id")
    private Integer id;

    private String name;

    @OneToOne(targetEntity = Student.class, mappedBy = "professor")
    // FOREIGN KEY (student_id) REFERENCES student_info (id);
//    @JoinColumn(name = "student_id", referencedColumnName = "id")
    private Student student;
}    

mappedBy表示，Professor放弃控制权，由Student来控制。在SQL上的表现就是，Professor表没专门为此生成的属性和外键。mappedBy = "professor"，这个"professor"表示，Student类中名字为professor的属性存在。即Student.professor这个成员变量存在(其实只要保证Student.getProfessor(), Student.setProfessor(Professor)存在即可)。

Student.java修改如下:

@Entity
@Table(name = "student_info")
public class Student {
    @OneToOne(targetEntity = Professor.class)
    @JoinColumn(name = "professor_id", referencedColumnName = "professor_id", unique = true)
    private Professor professor;
}

HibernateTest.java修改如下：

public static void biOneToOne() {
    Configuration conf = new Configuration().configure();
    StandardServiceRegistry registry = conf.getStandardServiceRegistryBuilder().build();
    try (SessionFactory sessionFactory = conf.buildSessionFactory(registry); Session session = sessionFactory.openSession()) {
        Transaction transaction = session.beginTransaction();

        Professor professor = new Professor();
        professor.setName("professor name one2one");

        session.save(professor);

        Student student = new Student();
        student.setName("student name one2one");
        student.setProfessor(professor);

        session.save(student);

        transaction.commit();
    }
}
public static void main(String[] args) {
    biOneToOne();
}

MySQL输出如下：

mysql> select * from student_info;
+----+-----+--------+--------+----------------------+--------------+
| id | age | height | weight | name                 | professor_id |
+----+-----+--------+--------+----------------------+--------------+
|  1 |   0 |   NULL |   NULL | student name one2one |            1 |
+----+-----+--------+--------+----------------------+--------------+
1 row in set (0.00 sec)

mysql> select * from professor;
+--------------+------------------------+
| professor_id | name                   |
+--------------+------------------------+
|            1 | professor name one2one |
+--------------+------------------------+
1 row in set (0.00 sec)

mysql> show create table student_info;
CREATE TABLE `student_info` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `age` int(11) NOT NULL,
  `height` int(11) DEFAULT NULL,
  `weight` int(11) DEFAULT NULL,
  `name` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL,
  `professor_id` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `UK_gg8r834cvr56est49a2tlw8an` (`professor_id`),
  CONSTRAINT `FKmudc1uutqukeete7gravfalew` FOREIGN KEY (`professor_id`) REFERENCES `Professor` (`professor_id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci

mysql> show create table professor;
CREATE TABLE `professor` (
  `professor_id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL,
  PRIMARY KEY (`professor_id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci

可以看到professor上面的确没有Student的任何信息，因为它已经用mappedBy声明放弃控制。

2.1.3 单向N - 1 （A含有B，B不含有A）

比如一个教授可以教授多个学生，每个学生只能由一个教授指导。

我们当然可以让一个教授包含多个学生，就像前一章中映射集合一样。但这里，Student是一个实体(Entity)，在语境上不符合作为Embeddable。因为Student完全可能和Professor的其他Entity产生关系。

为了简单起见，我们把Student的集合属性和组合属性都删掉。然后重新hibernatedb，重建。

Student.java

@Entity
@Table(name = "student_info")
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;

    private String name;

    private int age;

    @ManyToOne(targetEntity = Professor.class)
    @JoinColumn(name = "professor_id", referencedColumnName = "professor_id", nullable = false) // remove unique=true!!!
    @Cascade(org.hibernate.annotations.CascadeType.ALL)
    private Professor professor;
    
    // getter and setters
}

Professor.java

@Entity
public class Professor {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "professor_id")
    private Integer id;

    private String name;
}

HibernateTest.java

public static void uniManyToOne() {
    Configuration conf = new Configuration().configure();
    StandardServiceRegistry registry = conf.getStandardServiceRegistryBuilder().build();
    try (SessionFactory sessionFactory = conf.buildSessionFactory(registry); Session session = sessionFactory.openSession()) {
        Transaction transaction = session.beginTransaction();

        Professor professor = new Professor();
        professor.setName("professor name one2one");

        Student student = new Student();
        student.setName("student name one2one");
        student.setProfessor(professor);

        Student student2 = new Student();
        student2.setName("student2");;
        student2.setProfessor(professor);

        session.save(student2);

        transaction.commit();
    }
}

public static void main(String[] args) {
    uniManyToOne();
}    

数据库输出：

mysql> select * from professor;
+--------------+------------------------+
| professor_id | name                   |
+--------------+------------------------+
|            1 | professor name one2one |
+--------------+------------------------+
1 row in set (0.00 sec)

mysql> select * from student_info;
+----+-----+----------------------+--------------+
| id | age | name                 | professor_id |
+----+-----+----------------------+--------------+
|  1 |   0 | student name one2one |            1 |
|  2 |   0 | student2             |            1 |
+----+-----+----------------------+--------------+
2 rows in set (0.00 sec)

mysql> show create table professor;
CREATE TABLE `professor` (
  `professor_id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL,
  PRIMARY KEY (`professor_id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci

mysql> show create table student_info;
CREATE TABLE `student_info` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `age` int(11) NOT NULL,
  `name` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL,
  `professor_id` int(11) NOT NULL,
  PRIMARY KEY (`id`),
  KEY `FKmudc1uutqukeete7gravfalew` (`professor_id`),
  CONSTRAINT `FKmudc1uutqukeete7gravfalew` FOREIGN KEY (`professor_id`) REFERENCES `Professor` (`professor_id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci

可以看到professor是没有任何外键的，student_info有一个外键，引用了professor.id。这就是对于关系映射N-1的情况下，我们应该设计的数据的样子。

@Cascade: 指定映射的级联。如果没有这个注解，那我们就必须先save(professor)，才能save(student)。

2.1.4 单向 1 - N

hibernate不推荐控制权在1端，而是推荐控制权在N端，也就是推荐使用前面的单向N-1。

2.1.5 双向1-N （A含有元素类型为B的属性，B含有A）

双向1-N和双向N-1都是一样的。

先删除前面建的表(drop table xxx)。

双向的1-N和前面的单向N-1十分类似。只需要修改Professor类:

@Entity
public class Professor {
    @OneToMany(targetEntity = Student.class, mappedBy = "professor")
    private List<String> studentList;
//    private Student student;
}

输出结果和上面都是一样的。这里就不重复了。

值得提一下的是:

HibernateTest.java

public static void searchProfessor(Integer id) {
    Configuration conf = new Configuration().configure();
    StandardServiceRegistry registry = conf.getStandardServiceRegistryBuilder().build();
    try (SessionFactory sessionFactory = conf.buildSessionFactory(registry); Session session = sessionFactory.openSession()) {
        Transaction transaction = session.beginTransaction();
        Professor professor = session.get(Professor.class, id);
        if (professor != null) {
            System.out.println("student name: " + professor.getStudentList());
        }
        transaction.commit();
    }
}

其中参数Id是数据库中的一个id。如果运行这个函数的话，能正确的输出Professor对应的student list。

2.1.6 单向N-M （A含有B）

在控制的一段添加ManyToMany

@Entity
@Table(name = "student_info")
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;

    private String name;

    private int age;

    @ManyToMany(targetEntity = Professor.class)
    @JoinColumn(name = "professor_id", referencedColumnName = "professor_id", nullable = false)
    private List<Professor> professorList = new ArrayList<>();
}

@Entity
public class Professor {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "professor_id")
    private Integer id;

    private String name;
}

Transaction transaction = session.beginTransaction();

Professor professor = new Professor();
professor.setName("professor1");
session.save(professor);

Professor professor2 = new Professor();
professor2.setName("professor2");
session.save(professor2);

Student student = new Student();
student.setName("student name one2one");
student.getProfessorList().add(professor);
student.getProfessorList().add(professor2);

session.save(student);

Student student2 = new Student();
student2.setName("student2");
student2.getProfessorList().add(professor);
student2.getProfessorList().add(professor2);

session.save(student2);

transaction.commit();

数据库输出：

mysql> select * from student_info;
+----+-----+----------------------+
| id | age | name                 |
+----+-----+----------------------+
|  1 |   0 | student name one2one |
|  2 |   0 | student2             |
+----+-----+----------------------+
2 rows in set (0.01 sec)

mysql> select * from professor;
+--------------+------------+
| professor_id | name       |
+--------------+------------+
|            1 | professor1 |
|            2 | professor2 |
+--------------+------------+
2 rows in set (0.00 sec)

mysql> select * from student_info_Professor;
+------------+----------------------------+
| Student_id | professorList_professor_id |
+------------+----------------------------+
|          1 |                          1 |
|          1 |                          2 |
|          2 |                          1 |
|          2 |                          2 |
+------------+----------------------------+
4 rows in set (0.00 sec)

mysql> show create table student_info_Professor;

CREATE TABLE `student_info_Professor` (
  `Student_id` int(11) NOT NULL,
  `professorList_professor_id` int(11) NOT NULL,
  KEY `FKoboctn2nj4vqepv9lngaatdc9` (`professorList_professor_id`),
  KEY `FKh6rxyclu4wmcpuqi215m6rwd9` (`Student_id`),
  CONSTRAINT `FKh6rxyclu4wmcpuqi215m6rwd9` FOREIGN KEY (`Student_id`) REFERENCES `student_info` (`id`),
  CONSTRAINT `FKoboctn2nj4vqepv9lngaatdc9` FOREIGN KEY (`professorList_professor_id`) REFERENCES `Professor` (`professor_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci

2.1.7 双向N-N （A含有B、B也含有A）

@Entity
public class Professor {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "professor_id")
    private Integer id;

    private String name;

    @ManyToMany(targetEntity = Student.class)
    @JoinTable(joinColumns = @JoinColumn(name = "professor_id", referencedColumnName = "professor_id"))
    private List<String> studentList;
}

@Entity
@Table(name = "student_info")
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;

    private String name;

    private int age;

    @ManyToMany(targetEntity = Professor.class)
    @JoinTable(joinColumns = @JoinColumn(name = "id", referencedColumnName = "id"))
//    @Column(name = "student_id")
    private List<Professor> professorList = new ArrayList<>();

其他的和单向N-N一样。

@JoinTable：指定用连接表来保存映射关系(像前面的student_info_Professor)。需要注意的是，里面的@JoinColumn，为什么这里和以前的不一样，以前的JoinColumn(name, referencedColumnName)都是不同的，而这里为什么不一样？JoinColumn的意思是，本段的name属性应用了另一个表的referencedColumnName。由于这里指定了@JoinTable，也就是指定了用一个连接表，那么另一个表指的就是连接表。我们当然应该表这个表中的name属性和连接表中的name属性映射起来。即A.a 映射到连接表AB.a， B.b映射到连接到AB.b。

3 类继承

比如我们前面的Student代表的是大学生，它在数据库中有一个对应的表。 现在新建它的一个子类PostGraduate(研究生)，那么对于PostGraduate在数据库中的存在有几种呢？

对于类的继承，我们有如下几种方式：

• 子类和父类处于同一个表内(这样是hibernate默认的实现方式）。这需要修改父类的表以适应子类。
• 子类处和父类各自处于单独的表。
• 连接子类。子类新增的属性处于一个单独的表，同时修改父类的表，增加一个外键引用子类的表。

3.1 子类和父类共用一表 （Hibernate默认实现方式）

考虑一下，如果子类和父类共用一个表，那我们势必需要在表中添加一个属性，标识是父类还是子类。这个属性叫做辨别者列(discriminator)，我们用@DiscriminatorColumn注解来标识辨别者列。对于每个类在辨别者列上的取值，我们用@DiscirminatorValue指定。

先来看看重定义的Student:

@Entity
@DiscriminatorColumn(name = "student_type", discriminatorType = DiscriminatorType.STRING)
@DiscriminatorValue("student")
@Table(name = "student_info")
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;

    private String name;

    private int age;
}

新定义一个PostGraduate继承Student:

@Entity
@DiscriminatorValue("post_gradudate")
public class PostGraduate extends Student {
    private String finalPaper;
}

HibernateTest.java

public static void inheritance() {
    Configuration conf = new Configuration().configure();
    StandardServiceRegistry registry = conf.getStandardServiceRegistryBuilder().build();
    try (SessionFactory sessionFactory = conf.buildSessionFactory(registry); Session session = sessionFactory.openSession()) {
        Transaction transaction = session.beginTransaction();

        Student student = new Student();
        student.setName("student name");
        student.setAge(18);
        session.save(student);

        Student student1 = new Student();
        student1.setName("student name1");
        student1.setAge(19);
        session.save(student1);

        PostGraduate postGraduate = new PostGraduate();
        postGraduate.setAge(23);
        postGraduate.setFinalPaper("introduction to linux");
        session.save(postGraduate);

        PostGraduate postGraduate1 = new PostGraduate();
        postGraduate1.setAge(24);
        postGraduate1.setFinalPaper("java io");
        session.save(postGraduate1);

        transaction.commit();
    }
}

public static void main(String[] args) {
    inheritance();
}

sql输出：

mysql> select * from student_info;
+----------------+----+-----+---------------+-----------------------+
| student_type   | id | age | name          | finalPaper            |
+----------------+----+-----+---------------+-----------------------+
| student        |  1 |  18 | student name  | NULL                  |
| student        |  2 |  19 | student name1 | NULL                  |
| post_gradudate |  3 |  23 | NULL          | introduction to linux |
| post_gradudate |  4 |  24 | NULL          | java io               |
+----------------+----+-----+---------------+-----------------------+
4 rows in set (0.00 sec)

可以看到student_info增加了PostGraduate的属性。student_type是辨别者列，通过这个列上的属性来判断是哪个类。对于子类新增的属性，父类对应的值为NULL。

3.2 子类、父类各自处于单独的表

考虑一下，前面我们生成主键的时候，指定了@GeneratedValue(strategy = GeneratedType.IDENTITY)，表示自增。在只有一张表的情况下，这是OK的。但对于我们现在描述的情况，父类子类处于不同的表，这种自增策略就不行了。此时我们要使用Hibernate自带生成策略。这里我们使用hibernate hilo生成策略，策略的意思以及其他策略请参考文档。

同时，为了让父类、子类各自处于单独的表，我们还需要用@Inheritance替换@Discriminator

Student.java

@Entity
@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
@Table(name = "student_info")
public class Student {
    @Id
    @GenericGenerator(name = "student_uuid", strategy = "org.hibernate.id.UUIDGenerator")
    @GeneratedValue(generator = "student_uuid")
    private String id;

    private String name;

    private int age;
}    

需要注意的是，我们把id从Integer变成了String。因为UUIDGenerator生成的主键不可能用integer保存。

PostGraudate.java

@Entity
public class PostGraduate extends Student {
    private String finalPaper;
}    

sql输出：

mysql> select * from PostGraduate;
+--------------------------------------+-----+------+-----------------------+
| id                                   | age | name | finalPaper            |
+--------------------------------------+-----+------+-----------------------+
| ad0f4762-8d8e-459e-a6b3-bb219d7658c7 |  24 | NULL | java io               |
| e83572ce-a814-4e85-b8ba-79dd298b1240 |  23 | NULL | introduction to linux |
+--------------------------------------+-----+------+-----------------------+
2 rows in set (0.00 sec)

mysql> select * from student_info;
+--------------------------------------+-----+---------------+
| id                                   | age | name          |
+--------------------------------------+-----+---------------+
| 3c96ba4f-e719-491f-bd96-76811d832bf5 |  19 | student name1 |
| c5299329-90bf-4dbf-9085-cd366da0b407 |  18 | student name  |
+--------------------------------------+-----+---------------+

可以看到，的确是在两个不同的表中。

3.3 连接子类映射策略

这种策略只需要把上面的@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)修改为@Inheritance(strategy = InheritanceType.JOINED)

这种策略由于查找的时候，要join一次，性能比前面两种低，所以这里暂时不讲解。有兴趣的可以自己跑一下看输出。