hibernate相关知识

hibernate多对一关联映射
关联映射的本质：将关联关系映射到数据库，关联关系在对象模型域中体现为一个或多个引用

<many-to-one>标签会在“多”的一端添加一个外键，指向“一”的一端，这个外键是由<many-to-one>
中的column的属性定义的，如果忽略这个属性，默认创建的外键与实体类的属性名相同

<many-to-one>定义示例：
* <many-to-one name="group" column="groupid"/>

理解cascade
* 是对象之间的连锁操作（只对增删改起作用）
hibernate一对一主键关联映射（单项关联）
hibernate一对一主键关联映射（单项关联）Person--->IdCard

主键关联映射：让两个对象的id保持相同，这样可以避免多余的字段被创建

<one-to-one>标签指示hibernate如何加载其引用对象，缺省情况下根据主键加载其引用对象

<id name="id">
<generator class="foreign">
<!-- person中的id来源于idCard，即共享idCard主键 -->
<param name="property">idCard</param>
</generator>
</id>
<property name="name"/>
<!-- constrained="true",当前主键上存在一个约束，表明person中的主键作为外键参照了idCard -->
<one-to-one name="idCard" constrained="true"/>
hibernate一对一主键关联映射（双项关联）
hibernate一对一主键关联映射（双项关联）Person<--->IdCard

需要在idCard加入<one-to-one>标签，指示hibernate如何加载person，默认情况下根据主键加载

<one-to-one name="person"></one-to-one>
hibernate一对一唯一外键关联映射（单项关联）
hibernate一对一唯一外键关联映射（单项关联）Person--->IdCard

一对一唯一外键关联实际上是多对一关联映射的特例

可以采用<many-to-one>标签，指定“多”的一端unique=“true”，即限制了“多”一端的多重性为“一”
这样就构成了一对一唯一外键关联映射
hibernate一对一唯一外键关联映射（双向关联）
hibernate一对一唯一外键关联映射（双向关联）Person<--->IdCard

一对一唯一外键双向关联映射，需要在另一端(IdCard)，添加<one-to-one>标签，指示hibernate如何
加载其引用对象，默认情况下根据主键加载person，因为外键关联映射中，两个实体的关系是由person的
外键IdCard维护的，所以不能指定person的主键来加载person，而是根据person的外键idCard来加载person
对象，如：
<one-to-one name="person" property-ref="idCard"></one-to-one>

hibernate一对多关联映射（单向关联）
hibernate一对多关联映射（单向关联）Classes--->Student

这种关联映射的原理采用的是多对一关联映射的原理

多对一关联映射，是在“多”的一端添加一个外键指向“一”的一端，它维护的关系多到一的关系
一对多关联应是，是在“多”的一端添加一个外键指向“一”的一端，它维护的关系一到多的关系

也就是说，一对多和多对一关联映射的策略是一致的，只是站的角度不同

缺点：
* 更新student表中的classesid字段时，会发出多余的update语句，来维护classes到student之间的关系
* 如果将t_student中的classesid设置为非空，则不能成功保存

<set name="students" order-by="id">
<!--
<key column="classesid" not-null="true"></key>
-->
<key column="classesid"></key>
<one-to-many class="com.bjsxt.hibernate.Student"/>
</set>
hibernate一对多关联映射（双向关联）
hibernate一对多关联映射（双向关联）Classes<--->Student

一对多双向关联映射的方法：
* 在“一”一端的集合中使用<key>标签，在对方表中加入一个外键指向“一”一端
* 在“多"的一端采用<many-to-one>

注意：<key>标签指定的外键字段必须和<many-to-one>指定的外键字段一致，否则引起字段错误
<many-to-one name="classes" column="classesid" cascade="all"></many-to-one>

如果在“一”一端维护一对多关联关系，hibernate会发出多余的update语句，所以我们一般在多的一端来维护关联关系。

关于inverse属性：
inverse主要用在一对多和多对多双向关联上，inverse可以被是知道集合标签<set>上，默认inverse为false，
所以我们可以从“一”一端和“多”一端维护关联关系，如果设置成inverse为true，则我们只能从多一端来维护关联关系。

注意：inverse属性，只影响数据的存储，也就是持久化

inverse和cascade
* inverse是关联关系的控制方向
* cascade是指操作上的连锁反映
hibernate多对多关联映射（单项关联）
hibernate多对多关联映射（单项关联）user--->role

