继承映射

对于面向对象的程序设计语言而言 ，继承和多态是两个最基本的概念。Hibernate的继承映射可以理解持久化类之间的继承关系。

例如：人和学生之间的关系。学生继承了人 ，可以认为学生是一个特殊的人，如果对人进行查询，学生的实例也将被得到。

Class Person    int  personId

                              String  name

                              Int  age

Class Student   String  school

                              String  major

 

Hibernate支持三种继承映射策略：

  1. 使用subclass进行映射：将域模型中的每一个实体对象映射到一个独立的表中，也就是说不用在关系数据模型中考虑域模型中的继承关系和多态 。
  2. 使用joined-subclass进行映射：对于继承关系中的子类使用同一个表，这就需要在数据库表中增加额外的区分子类类型的字段。
  3. 使用union-subclass进行映射：域模型中的每个类映射到一个表，通过关系数据模型中的外键来描述表之间的继承关系，这也就相当于按照域模型的结构来建立数据库中的表，并通过外键来建立表之间的继承关系。

 

  1. 采用subclass元素的继承映射

采用subclass的继承映射可以实现对于继承关系中父类和子类使用同一张表。

因为父类和子类的实例全部保存在同一个表中，因此需要在该表内增加一列（辨别者列）

，使用该列来区分每行记录到底是哪个类的实例--------这个列被称为辨别者列（discriminator）

在这种映射策略下，使用subclass来映射子类，使用class或subclass的discriminator-value属性指定辨别者列的值

所有子类定义的字段都不能有非空约束。如果为那些字段添加非空约束，那么父类的实例在那些列其实并没有值，这将引起数据库完整性冲突，父类类的实例无法保存到数据库中。

 

采用union-subclass元素的继承映射

采用union-subclass元素可以实现将每一个实体对象映射到一个独立的表中。

子类增加的属性可以有非空约束-------即父类实例的数据保存在父表中，而子类实例的数据保存在子类表中。

子类实例的数据仅保存在子类表中，而在父类表中没有任何记录。

在这种映射策略下，子类表中字段会比父类表中字段要多 ，因为子类表的字段等于父类表的组电，加上子类增加属性的总和。

在这种映射策略下，既不需要使用鉴别者列，也无需使用key元素来映射共有主键。

使用union-subclass映射策略是不可使用identity的主键生成策略，因为同一类继承层次中所有实体类都需要使用同一个主键种子，即多个持久化实体对应的记录了的主键应该是连续的，受此影响，也不该使用native主键生成策略，因为native会根据数据库来选择使用identity或sequence.

 

 

package com.atguigu.hibernate.subclass;

 

public class Person {

    private Integer id;

    private String name;

    private int age;

    public Integer getId() {

       return id;

    }

    public void setId(Integer id) {

       this.id = id;

    }

    public String getName() {

       return name;

    }

    public void setName(String name) {

       this.name = name;

    }

    public int getAge() {

       return age;

    }

    public void setAge(int age) {

       this.age = age;

    }

}

 

 

package com.atguigu.hibernate.subclass;

 

public class Student extends Person{

   

    private String school;

 

    public String getSchool() {

       return school;

    }

 

    public void setSchool(String school) {

       this.school = school;

    }

}

 

 

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >

<hibernate-mapping package="com.atguigu.hibernate.subclass">

    <class name="Person"  table="persons" discriminator-value="person">

       <id name="id" type="java.lang.Integer">

           <column name="id"></column>

           <generator class="native"></generator>

       </id>

      

       <!-- 配置辨别者列 -->

       <discriminator column="type" type="string" ></discriminator>

      

       <property name="name" type="string">

           <column name="name"></column>

       </property>

      

       <property name="age" type="int">

           <column name="age"></column>

       </property>

      

       <!-- 映射子类Student，使用subclass进行映射 -->

       <subclass name="Student" discriminator-value="student">

           <property name="school" type="string" column="school"></property>

       </subclass>

    </class>

