1. 多对多关联：
在双方都要用一个类型为Set的属性保存对方的信息，并在映射配置文件中指定这个属性的名字，并指定中间表。还需要通过<key column=””>来指定自己在中间表中对应的外键。在<many-to-many>标签中，要配置对方的类，并且指定对方类在中间表中的对应的外键
*学生表配置文件：
<class name="edu.whu.swe.lxl.learn.hibernate.model.stucourse.Student" table="student" schema="dbforlearn">
<id name="id" column="id" >
<generator class="native"/>
</id>
<property name="num" column="num"/>
<property name="name" column="name"/>
<!--配置set集合描述类Student中的courses属性和中间表信息-->
<set name="courses" table="stu_course" >
<!--设置本类在连接表中对应的外键-->
<key column="student"/>
<!--配置关联类以及关联类在中间表中的外键-->
<many-to-many class="edu.whu.swe.lxl.learn.hibernate.model.stucourse.Course"
column="course"/>
</set>
</class>
*课程表的映射文件：
<class name="edu.whu.swe.lxl.learn.hibernate.model.stucourse.Course" table="course" schema="dbforlearn">
<id name="id" column="id">
<generator class="native"
</id>
<property name="num" column="num"/>
<property name="name" column="name"/>
<!--配置关联类在本类中对应的属性以及中间表-->
<set name="students" table="stu_course">
<!--设置本类在连接表中对应的外键-->
<key column="course"/>
<!--配置关联类以及关联类在中间表中对应的外键-->
<many-to-many class="edu.whu.swe.lxl.learn.hibernate.model.stucourse.Student"
column="student"/>
</set>
</class>
*一般在多对多关系中，不存在级联删除的需求。在多对多中，千万不要加入cascade=delete，否则会是灾难性的。
2.查询
1）唯一标识OID的检索方式（重要）
Session.get(obj.class,OID)
2) 对象的导航方式（重要）
一对多查询时，利用里面包含的set
3）HQL的检索方式（重要）
Hibernate Query Language ——hibernate的查询语言
4）QBC的检索方式（重要）
Query By Criteria ——条件查询
5）SQL查询
3.HQL查询
* HQL是面向java对象的，和SQL有相似之处
*是hibernate中使用最广泛的检索方式
*hibernate负责解析HQL，然后根据ORM配置的映射关系，生成相应的SQL语句
*HQL操作的是类以及属性，而不是数据表和字段
4.延迟加载技术——在class标签上配置
1）延迟加载先获取到代理对象，当真正使用到该对象中的属性且缓存里没有值时，才会发送SQL语句，是hibernate框架提升性能的主要方式。
2）类级别的延迟加载
*Session对象的load方法默认就是延迟加载
*Customer c=session.load(Customer.class,1L)，没有发送SQL语句，当使用该对象的属性时，才发送SQL语句
【实例】
/**
<class name="edu.whu.swe.lxl.learn.hibernate.model.Customer" table="customer" >
<id name="id" column="id">
<generator class="identity"/>
</id>
<property name="name" column="name"/>
<property name="address" column="address"/>
<property name="age" column="age"/>
<property name="registerDate" column="register_date"/>
</class> */
public void testLoad(){
Customer customer = session.load(Customer.class, 3);
log.trace(customer.getId().toString());//没有发送SQL，因为ID已经由代码提供了，此时开始变成持久态
log.trace("+++++++++++++++++");
log.trace(customer.getName());//发送SQL语句，因为此时缓存里没有name信息，必须要发送SQL从数据库中查询
}
*使类级别的延迟加载失效：
**在<class>标签上配置lazy=”false”
**Hibernate.initialize(Object proxy)
【实例】
/**
<class name="edu.whu.swe.lxl.learn.hibernate.model.Customer" table="customer" lazy="false">
<id name="id" column="id">
<generator class="identity"/>
</id>
<property name="name" column="name"/>
<property name="address" column="address"/>
<property name="age" column="age"/>
<property name="registerDate" column="register_date"/>
</class>
*/
@Test
public void testLoadNotLazy() {
Customer customer = session.load(Customer.class, 3);
log.trace(customer.getId().toString());//没有发送SQL，因为ID已经由代码提供了，此时开始变成持久态
log.trace("+++++++++++++++++");
log.trace(customer.getName());//发送SQL语句，因为此时缓存里没有name信息，必须要发送SQL从数据库中查询
}
3）关联级别的延迟加载。
* CustCustomer customer=session.get(CustCustomer.class,1L)不是延迟加载，但是它不会把代理类CustCustomer的关联类CstLinkman加载进来，当使用CstLinkman linkmans=customer.getLinkmans()获取关联类对象的时候，因为没有用到CstLinkman的任何属性，也不需要知道有几个linkman，所以还是不会加载。直到使用了linkmans里的属性时，才会发送SQL加载关联类对象。
【实例】
/**
* <set name="linkMans" cascade="delete-orphan" inverse="true">
<!--外键-->
<key column="lkm_cust_id"/>
<!--对应关系-->
<one-to-many class="edu.whu.swe.lxl.learn.hibernate.model.CstLinkman" />
</set>
*/
CustCustomer customer = session.get(CustCustomer.class, 19L);//直接发送SQL查询CustCustomer，但不查询CstLinkman
log.trace(customer.getCustId().toString());//
log.trace("++++++++++++++++++++++++++");
Set linkmans=customer.getLinkMans();//还是不发送SQL，因为还没有必要查询CstLinkman的属性
log.trace("++++++++++++++++++++++++++");
log.trace(""+linkmans.size());//这个时候发送SQL，因为不发送，就不知道有几个linkman了。
5.延迟加载技术——在set标签上配置策略
1）在<set>标签上使用fetch和lazy属性
*fetch的取值 ——控制SQL语句的生成格式
** select ——默认值，发送查询语句
**join ——连接查询，发送的是一条左外链接查询，此时，关联表延迟加载失效（因为不需要再发起一次SQL查询关联表了，而是在一次外链接查询中完成了所有表的加载）
**subselect ——子查询，发送一条子查询完成关联对象的查询。（需要使用list()方法进行测试，如Criteria.list()或者Query.list()）
*lazy的取值 ——查询关联对象的时候是否采用延迟加载
**true ——默认，延迟
**false ——不延迟
**extra ——极其懒惰，根据需要查询，而不是查询所有字段，比如用一写聚合函数，或者只查询某一个字段
一般都采用默认值即可
【示例】
*fetch=”join”
public void testJoinSet(){
/**
<set name="linkMans" cascade="delete-orphan" inverse="true" fetch="join>
<!--外键-->
<key column="lkm_cust_id"/>
<!--对应关系-->
<one-to-many class="edu.whu.swe.lxl.learn.hibernate.model.CstLinkman" />
</set>
*/
CustCustomer customer = session.get(CustCustomer.class, 19L);//直接发送join SQL 左外连接查询，一次性获取所有的数据
log.trace(customer.getCustId().toString());
log.trace("++++++++++++++++++++++++++");
}
*fetch=”select” lazy=”extra”
@Test
public void testExtraLazy() {
/**
<set name="linkMans" cascade="delete-orphan" inverse="true" fetch="select" lazy="extra">
<!--外键-->
<key column="lkm_cust_id"/>
<!--对应关系-->
<one-to-many class="edu.whu.swe.lxl.learn.hibernate.model.CstLinkman" />
</set>
*/
CustCustomer customer = session.get(CustCustomer.class, 19L);//直接发送SQL查询CustCustomer，但不查询CstLinkman
log.trace(customer.getCustId().toString());//
log.trace("++++++++++++++++++++++++++");
Set linkmans = customer.getLinkMans();//还是不发送SQL，因为还没有必要查询CstLinkman的属性
log.trace("++++++++++++++++++++++++++");
log.trace("" + linkmans.size());//发送select count(lkm_id) form cst_linkman where lkm_cust_id=?,而不是查询所有字段
}
*fatch=”subselect”
public void testSubselectSet() {
/**
<set name="linkMans" cascade="delete-orphan" inverse="true" fetch="subselect">
<!--外键-->
<key column="lkm_cust_id"/>
<!--对应关系-->
<one-to-many class="edu.whu.swe.lxl.learn.hibernate.model.CstLinkman" />
</set>
*/
Query query = session.createQuery("from CustCustomer ");
List<CustCustomer> customers = query.list();//发送SQL查询CustCustomer，但不查询CstLinkman
log.trace("++++++++++++++++++++++++++++++++++");
for(CustCustomer customer:customers){
Set linkmans
= customer.getLinkMans();//不发送SQL
log.trace("++++++++++++++++++++++++++++++++++");
log.trace(""+linkmans.size());//在第一次循环时候，就发送子查询把List所有中所有用户的所有联系人都一次性查询出来，下次循环就不用发送SQL了。如果不适用subselect，那么循环一次，就发送一次SQL查询该客户的联系人
}
}
6.优化技术——在<many-to-one>标签中配置策略
1）在<many-to-one>标签上使用fetch和lazy属性
*fetch的取值 ——控制SQL语句的格式
**select ——默认，发送基本的select语句查询
**join ——无效，所以fetch只能是select，所以不用设置fetch
*lazy的取值
**false ——不采用延迟加载
**proxy ——默认值，是否延迟加载取决于一方set 标签的lazy取值，多方和一方的lazy值一样。
7.当fetch=select，lazy=true的时候，使用list时，对从表的查询是一次循环获取进行一次的，此时如果不想设置subselect进行子查询，那么可以设置set标签的batch-size=10，从而达到批量获取从表数据的目的。当设置batch-size=10时，hibernate会一次就取10个客户的联系人。具体工作原理这样的：
1）先获取所有的客户
2）再用select xxx xxx xxx from cst_linkman where cst_linkman.lkm_cust_id in( 10个客户的id )批量获取10个客户的联系人。
总结：session.load采取的是类级别的延迟加载，并且在class标签上配置当前类的延迟加载策略；session.get采取的是连接上的延迟加载，并且在set标签上配置加载策略，在many-to-one上也可以进行配置。
8.延迟加载策略的优缺点及适用范围：
1）有点
有应用程序决定要加载哪些对象，可以避免执行多余的SQL语句，避免加载不程序不会访问的对象，提高性能和空间利用率。
2）缺点
应用程序如果试图访问处于游离态的代理类实例，必须保证它在持久化状态是已经被初始化了。而延迟加载策略往往导致代理类实例相应的set没有值，从而需要把游离态对象通过session.update方法变成持久态，再去访问set中的对象从而加载对象。
3）适用范围
——一对多或者多对多
——应用程序不需要立即访问或者根本不需要访问的对象。
9.在配置文件中配置的加载策略影响全局，但是应用程序的需求可能是多样的，在不同的时候需要不同的加载策略，因此，hibernate提供了在应用程序中指定加载策略的方式，应用程序中指定的加载方式将覆盖配置文件中的加载方式（局部优先于整体原则）
10.一对一的加载默认是使用左外连接查询。