映射规则：
<set name="roles" table="t_user_role">
<key column="userid"></key>
<many-to-many class="com.bjsxt.hibernate.Role" column="roleid"/>
</set>
hibernate多对多关联映射（双项关联）
hibernate多对多关联映射（双项关联）user<--->role

映射规则：

<set name="users" table="t_user_role" order-by="userid">
<key column="roleid"/>
<many-to-many class="com.bjsxt.hibernate.User" column="userid"></many-to-many>
</set>

* table属性值必须和单向关联中的table属性值一致
* <key>标签中的column属性值必须和单向关联中的<many-to-many>中的column属性值一致
* <many-to-many>标签中的column必须和单向关联中的<key>标签中的column属性值一致
基本映射说明
基本映射

类-->数据库表

普通属性-->表字段

通过<class>映射到数据库表，通过<property>将普通属性映射到表字段。
所谓普通属性不包扩，自定义类，集合，数组

实体类主要设计原则：
* 实现一个默认的（即无参数的）构造方法（constructor）
* 提供一个标识属性（identifier property）(可选)
* 使用非final的类（可选）
* 为持久化字段声明访问器（accessors）(可选)

注意：类的名称和属性的名称如果和sql中的关键子重复，必须用table或column重新命名

id的映射：
了解uuid、native和assigned

注意：类的名称和类中属性的名称，如果和sql中的关键字重复，必须用table或column属性重命名
hibernate的session.flush
测试session.flush

1、session在什么情况下清理缓存：
* 默认情况下，当应用程序提交事务，如：Transaction.commit;
* 当我们显示调用flush的时候
* 在执行某些查询的时候，如：iterate

2、session.flush()主要完成两件事情：
* 清理缓存
* 执行sql

3、flush执行的顺序：hibernate按照save,update,delete顺序提交相关操作
Hibernate的一个配置参数hibernate.hbm2ddl.auto
关键字: hibernate hbm2ddl.auto
Java代码  
1.<properties>  
2.           <property name="hibernate.show_sql" value="true" />        
3.           <property name="hibernate.hbm2ddl.auto" value="create" />  
4.</properties>  

看到了吗？
hibernate.hbm2ddl.auto value=“create”
看一下hibernate的官方解释：
hibernate.hbm2ddl.auto Automatically validate or export schema DDL to the database when the SessionFactory is created. With create-drop, the database schema will be dropped when the SessionFactory is closed explicitly. eg. validate | update | create | create-drop
有意思吧~！
竟然可以自动创建|更新|验证数据库表结构。
呵呵 不过如果不是此方面的需求建议set value="none".
下面是这几个属性的解释：
validate               加载hibernate时，验证创建数据库表结构
create                  每次加载hibernate，重新创建数据库表结构，这就是导致数据库表数据丢失的原因。
create-drop         加载hibernate时创建，退出是删除表结构
update                加载hibernate自动更新数据库结构

1.请慎重使用此参数，没必要就不要随便用。如果要用尽量使用update
2.如果发现数据库表丢失，请检查hibernate.hbm2ddl.auto的配置

hibernate lazy策略可以使用在：
* <class>标签上，可以取值：true/false
* <property>标签上，可以取值：true/false需要类增强工具
* <set><list>标签上，可以取值：true/false/extra
* <one-to-one><many-to-one>单端关联上，可以取值：false/proxy/noproxy

lazy概念：只有真正使用该对象时，才会创建，对于hibernate而言，正真使用的时候才会发出sql

hibernate支持lazy策略只有在session打开状态下有效

<class>标签上的lazy特性只对普通属性起作用hibernate lazy策略可以使用在：
* <class>标签上，可以取值：true/false
* <property>标签上，可以取值：true/false需要类增强工具
* <set><list>标签上，可以取值：true/false/extra
* <one-to-one><many-to-one>单端关联上，可以取值：false/proxy/noproxy

lazy概念：只有真正使用该对象时，才会创建，对于hibernate而言，正真使用的时候才会发出sql

hibernate支持lazy策略只有在session打开状态下有效

<class>标签上的lazy特性只对普通属性起作用
重要的概念：
1、lazy的概念，指在需要的时候才发出sql
2、lazy策略只是在session打开期间才是有效的

注意：
Hibernate类级别的lazy加载策略：可以控制什么时候加载这些普通对象属性

测试单元的使用：
请先运行初时化程序InitData,在执行每个单元测试