</hibernate-mapping>

 

 

package com.atguigu.hibernate.subclass;

 

import java.util.List;

 

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.Transaction;

import org.hibernate.cfg.Configuration;

import org.hibernate.service.ServiceRegistry;

import org.hibernate.service.ServiceRegistryBuilder;

import org.junit.After;

import org.junit.Before;

import org.junit.Test;

 

public class HibernateTest01 {

 

private SessionFactory sessionFactory;

private Session session;

private Transaction transaction;

 

@Before

public void init(){

           Configuration conf = new Configuration().configure();

           ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(conf.getProperties()).buildServiceRegistry();

           sessionFactory = conf.buildSessionFactory(serviceRegistry);

           session = sessionFactory.openSession();

           transaction = session.beginTransaction();

}

@After

public void destroy(){

           transaction.commit();

           session.close();

           sessionFactory.close();

}

/**

 * 查询：

 * 1.查询父类记录，只需要查询一张数据表

 * 2.对于子类记录，也只需要查询一张数据表

 */

@Test

public void testQuery(){

          

           List<Person> persons = session.createQuery("FROM Person").list();

           System.out.println(persons.size());

          

           List<Student> students = session.createQuery("FROM Student").list();

           System.out.println(students.size());

 

}

/**

 * 缺点：

 * 1.使用了辨别者列

 * 2.子类独有的字段不能添加非空约束

 * 3.若继承层次较深 ，则数据表的字段也会较多

 */

 

/**

 * 插入操作：

 * 1.对于子类对象只需要把记录插入到一张数据表中。

 * 2.辨别者列 有Hibernate自动维护 。

 * Hibernate:

    insert

    into

        persons

        (name, age, type)

    values

        (?, ?, 'person')

Hibernate:

    insert

    into

        persons

        (name, age, school, type)

    values

        (?, ?, ?, 'student')

 */

@Test

public void testSave(){

           Person person = new Person();

           person.setAge(11);

           person.setName("AA");

          

           session.save(person);

          

           Student stu = new Student();

           stu.setAge(22);

           stu.setName("BB");

           stu.setSchool("ATGUIGU");

           session.save(stu);

}

}

 

 

 

 

 

 

 

 

 

 

 

package com.atguigu.hibernate.joined.subclass;

 

public class Person {

    private Integer id;

    private String name;

    private int age;

    public Integer getId() {

       return id;

    }

    public void setId(Integer id) {

       this.id = id;

    }

    public String getName() {

       return name;

    }

    public void setName(String name) {

       this.name = name;

    }

    public int getAge() {

       return age;

    }

    public void setAge(int age) {

       this.age = age;

    }

}

 

package com.atguigu.hibernate.joined.subclass;

 

public class Student extends Person{

   

    private String school;

 

    public String getSchool() {

       return school;

    }

 

    public void setSchool(String school) {

       this.school = school;

    }

}

 

 

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >

<hibernate-mapping package="com.atguigu.hibernate.joined.subclass">

    <class name="Person"  table="persons" >

       <id name="id" type="java.lang.Integer">

           <column name="id"></column>

           <generator class="native"></generator>

       </id>

 

       <property name="name" type="string">

           <column name="name"></column>

       </property>

      

       <property name="age" type="int">

           <column name="age"></column>

       </property>

      

       <joined-subclass name="Student" table="students">

           <key column="student_id"></key>

       </joined-subclass>

    </class>

</hibernate-mapping>

 

package com.atguigu.hibernate.joined.subclass;

 

import java.util.List;

 

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.Transaction;

import org.hibernate.cfg.Configuration;

import org.hibernate.service.ServiceRegistry;

import org.hibernate.service.ServiceRegistryBuilder;

import org.junit.After;

import org.junit.Before;

import org.junit.Test;

 

