基于mvc模式的应用框架之Hibernate(六)

一、一对一映射

需求: 用户与身份证信息

一条用户记录对应一条身份证信息！ 一对一的关系！

设计数据库：

JavaBean：

映射：

1.基于外键的映射

// 身份证
public class IdCard
{
// 身份证号(主键)
private String cardNum;// 对象唯一表示(Object Identified, OID)
private String place; //  身份证地址
// 身份证与用户，一对一的关系
private User user;
}

// 用户
public class User
{
private int userId;
private String userName;
// 用户与身份证信息， 一对一关系
private IdCard idCard;
}

<?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.itcast.c_one2one">
<class name="IdCard" table="t_IdCard">
<id name="cardNum">
<generator class="assigned"></generator>
</id>
<property name="place" length="20"></property>
<!--
一对一映射，有外键方
unique="true"   给外键字段添加唯一约束
-->
<many-to-one name="user" unique="true" column="user_id" class="User" cascade="save-update"></many-to-one>
</class>
</hibernate-mapping>

<?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.itcast.c_one2one">
<class name="User" table="t_user">
<id name="userId">
<generator class="native"></generator>
</id>
<property name="userName" length="20"></property>
<!--
一对一映射： 没有外键方
-->
<one-to-one name="idCard" class="IdCard"></one-to-one>
</class>
</hibernate-mapping>

2.基于主键的映射

// 身份证
public class IdCard
{
private int user_id;
// 身份证号
private String cardNum;
private String place; //  身份证地址
// 身份证与用户，一对一的关系
private User user;
}

<?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.itcast.c_one2one2">

<class name="IdCard" table="t_IdCard">
<id name="user_id">
<!--
id 节点指定的是主键映射, 即user_id是主键
主键生成方式： foreign  即把别的表的主键作为当前表的主键；
property (关键字不能修改)指定引用的对象     对象的全名 cn..User、  对象映射 cn.User.hbm.xml、   table(id)
-->
<generator class="foreign">
<param name="property">user</param>
</generator>
</id>
<property name="cardNum" length="20"></property>
<property name="place" length="20"></property>

<!--
一对一映射，有外键方
（基于主键的映射）
constrained="true"  指定在主键上添加外键约束
-->
<one-to-one name="user" class="User" constrained="true"  cascade="save-update"></one-to-one>
</class>
</hibernate-mapping>

二、组件映射

类的关系

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

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

需求： 汽车与车轮

数据库

T_car

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

Javabean：

public class Car {

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

private int count;
private int size;
}
<hibernate-mapping package="cn.itcast.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>

三.继承映射

需求：动物

猫

猴子

1.简单继承映射

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

<hibernate-mapping package="cn.itcast.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.itcast.e_extends1.Animal");
List<Animal> list = q.list();
System.out.println(list);

session.getTransaction().commit();
session.close();

}

总结：

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

继承映射

需求：猫、猴子、动物。

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

什么情况用？

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

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

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

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

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

数据库:

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

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

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

2 大花猫 不抓老鼠 NULL 猫

总结：

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

但数据库设计不合理!

（不推荐用。）

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

数据库

T_anmal （存储父类信息）

1 大花猫

T_cat （引用父类的主键）

1 抓小老鼠

T_monkey（引用父类的主键）

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

<!--
继承映射， 每个类对应一张表(父类也对应表)
-->
<hibernate-mapping package="cn.itcast.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： 往父类插入、往子类插入！

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

数据库：

T_cat

Id name catchMounse

T_monkey

Id name eatBanana

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

注意：主键不能是自增长！

总结：

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

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

四.Hibernate中映射：

多对一
一对多
多对多
一对一  （多对一的特殊应用）
组件
继承