Hibernate集合属性的懒加载策略：

在集合属性上，可以配置懒加载策略，取值为：true/false/extra

true:默认取值，它的意思是只有在调用这个集合获取里面的元素对象时，才发出查询语句，加载其
    集合元素的数据
false:取消懒加载特性，即在加载对象的同时，就发出第二条查询语句加载其关联集合的数据
extra:一种比较聪明的懒加载策略，即调用集合的size/contains等方法的时候，hibernate并不会去加载整个集合的数据，而是发出一条聪明的SQL语句，以便获得需要的值，只有在真正需要用到这些集合元素对象数据的时候，才去发出查询语句加载所有对象的数据


Hibernate单端关联懒加载策略：即在<one-to-one>/<many-to-one>标签上可以配置
懒加载策略。

可以取值为：false/proxy/no-proxy
false:取消懒加载策略，即在加载对象的同时，发出查询语句，加载其关联对象
proxy:这是hibernate对单端关联的默认懒加载策略，即只有在调用到其关联对象的方法的时候
     才真正发出查询语句查询其对象数据，其关联对象是代理类
no-proxy:这种懒加载特性需要对类进行增强，使用no-proxy，其关联对象不是代理类

注意：在class标签上配置的lazy属性不会影响到关联对象!!!

hibernate的lazy策略forClass
lazy策略可以用在：
* <class>标签上，可以取值：true/false
* <property>标签上，可以取值：true/false,这个特性需要类增强工具
* <set><list>等集合上，可以取值:true/false/extra
* <one-to-one>和<many-to-many>（单端关联）等标签上，可以取值：false/proxy/noproxy

概念：
1、lazy是只有需要的时候才发出sql语句
2、hibernate支持lazy策略，只有session打开状态下才有效

hibernate类级别的lazy测试，可以控制什么时候加载这些普通属性
把class的lazy设置成false时，再load类时会把普通属性都查出来，但是集合不查
class标签上的lazy不会影响到集合上的lazy特性
class标签上的lazy特性只对普通属性起作用

使用：
1、运行initData
2、运行测试用例
hibernate在集合上的lazy策略
hibernate在集合上的lazy策略，可以取值true/false/extra
测试集合lazy:
get集合时不会发sql,迭代会发sql
查个数的时候会把整个集合查出来，这样的话对效率有影响
lazy在集合上用extra在获取size的时候会发出count语句，这样对效率有提升

使用：
1、运行InitData
2、运行测试用例
hibernate在单端关联上的lazy策略
hibernate在单端关联上的lazy策略,<one-to-one>和<many-to-one>，可以取值：false/proxy/noproxy
在单端关联上lazy默认，和集合一样，在get时返回代理不发查询语句，在使用时发出sql
在单端关联上lazy=false,在访问普通属性时发出两条sql,查询属性以及对应的关联对象
将class标签上lazy设置成false,其它默认：
不会影响单端关联，也不会影响集合

使用：
1、运行InitData
2、运行测试用例

Hibernate中的继承映射
Hibernate的继承映射包含了三种不同的策略：
1.每棵继承树映射成一张表
2.每个子类映射成一张表；
3.每个具体类映射成一张表（有限制）。
每棵继承树映射成一张表



每棵继承树映射成一张表
t_animal
idnameSexweightheighttype
1猪猪True100P
2鸟鸟False50B

Animal.java
publicclass Animal {
privateint id;
private String name;
privateboolean sex;
getter and setter; }
Pig.java
publicclass Pig extends Animal {
privateint weight;
    getter and setter;
}

Bird.java
publicclass Bird extends Animal {
privateint height;
    getter and setter;
}

Extend.hbm.xml
<hibernate-mapping package="com.bjsxt.hibernate">
    <class name="Animal" table="t_animal" lazy="false">
        <id name="id">
            <generator class="native"/>
        </id>
        <discriminator column="type" type="string"/>
        <property name="name"/>
        <property name="sex"/>
        <subclass name="Pig" discriminator-value="P">
            <property name="weight"/>
        </subclass>
        <subclass name="Bird" discriminator-value="B">
            <property name="height"/>
        </subclass>
    </class>
</hibernate-mapping>

每个子类一个表；(效率不高。实体类跟上面的一样)

