原创播客，如需转载请注明出处。原文地址：http://www.cnblogs.com/crawl/p/7680415.html
五、映射一对多关联关系
1. 单向多对一 即 单向 n-1
1）单向 n-1 关联只需从 n 的一端可以访问 1 的一端
① 域模型: 从 Order 到 Customer 的多对一单向关联需要在Order 类中定义一个 Customer 属性, 而在 Customer 类中无需定义存放 Order 对象的集合属性
② 关系数据模型:ORDERS 表中的 CUSTOMER_ID 参照 CUSTOMER 表的主键 （多的那一端的数据表需要加上 s，否则建表不成功）
2）使用 many-to-one 映射
3）测试多对一 映射
① save() 保存
② get() 查询
③ update() 修改 和 删除
2、双向一对多 即 双向1-n
1）双向 1-n 与 双向 n-1 是完全相同的两种情形
2）域模型:从 Order 到 Customer 的多对一双向关联需要在Order 类中定义一个 Customer 属性, 而在 Customer 类中需定义存放 Order 对象的集合属性
3）需要在 1 的一端即 Customer 中添加 n 的一端（Order）的集合关系，并注意
4）测试双向多对一映射
① save() 保存操作
> 映射：n（Order）这一端需要进行常规的多对一映射；在 1（Customer）这 一端使用 set 节点映射：
其中：inverse 属性：
inverse = false 的为主动方，inverse = true 的为被动方, 由主动方负责维护关联关系，在没有设置 inverse=true 的情况下，父子两边都维护父子关系
> 测试：
② get() 获取操作
> 测试
③ update() 操作 常规操作
六、映射一对一关联关系
1. 一对一关联关系
1）理解：一个部门只有一个部门经理，一个部门经理管理一个部门
2）域模型：Department 中有 Manager 的引用，Manager 中也有 Department 的引用
3） ① 基于外键映射的 1 - 1
> 对于基于外键的1-1关联，其外键可以存放在任意一边，在需要存放外键一端，增加many-to-one元素。为many-to-one元素增加 unique=“true” 属性来表示为1-1关联, 如下：
> 另一端需要使用one-to-one元素，该元素使用 property-ref 属性指定使用被关联实体主键以外的字段作为关联字段
> 测试：
save() 保存：
get() 获取：
② 基于主键映射的 1 -1
> 指一端的主键生成器使用 foreign 策略,表明根据”对方”的主键来生成自己的主键，自己并不能独立生成主键. <param> 子元素指定使用当前持久化类的哪个属性作为 “对方”
> 采用foreign主键生成器策略的一端增加 one-to-one 元素映射关联属性，其one-to-one属性还应增加 constrained=“true” 属性；另一端增加one-to-one元素映射关联属性
注：constrained(约束):指定为当前持久化类对应的数据库表的主键添加一个外键约束，引用被关联的对象(“对方”)所对应的数据库表主键
> 测试：
save() :
get() 获取：
七、映射多对多的关联关系
1.单向多对多：
1) 域模型：Category （类别） 和 Item （商品） 之间的关系模型，只在 Category 类中定义 Set<Item>，即单向 n-n 关联只需一端使用集合属性
2) n-n 的关联必须使用连接表 CATEGORIES_ITEMS
3)与 1-n 映射类似，必须为 set 集合元素添加 key 子元素，指定CATEGORIES_ITEMS 表中参照 CATEGORIES 表的外键为 C_ID. 与 1-n 关联映射不同的是，建立 n-n 关联时, 集合中的元素使用 many-to-many. many-to-many 子元素的 class 属性指定 items 集合中存放的是 Item 对象, column 属性指定 CATEGORIES_ITEMS 表中参照 ITEMS 表的外键为 I_ID
4) 单向多对多的测试，get() 方法会连接中间表查询
2.双向多对多
1) 域模型：Category （类别） 和 Item （商品） 之间的关系模型，在 Category 类中定义 Set<Item>，在 Item 类中定义 Set<Category>,即
双向 n-n 关联需要两端都使用集合属性
2）双向n-n关联必须使用连接表
3）在双向 n-n 关联的两边都需指定连接表的表名及外键列的列名. 两个集合元素 set 的 table 元素的值必须指定，而且必须相同。set元素的两个子元素：key 和 many-to-many 都必须指定 column 属性，其中，key 和 many-to-many 分别指定本持久化类和关联类在连接表中的外键列名，因此两边的 key 与 many-to-many 的column属性交叉相同
> Category.hbm.xml 中的 Set 节点的配置：
> Item.hbm.xml 中的 Set 节点的配置：
注：对于双向 n-n 关联, 必须把其中一端的 inverse 设置为 true, 否则两端都维护关联关系可能会造成主键冲突.即：
八、映射继承关系（了解，开发中使用很少）
1.使用 subclass 进行映射：
1）采用 subclass 的继承映射可以实现对于继承关系中父类和子类使用同一张表
2）因为父类和子类的实例全部保存在同一个表中，因此需要在该表内增加一列，使用该列来区分每行记录到低是哪个类的实例----这个列被称为辨别者列(discriminator).
3）在这种映射策略下，使用 subclass 来映射子类，使用 class 和 subclass 的 discriminator-value 属性指定辨别者列的值
4）所有子类定义的字段都不能有非空约束。如果为那些字段添加非空约束，那么父类的实例在那些列其实并没有值，这将引起数据库完整性冲突，导致父类的实例无法保存到数据库中
5）具体配置：只生成 父类的 .hbm.xml 文件即可，在此配置文件中对子类进行映射
6）测试：
save():
查询操作：
7）使用 subclass 进行映射的缺点：
> 使用了 辨别者列
> 子类独有的字段不能添加非空约束
> 若继承层次较深，则数据表的字段也会较多
2.使用 joined-subclass 进行映射
1）采用 joined-subclass 元素的继承映射可以实现每个子类一张表
2）采用这种映射策略时，父类实例保存在父类表中，子类实例由父类表和子类表共同存储。因为子类实例也是一个特殊的父类实例，因此必然也包含了父类实例的属性。于是将子类和父类共有的属性保存在父类表中，子类增加的属性，则保存在子类表中。
3）在这种映射策略下，无须使用鉴别者列，但需要为每个子类使用 key 元素映射共有主键。
4）子类增加的属性可以添加非空约束。因为子类的属性和父类的属性没有保存在同一个表中
5）具体映射：只生成 父类的 .hbm.xml 文件即可，在此配置文件中对子类进行映射
6）测试
save() 操作：
query() 查询操作：
7）优点：
> 不需要使用辨别者列
>子类独有的字段能添加非空约束
>没有冗余的字段
3.使用 union-subclass 进行映射
1）采用 union-subclass 元素可以实现将每一个实体对象映射到一个独立的表中。
2）子类增加的属性可以有非空约束 --- 即父类实例的数据保存在父表中，而子类实例的数据保存在子类表中。
3）子类实例的数据仅保存在子类表中, 而在父类表中没有任何记录
4）在这种映射策略下，子类表的字段会比父类表的映射字段要多,因为子类表的字段等于父类表的字段、加子类增加属性的总和
5）在这种映射策略下，既不需要使用鉴别者列，也无须使用 key 元素来映射共有主键.
6）使用 union-subclass 映射策略是不可使用 identity 的主键生成策略
7）具体映射：只生成 父类的 .hbm.xml 文件即可，在此配置文件中对子类进行映射，如下：
8）测试：
save() : 插入效率还可以，对于子类对象，只需把记录插入到自己的一张表中
query()：查询父类记录，需把父表和子表记录汇总到一起再做查询，性能稍差
9）优点：
> 不需要使用辨别者列
>子类独有的字段能添加非空约束
缺点：
> 存在冗余的字段
>若更新父表的字段，则更新的效率较低
九、Hibernate 的检索策略
1.类级别的检索策略，仅适用于 session 的 load() 方法
1）分为 立即检索（立即加载检索方法指定的对象） 和 延迟检索（延迟加载检索方法指定的对象，在使用具体的非 id 属性时再进行加载）
2）类级别的检索策略可以通过 <class> 元素的 lazy 属性进行设置
3）如果程序加载一个对象的目的是为了访问它的属性, 可以采取立即检索.
4）如果程序加载一个持久化对象的目的是仅仅为了获得它的引用, 可以采用延迟检索。注意出现懒加载异常！
5）注：①无论 <class> 元素的 lazy 属性是 true 还是 false, Session 的 get() 方法及 Query 的 list() 方法在类级别总是使用立即检索策略
②若 <class> 元素的 lazy 属性为 true 或取默认值(true), Session 的 load() 方法不会执行查询数据表的 SELECT 语句, 仅返回代理类对象的实例, 该代理类实例有如下特征:
–由 Hibernate 在运行时采用 CGLIB 工具动态生成
–Hibernate 创建代理类实例时, 仅初始化其 OID 属性
–在应用程序第一次访问代理类实例的非 OID 属性时, Hibernate 会初始化代理类实例
6）测试：
2.一对多和多对多的检索策略
1）Set 节点的 lazy 属性
2）Set 节点的 batch-size 属性
3）Set 节点的 fetch 属性
3.多对一 和 一对一 关联检索策略
1）many-to-one 节点的 lazy 属性，设置是否延迟检索，默认为 proxy，为延迟检索，可取值： proxy false
2）lazy fetch batch-size 属性的使用如下：
十、Hibernate 的检索方式（使用 Oracle 数据库，在数据库中建立了my_department 和 my_employee 两张数据表，并导入了数据）
重点学习：
1. HQL（Hibernate Query Language） 检索方式：使用面向对象的 HQL 查询语言
2.HQL查询的 HelloWorld：
3.HQL 的分页查询
两个方法：
1）setFirstResult(int firstResult) :设置开始检索的位置，参数 firstResult 表示这个对象在查询结果中的索引位置
2）setMaxResults(int maxResults):设置一次检索多少个，即一页显示多少条记录
4.HQL 的命名查询：特点是可以把 hql 语句配置在 .hbm.xml 文件中
1）在 Employee.hbm.xml 文件中定义<query> 节点，用于定义一个 HQL 查询语句, 它和 <class> 元素并列
5.HQL 的投影查询：查询结果仅包含实体的部分属性. 通过 SELECT 关键字实现.
1）注：Query 的 list() 方法返回的集合中包含的是数组类型的元素, 每个对象数组代表查询结果的一条记录
2）上面的方式不方便使用，使用下面的方式可以返回一个对象的集合，方便使用
注：在 hql 语句中使用了 Employee 的构造器，所以在 Employee 类中必须定义一个同样的构造器
6.HQL 的报表查询：即在 HQL 语句中可以使用 GROUP BY 或 HAVING 或 min() 或 max() 或 sum() 或 count() 等聚集函数
补：使用 HQL 可以实现删除操作：
7.HQL 的左外连接 和 迫切左外连接
1）迫切左外连接（尽量使用迫切左外连接）
①LEFT JOIN FETCH 关键字表示迫切左外连接检索策略
②list() 方法返回的集合中存放实体对象的引用, 每个 Department 对象关联的 Employee 集合都被初始化, 存放所有关联的 Employee 的实体对象.
2）左外连接
①LEFT JOIN 关键字表示左外连接查询
②list 方法返回的集合中存放的是对象数组类型，如果希望 list 集合中仅包含 Department 对象，可以在 HQL 查询语句中使用 SELECT 关键字
8.QBC(Query By Criteria)查询和本地 SQL查询 Criteria：标准 条件
1）QBC 查询的 HelloWorld:
2)带有 AND 和 OR 关键字的 QBC 查询
3）QBC 的统计查询
4）使用 QBC 进行排序和分页
注：关于 QBC 查询的更多实例可查看 Hibernate 的示例文档：
hibernate-release-4.3.11.Final\documentation\manual\en-US\html_single\index.html#querycriteria
5）本地 SQL 查询
十一、Hibernate 的二级缓存
SessionFactory 级别的缓存
1. 配置 Hibernate类级别的二级缓存：
> 加入 EHCache 的三个 jar 包 hibernate-release-4.2.4.Final\lib\optional\ehcache 目录下
> 加入 EHCache 的配置文件 hibernate-release-4.2.4.Final\project\etc 目录下，放到 src 目录下
> 在 Hibernate.cfg.xml 中 启用二级缓存 配置使用二级缓存的产品 设置对哪一个类使用二级缓存
> 注：还可以在 对应类的 .hbm.xml 文件中使用 cache 节点配置使用缓存的策略，而省略在 Hibernate.cfg.xml 中设置对哪一个类使用二级缓存
2.配置 Hibernate 集合级别的二级缓存：
> 配置对集合使用二级缓存：注：还需要对集合中元素对应的持久化类也使用二级缓存，否则会多出 n 条 SQL 语句
注：也可以在 .hbm.xml 中配置，注意集合的二级缓存在 Set 节点中配置
3.详解 ehcache.xml 配置文件：
4.查询缓存：默认情况下, 设置的缓存对 HQL 及 QBC 查询时无效的, 但可以通过以下方式使其是有效的
注：查询缓存依赖于二级缓存
> 在 hibernate 配置文件中声明开启查询缓存
> 调用 Query 或 Criteria 的 setCacheable(true) 方法
5.管理 Session ，使 Session 的生命周期和本地线程绑定
步骤（用于测试）：
1）在 Hibernate.cfg.xml 文件中配置管理 Session 的方式
2）构建一个 HibernateUtils 类，用于获取与当前线程绑定的 Session
public class HibernateUtils { //单例 private HibernateUtils() {}
private static HibernateUtils instance = new HibernateUtils();
public static HibernateUtils getInstance() { return instance; }
private SessionFactory sessionFactory;
//获取 Session 对象的方法 public Session getSession() { return getSessionFactory().getCurrentSession(); }
//获取 SessionFactory 对象的方法 public SessionFactory getSessionFactory() { if(sessionFactory == null) { Configuration configuration = new Configuration().configure(); ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(configuration.getProperties()).buildServiceRegistry(); sessionFactory = configuration.buildSessionFactory(serviceRegistry); } return sessionFactory; }
}
3）构建一个 DepartmentDao 类
public class DepartmentDao { public void save(Department dept) { /** * 内部获取 Session 对象，获取和当前线程绑定的 Session 对象 * 优点： 1.不需要从外部传入 Session对象 * 2. 多个 DAO 方法可以使用一个事务 */ Session session = HibernateUtils.getInstance().getSession(); System.out.println(session.hashCode()); session.save(dept); } /** * 若需要传入一个 Session 对象, 则意味着上一层(Service)需要获取到 Session 对象. * 这说明上一层需要和 Hibernate 的 API 紧密耦合. 所以不推荐使用此种方式. */ public void save(Session session, Department dept) { session.save(dept); } }
4）测试：
6、建议使用原生的 JDBC 的API 进行批量操作
