【Hibernate】组件映射与继承映射

一、类的关系

组合关系

一个类中包含了另外一个类。这2个类中就是组合关系。

需求： 汽车与车轮

继承关系

一个类继承另外一个类。这2个类中就是继承关系。

需求：动物

猫

猴子

二、组件映射

类组合关系的映射，也叫做组件映射！

注意：组件类和被包含的组件类，共同映射到一张表！

需求： 汽车与车轮

数据库

T_car

主键   汽车名称  轮子大小  个数

Javabean：

public class Car {
 
private int id;
private String name;
// 车轮
private Wheel wheel;
}

// 车轮
public class Wheel {
 
private int count;
private int size;
}

Car.hbm.xml

<hibernate-mapping package="cn.lfsenior.d_component">
<class name="Car" table="t_car">
<id name="id">
<generator class="native"></generator>
</id>
<property name="name" length="20"></property>
<!-- 组件映射 -->
<component name="wheel">
<property name="size"></property>
<property name="count"></property>
</component>
 
</class>
 
</hibernate-mapping>
 

三、继承映射 

需求：动物

猫

猴子

四、简单继承映射

// 动物类
public abstract class Animal {
 
private int id;
private String name;

<!--
简单继承
 -->
<hibernate-mapping package="cn.lfsenior.e_extends1">
<class name="Cat" table="t_Cat">
<!-- 简单继承映射： 父类属性直接写 -->
<id name="id">
<generator class="native"></generator>
</id>
<property name="na"></property>
<property name="catchMouse"></property>	 
</class>
 
</hibernate-mapping>

@Test
public void getSave() {
Session session = sf.openSession();
session.beginTransaction();
// 保存
//Cat cat = new Cat();
//cat.setName("大花猫");
//cat.setCatchMouse("抓小老鼠");
//session.save(cat);
// 获取时候注意：当写hql查询的使用，通过父类查询必须写上类的全名
Query q = session.createQuery("from cn.lfsenior.e_extends1.Animal");
List<Animal> list = q.list();
System.out.println(list);
session.getTransaction().commit();
session.close();
}

总结：

简单继承映射，有多少个子类，写多少个映射文件！

五、复杂继承映射

需求：猫、猴子、动物。

A、所有子类映射到一张表 (1张表)

Animal.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 
<!--
继承映射， 所有的子类都映射到一张表
 -->
<hibernate-mapping package="cn.lfsenior.e_extends2">
<class name="Animal" table="t_animal">
<id name="id">
<generator class="native"></generator>
</id>
<!-- 指定鉴别器字段(区分不同的子类) -->
<discriminator column="type_"></discriminator>
<property name="name"></property>
<!--
子类：猫
每个子类都用subclass节点映射
注意：一定要指定鉴别器字段，否则报错！
鉴别器字段：作用是在数据库中区别每一个子类的信息， 就是一个列
discriminator-value="cat_"
指定鉴别器字段,即type_字段的值
如果不指定，默认为当前子类的全名
 -->
 <subclass name="Cat" discriminator-value="cat_">
 	<property name="catchMouse"></property>
 </subclass>
 
 <!--
 	子类：猴子
  -->
  <subclass name="Monkey" discriminator-value="monkey_">
  	<property name="eatBanana"></property>
  </subclass>
</class>
 
</hibernate-mapping>
 

A1、什么情况用？

子类教多，且子类较为简单，即只有个别属性！

好处：因为使用一个映射文件， 减少了映射文件的个数。

缺点：（不符合数据库设计原则）

一个映射文件： Animal.hbm.xml

(如何区分是哪个子类的信息？)

A2、数据库:

T_animal （要存储所有的子类信息）                 “鉴别器”

Id   name     catchMouse      eatBanana   type_(区别是哪个子类)

         1   大马猴       NULL        吃10个香蕉     猴子

 2   大花猫     不抓老鼠         NULL          猫

A3、总结：

写法较为简单：所有子类用一个映射文件，且映射到一张表！

但数据库设计不合理!

（不推荐用。）

B、每个类映射一张表(3张表)

数据库

  T_anmal （存储父类信息）

1   大花猫

  T_cat （引用父类的主键）

     1  抓小老鼠

T_monkey（引用父类的主键）

 Javabean设计一样，映射实现不同：

 
<!--
继承映射， 每个类对应一张表(父类也对应表)
 -->
<hibernate-mapping package="cn.lfsenior.e_extends3">
<class name="Animal" table="t_animal">
<id name="id">
<generator class="native"></generator>
</id>
<property name="name"></property>
<!--
子类：猫  t_cat
key 指定_cat表的外键字段
-->
<joined-subclass name="Cat" table="t_cat">
<key column="t_animal_id"></key>
<property name="catchMouse"></property>
</joined-subclass>
<!-- 子类：猴子  t_monkey -->
<joined-subclass name="Monkey" table="t_monkey">
<key column="t_animal_id"></key>
<property name="eatBanana"></property>
</joined-subclass>
</class>
 
</hibernate-mapping>
 

总结：

一个映射文件，存储所有的子类； 子类父类都对应表；

   缺点：表结构比较复杂，插入一条子类信息，需要用2条sql： 往父类插入、往子类插入！

C、(推荐)每个子类映射一张表， 父类不对应表(2张表)

数据库：

T_cat

Id   name   catchMounse

T_monkey

Id    name   eatBanana

<union-subclass name="Cat" table="t_cat">
<property name="catchMouse"></property>
</union-subclass>

Animal.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 
<!--
继承映射， 每个类对应一张表(父类不对应表)
 -->
<hibernate-mapping package="cn.lfsenior.e_extends4">
<!--
 abstract="true"  指定实体类对象不对应表，即在数据库段不生成表
 -->
<class name="Animal" abstract="true">
<!-- 如果用union-subclass节点，主键生成策略不能为自增长！ -->
<id name="id">
<generator class="uuid"></generator>
</id>
<property name="name"></property>
<!--
子类：猫  t_cat
union-subclass  
table 指定为表名, 表的主键即为id列
-->
<union-subclass name="Cat" table="t_cat">
<property name="catchMouse"></property>
</union-subclass>
<!-- 子类：猴子  t_monkey -->
<union-subclass name="Monkey" table="t_monkey">
<property name="eatBanana"></property>
</union-subclass>
</class>
 
</hibernate-mapping>

总结： 

所有的子类都写到一个映射文件；

父类不对应表； 每个子类对应一张表