<hibernate-mapping package="com.bjsxt.hibernate">
    <class name="Animal" table="t_animal">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="name"/>
        <property name="sex"/>
        <joined-subclass name="Pig" table="t_pig">
            <key column="pid"/>
            <property name="weight"/>
        </joined-subclass>
        <joined-subclass name="Bird" table="t_bird">
            <key column="bid"/>
            <property name="height"/>
        </joined-subclass>
    </class>
</hibernate-mapping>

每个具体类映射成一张表（有限制）

每个具体类映射成一张表（主表可以不生成 在class中 设置 abstract = “ true”）
t_pig
idNamesexweight
1猪猪true100
t_bird
idNamesexheight
2鸟鸟false50

session{
map{
key=Animal+id
}
}
(实体类跟上面的一样) 主键不能用自增，主键手动设置

Extends.hbm.xml
<hibernate-mapping package="com.bjsxt.hibernate">
    <class name="Animal"abstract="true">
        <id name="id">
            <generator class="assigned"/>
        </id>
        <property name="name"/>
        <property name="sex"/>
        <union-subclass name="Pig" table="t_pig">
            <property name="weight"/>
        </union-subclass>
        <union-subclass name="Bird" table="t_bird">
            <property name="height"/>
        </union-subclass>
    </class>
</hibernate-mapping>

component映射（只建一张表）

在hibernate中,component是某个实体的逻辑组成部分，它与实体的根本区别是没有oid，
component可以成为是值对象（DDD）

采用component映射的好处：它实现了对象模型的细粒度划分，层次会更分明，复用率会更高

Contact.java
publicclass Contact {
private String email;
private String address;
private String zipCode;
private String contactTel;
getter and setter;
}

User.java
publicclass User {
privateint id;
private String name;
private Contact contact;
    getter and setter;
}

User.hbm.xml
<hibernate-mapping>
    <class name="com.bjsxt.hibernate.User" table="t_user">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="name"/>
        <component name="contact">
            <property name="email"/>
            <property name="address"/>
            <property name="zipCode"/>
            <property name="contactTel"/>
        </component>
    </class>
</hibernate-mapping>

复合主键映射（单独建一个实体类，重写hashCode和equals方法，实现序列化接口）
通常将复合主键相关的属性，单独放到一个类中
* 此类必须实现序列化接口
* 覆写hashcode和equals方法

<hibernate-mapping>
    <class name="com.bjsxt.hibernate.FiscalYearPeriod" table="t_fiscal_year_period">
        <composite-id name="fiscalYearPeriodPK">
            <key-property name="fiscalYear"/>   //第一个主键
            <key-property name="fiscalPeriod"/>   //第二个主键
        </composite-id>
        <property name="beginDate"/>
        <property name="endDate"/>
        <property name="periodSts"/>
    </class>
</hibernate-mapping>

hibernate-悲观锁与乐观锁
悲观锁

悲观锁的实现，通常依赖于数据库机制，在整个过程中将数据锁定，其它任何用户都不能读取或修改

Inventory.java
publicclass Inventory {
privateint itemNo;
private String itemName;
privateint quantity;}

<pre name="code"class="java">Inventory.hbm..xml
<hibernate-mapping>
    <class name="com.bjsxt.hibernate.Inventory" table="t_inventory">
        <id name="itemNo">
            <generator class="native"/>
        </id>
        <property name="itemName"/>
        <property name="quantity"/>
    </class>
</hibernate-mapping></pre>操作类中实现：
<br>    Inventory inv = (Inventory)session.load(Inventory.class, 1, LockMode.UPGRADE);

Hibernate的加锁模式有：

LockMode.NONE ： 无锁机制。
LockMode.WRITE ：Hibernate在Insert和Update记录的时候会自动获取。
LockMode.READ ： Hibernate在读取记录的时候会自动获取。

以上这三种锁机制一般由Hibernate内部使用，如Hibernate为了保证Update
过程中对象不会被外界修改，会在save方法实现中自动为目标对象加上WRITE锁。

LockMode.UPGRADE ：利用数据库的for update子句加锁。
LockMode. UPGRADE_NOWAIT ：Oracle的特定实现，利用Oracle的for update nowait子句实现加锁。

乐观锁
大多数基于数据版本记录机制（version）实现，一般是在数据库表中加入一个version字段
读取数据时将版本号一同读出，之后更新数据时版本号加一，如果提交数据时版本号小于或等于数据表中
的版本号，则认为数据是过期的，否则给予更新