public class HibernateTest01 {

 

private SessionFactory sessionFactory;

private Session session;

private Transaction transaction;

 

@Before

public void init(){

           Configuration conf = new Configuration().configure();

           ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(conf.getProperties()).buildServiceRegistry();

           sessionFactory = conf.buildSessionFactory(serviceRegistry);

           session = sessionFactory.openSession();

           transaction = session.beginTransaction();

}

@After

public void destroy(){

           transaction.commit();

           session.close();

           sessionFactory.close();

}

 

/**

 * 优点：

 * 1.不需要使用辨别者列

 * 2.子类独有的字段能添加非空约束

 * 3.没有冗余的字段

 */

 

 

/**

 * 查询：

 * 1.查询父类记录，做一个左外链接查询

 * 2.对于子类记录，做一个内连接查询

 *

 */

@Test

public void testQuery(){

          

           List<Person> persons = session.createQuery("FROM Person").list();

           System.out.println(persons.size());

          

           List<Student> students = session.createQuery("FROM Student").list();

           System.out.println(students.size());

 

}

 

/**

 * 插入操作：

 * 对于子类对象至少需要插入到两张数据表中。

 */

@Test

public void testSave(){

           Person person = new Person();

           person.setAge(11);

           person.setName("AA");

          

           session.save(person);

          

           Student stu = new Student();

           stu.setAge(22);

           stu.setName("BB");

           stu.setSchool("ATGUIGU");

           session.save(stu);

}

}

 

 

 

 

 

 

 

 

Union-subclass

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >

<hibernate-mapping package="com.atguigu.hibernate.union.subclass">

    <class name="Person"  table="persons" >

   

       <id name="id" type="java.lang.Integer">

           <column name="id"></column>

           <generator class="hilo"></generator>

       </id>

      

       <property name="name" type="string">

           <column name="name"></column>

       </property>

       <property name="age" type="int">

           <column name="age"></column>

       </property>

      

       <union-subclass name="Student" table="students">

           <property name="school" column="school" type="string"></property>

       </union-subclass>

    </class>

</hibernate-mapping>

 

 

package com.atguigu.hibernate.union.subclass;

 

import java.util.List;

 

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.Transaction;

import org.hibernate.cfg.Configuration;

import org.hibernate.service.ServiceRegistry;

import org.hibernate.service.ServiceRegistryBuilder;

import org.junit.After;

import org.junit.Before;

import org.junit.Test;

 

public class HibernateTest01 {

 

private SessionFactory sessionFactory;

private Session session;

private Transaction transaction;

 

@Before

public void init(){

           Configuration conf = new Configuration().configure();

           ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(conf.getProperties()).buildServiceRegistry();

           sessionFactory = conf.buildSessionFactory(serviceRegistry);

           session = sessionFactory.openSession();

           transaction = session.beginTransaction();

}

@After

public void destroy(){

           transaction.commit();

           session.close();

           sessionFactory.close();

}

@Test

public void testUpdate(){

           String hql = "UPDATE Person p SET p.age=20";

           session.createQuery(hql).executeUpdate();

}

 

/**

 * 优点：

 * 1.无需使用辨别者列

 * 2.子类独有的字段能添加非空约束。

 *

 * 缺点：

 * 1.存在冗余的字段

 * 2.若更新父表的字段，更新的效率较低 。

 */

 

 

/**

 * 查询：

 * 1.查询父类记录，需把父表和子表记录汇总到一起再做查询，性能较差。

 * 2.对于子类记录，只需要查询一张数据表

 *

 */

@Test

public void testQuery(){

          

           List<Person> persons = session.createQuery("FROM Person").list();

           System.out.println(persons.size());

          

           List<Student> students = session.createQuery("FROM Student").list();

           System.out.println(students.size());

 

}

 

/**

 * 插入操作：

 * 插入性能还不错

 */

@Test

public void testSave(){

           Person person = new Person();

           person.setAge(11);

           person.setName("AA");

          

           session.save(person);

          

           Student stu = new Student();

           stu.setAge(22);

           stu.setName("BB");

           stu.setSchool("ATGUIGU");

           session.save(stu);

}

}