hibernate 学习笔记3

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.一对一的加载默认是使用左外连接查询。