<hibernate-mapping>
    <class name="Inventory" table="t_inventory" optimistic-lock="version">
        <id name="itemNo">
            <generator class="native"/>
        </id>
        <version name="version"/>
        <property name="itemName"/>
        <property name="quantity"/>
    </class>
</hibernate-mapping>

hibernate查询语言hql


1、简单属性查询【重要】
* 单一属性查询，返回结果集属性列表，元素类型和实体类中相应的属性类型一致
* 多个属性查询,返回的集合元素是对象数组,数组元素的类型和对应的属性在实体类中的类型一致
*在hql中关键字不区分大小写，但是属性和类名区分大小写


 数组的长度取决与select中属性的个数
* 如果认为返回数组不够对象化，可以采用hql动态实例化Student对象
参见：SimplePropertyQueryTest.java  

2、实体对象查询【重要】
* N + 1问题，在默认情况下，使用query.iterate查询，有可以能出现N+1问题
 所谓的N+1是在查询的时候发出了N+1条sql语句
 1: 首先发出一条查询对象id列表的sql
 N: 根据id列表到缓存中查询，如果缓存中不存在与之匹配的数据，那么会根据id发出相应的sql语句
* list和iterate的区别？
* list每次都会发出sql语句，list会向缓存中放入数据，而不利用缓存中的数据
* iterate：在默认情况下iterate利用缓存数据，但如果缓存中不存在数据有可以能出现N+1问题
参见：SimpleObjectQueryTest1.java/SimpleObjectQueryTest2.java

3、条件查询【重要】
* 可以采用拼字符串的方式传递参数
* 可以采用 ？来传递参数（索引从0开始）
* 可以采用 :参数名 来传递参数
* 如果传递多个参数，可以采用setParamterList方法
* 在hql中可以使用数据库的函数，如：date_format
参见：SimpleConditionQueryTest.java

4、hibernate也支持直接使用sql进行查询
参见：SqlQueryTest.java

5、外置命名查询
* 在映射文件中采用<query>标签来定义hql
* 在程序中采用session.getNamedQuery()方法得到hql查询串
参见：Student.hbm.xml、NameQueryTest.java

6、查询过滤器
* 在映射文件中定义过滤器参数
* 在类的映射中使用这些参数
* 在程序中启用过滤器
参见：Student.hbm.xml、FilterQueryTest.java

7、分页查询【重要】
* setFirstResult()，从0开始
* setMaxResults,每页显示多少条数据
参见：PageQueryTest.java

8、对象导航查询，在hql中采用 . 进行导航【重要】
参见：ObjectNavQueryTest.java

9、连接查询【重要】
* 内连
* 外连接（左连接/右连接）
参见：JoinQueryTest.java

10、统计查询【重要】
参见：StatQueryTest.java

11、DML风格的操作（尽量少用，因为和缓存不同步）
参见：DMLQueryTest.java

hibernate一级缓存

一级缓存很短和session的生命周期一致，一级缓存也叫session级的缓存或事务级缓存

那些方法支持一级缓存：
* get()
* load()
* iterate（查询实体对象）

如何管理一级缓存：
* session.clear(),session.evict()

如何避免一次性大量的实体数据入库导致内存溢出
* 先flush，再clear

如果数据量特别大，考虑采用jdbc实现，如果jdbc也不能满足要求可以考虑采用数据本身的特定导入工具

在同一个session中发出两次load查询：

Student student = (Student)session.load(Student.class, 1);
            System.out.println("student.name=" + student.getName());
//不会发出sql，因为load使用缓存
            student = (Student)session.load(Student.class, 1);
            System.out.println("student.name=" + student.getName());

在同一个session中发出两次get查询：

Student student = (Student)session.get(Student.class, 1);
            System.out.println("student.name=" + student.getName());
//不会发出sql，因为get使用缓存
            student = (Student)session.get(Student.class, 1);
            System.out.println("student.name=" + student.getName());

在同一个session中发出两次iterate查询实体对象：

Student student =
(Student)session.createQuery("from Student s where s.id=1").iterate().next();
            System.out.println("student.name=" + student.getName());
//会发出查询id的sql，不会发出查询实体对象的sql，因为iterate使用缓存
            student =
(Student)session.createQuery("from Student s where s.id=1").iterate().next();
            System.out.println("student.name=" + student.getName());

在同一个session中发出两次iterate查询实体对象：

String name =
(String)session.createQuery("select s.name from Student s where s.id=1").iterate().next();
            System.out.println("student.name=" + name);
//iterate查询普通属性，一级缓存不会缓存，所以发出sql
//一级缓存是缓存实体对象的
            name =
(String)session.createQuery("select s.name from Student s where s.id=1").iterate().next();
            System.out.println("student.name=" + name);

开启两个session中发出load查询：
Session1中：

session = HibernateUtils.getSession();
            session.beginTransaction();
            Student student = (Student)session.load(Student.class, 1);
            System.out.println("student.name=" + student.getName());
Session2中：

//会发出查询语句，session间不能共享一级缓存的数据
//因为它会伴随session的生命周期存在和消亡
        Student student = (Student)session.load(Student.class, 1);
        System.out.println("student.name=" + student.getName());

在同一个session中先save，在发出load查询save过的数据：

Student stu = new Student();
            stu.setName("王五");
            Serializable id = session.save(stu);
//不会发出sql，因为save是使用缓存的
            Student student = (Student)session.load(Student.class, id);
            System.out.println("student.name=" + student.getName());

向数据库中批量加入1000条数据：

for (int i=0; i<1000; i++) {
                Student student = new Student();
                student.setName("s_" + i);
                session.save(student);
//每20条数据就强制session将数据持久化
//同时清除缓存，避免大量数据造成内存溢出
if ( i % 20 == 0) {
                    session.flush();
                    session.clear();
                }
            }

hibernate二级缓存

二级缓存也称进程级的缓存或SessionFactory级的缓存，二级缓存可以被所有的session共享
二级缓存的生命周期和SessionFactory的生命周期一致，SessionFactory可以管理二级缓存

二级缓存的配置和使用：
* 将echcache.xml文件拷贝到src下
* 开启二级缓存，修改hibernate.cfg.xml文件
<property name="hibernate.cache.use_second_level_cache">true</property>
* 指定缓存产品提供商，修改hibernate.cfg.xml文件
<property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
* 指定那些实体类使用二级缓存（两种方法）
* 在映射文件中采用<cache>标签
* 在hibernate.cfg.xml文件中，采用<class-cache>标签

二级缓存是缓存实体对象的

了解一级缓存和二级缓存的交互

Hibernate.cfg.xml
<!-- 开启二级缓存 -->
<property name="hibernate.cache.use_second_level_cache">true</property>

<!-- 指定缓存产品提供商 -->
<property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvide
r</property>


hibernate查询缓存

查询缓存是针对普通属性结果集的缓存
对实体对象的结果集只缓存id

查询缓存的生命周期，当前关联的表发生修改，那么查询缓存生命周期结束

查询缓存的配置和使用：
* 在hibernate.cfg.xml文件中启用查询缓存，如：
<property name="hibernate.cache.use_query_cache">true</property>
* 在程序中必须手动启用查询缓存，如：
query.setCacheable(true);

hibernate抓取策略（单端代理的批量抓取）

保持默认，同fetch="select",如：
<many-to-one name="classes" column="classesid" fetch="select"/>

fetch="select",另外发送一条select语句抓取当前对象关联实体或集合

hibernate抓取策略（单端代理的批量抓取）

设置fetch="join",如：
<many-to-one name="classes" column="classesid" fetch="join"/>

fetch="join",hibernate会通过select语句使用外连接来加载其关联实体或集合

此时lazy会失效

hibernate抓取策略（集合代理的批量抓取）

保持默认，同fetch="select",如：
<set name="students" inverse="true" cascade="all" fetch="select">

fetch="select",另外发送一条select语句抓取当前对象关联实体或集合

hibernate抓取策略（集合代理的批量抓取）

设置fetch="join",如：
<set name="students" inverse="true" cascade="all" fetch="join">

fetch="join",hibernate会通过select语句使用外连接来加载其关联实体或集合

此时lazy会失效

hibernate抓取策略（集合代理的批量抓取）

设置fetch="subselect",如：
<set name="students" inverse="true" cascade="all" fetch="subselect">

fetch="subselect",另外发送一条select语句抓取在前面查询到的所有实体对象的关联集合



hibernate抓取策略，,batch-szie在<class>上的应用

batch-size属性，可以批量加载实体类，参见：Classes.hbm.xml
<class name="Classes" table="t_classes" batch-size="3">

hibernate抓取策略,batch-szie在集合上的应用


batch-size属性，可以批量加载实体类，参见：Classes.hbm.xml
<set name="students" inverse="true" cascade="all" batch-size="5">