Hibernate(4)

   案例一:使用Hibernate完成对客户的条件查询
   案例二:使用Hibernate完成对客户查询的优化

案例一：完成CRM的客户的条件查询
1.1 案例需求:
1.1.1   需求描述
要对客户进行条件查询,效果如下:

1.2 相关知识点
1.2.1   Hibernate的检索方式:
1.2.1.1 Hibernate检索方式的分类:
Hibernate中提供了5种检索方式：
1.OID检索 
2.对象导航检索    
3.HQL检索
4.QBC检索
5.SQL检索
1.2.2   HQL检索
1.2.2.1 基本检索
    @Test
    /**
     * HQL：基本检索
     */
    public void demo2(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();

        // 基本查询
        /*Query query = session.createQuery("from Customer");
        List<Customer> list = query.list();*/
        // 起别名
        //Query query = session.createQuery("from Customer c");
        Query query = session.createQuery("select c from Customer c");
        List<Customer> list = query.list();

        for (Customer customer : list) {
            System.out.println(customer);
        }

        tx.commit();
    }
1.2.2.2 排序检索
    @Test
    /**
     * HQL：排序检索
     */
    public void demo3(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();

        // 基本查询
        Query query = session.createQuery("from Customer order by cust_id desc");
        List<Customer> list = query.list();

        for (Customer customer : list) {
            System.out.println(customer);
        }

        tx.commit();
    }
1.2.2.3 条件检索
    @Test
    /**
     * HQL：条件查询
     */
    public void demo4(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();

        // 按位置绑定参数
        /*Query query = session.createQuery("from Customer where cust_name = ?");
        // query.setString(0, "小军军");
        query.setParameter(0, "小军军");
        List<Customer> list = query.list();*/

        // 按名称绑定参数
        Query query = session.createQuery("from Customer where cust_name = :name");
        query.setParameter("name", "小添添");
        /*List<Customer> list = query.list();
        for (Customer customer : list) {
            System.out.println(customer);
        }*/
        Customer customer = (Customer) query.uniqueResult();
        System.out.println(customer);

        tx.commit();
    }
1.2.2.4 分页检索
    @Test
    /**
     *  分页查询
     */
    public void demo5(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();

        Query query = session.createQuery("from LinkMan order by lkm_id desc");
        query.setFirstResult(5);
        query.setMaxResults(5);
        List<LinkMan> list = query.list();
        for (LinkMan linkMan : list) {
            System.out.println(linkMan);
        }

        tx.commit();
    }
1.2.2.5 统计检索
    @Test
    /**
     *  统计查询
     */
    public void demo6(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();

        Query query = session.createQuery("select count(*) from Customer");
        Long num = (Long) query.uniqueResult();
        System.out.println(num);

        tx.commit();
    }
1.2.2.6 投影检索
    @Test
    /**
     * 投影查询
     */
    public void demo7(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();
        // 投影查询一列
        /*List<String> list = session.createQuery("select cust_name from Customer").list();
        for (String string : list) {
            System.out.println(string);
        }*/
        // 投影查询多列:
        /*List<Object[]> list = session.createQuery("select cust_id,cust_name from Customer").list();
        for (Object[] objects : list) {
            System.out.println(Arrays.toString(objects));
        }*/

        // 投影的构造的方式查询:
        List<Customer> list = session.createQuery("select new Customer(cust_id,cust_name) from Customer").list();
        for (Customer customer : list) {
            System.out.println(customer);
        }
        tx.commit();
    }

1.2.3   QBC检索
1.2.3.1 基本检索
@Test
    /**
     * 简单的查询
     */
    public void demo1(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();
        // 简单查询:
        Criteria criteria = session.createCriteria(Customer.class);
        List<Customer> list = criteria.list();

        for (Customer customer : list) {
            System.out.println(customer);
        }
        tx.commit();
    }
1.2.3.2 条件检索
    @Test
    /**
     * 条件查询
     */
    public void demo2(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();
        // 条件查询:
        Criteria criteria = session.createCriteria(Customer.class);
        // 设置条件:
        // criteria.add(Restrictions.eq("cust_name", "小军军"));
        criteria.add(Restrictions.like("cust_name", "%小%"));
        criteria.add(Restrictions.gt("cust_id", 1l));

        List<Customer> list = criteria.list();

        for (Customer customer : list) {
            System.out.println(customer);
        }
        tx.commit();
    }
1.2.3.3 分页检索
    @Test
    /**
     * 分页查询
     */
    public void demo3(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();
        // 条件查询:
        Criteria criteria = session.createCriteria(LinkMan.class);
        // 设置分页查询:
        criteria.setFirstResult(5);
        criteria.setMaxResults(5);

        List<LinkMan> list = criteria.list();

        for (LinkMan linkMan : list) {
            System.out.println(linkMan);
        }
        tx.commit();
    }
1.2.3.4 排序检索
    @Test
    /**
     * 排序查询
     */
    public void demo4(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();

        // 排序查询:
        Criteria criteria = session.createCriteria(LinkMan.class);
        criteria.addOrder(Order.desc("lkm_id"));

        List<LinkMan> list = criteria.list();

        for (LinkMan linkMan : list) {
            System.out.println(linkMan);
        }

        tx.commit();        
    }
1.2.3.5 统计检索
    @Test
    // 统计查询:
    public void demo4(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();

        Criteria criteria = session.createCriteria(LinkMan.class);
        criteria.setProjection(Projections.rowCount());
        Long count = (Long) criteria.uniqueResult();

        System.out.println(count);
        tx.commit();
    }
1.2.3.6 离线条件检索
    @Test
    /**
     * 离线条件查询:DetachedCriteria(SSH整合经常使用.).
     * * 可以脱离session设置参数.
     */
    public void demo6(){
        // 获得一个离线条件查询的对象
        DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Customer.class);
        detachedCriteria.add(Restrictions.eq("cust_name","小童童"));

        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();

        List<Customer> list = detachedCriteria.getExecutableCriteria(session).list();// 离线条件查询对象与session绑定.
        for (Customer customer : list) {
            System.out.println(customer);
        }
        tx.commit();
    }
1.2.4   多表查询
1.2.4.1 多表查询:
【SQL多表查询】
SQL中分成:
* 连接查询:
    * 交叉连接:
        * select * from A,B;
    * 内连接
        * 隐式内连接
            * select * from A ,B where A.id = B.id;
        * 显示内连接
            * select * from A inner join B on A.id = B.id;
            * select * from A join B on A.id = B.id;
    * 外连接
        * 左外连接
            * select * from A left outer join B on A.id = B.id;
            * select * from A left join B on A.id = B.id;

        * 右外连接
            * select * from A right outer join B on A.id = B.id;
            * select * from A right join B on A.id = B.id;
【HQL的多表查询】
HQL中分成:
* 连接查询:
     * 交叉连接:

     * 内连接:
        * 隐式内连接
        * 显示内连接
        * 迫切内连接 

     * 外连接：
        * 左外连接
        * 迫切左外连接
        * 右外连接
1.2.4.2 HQL连接查询
SQL连接查询:
* 隐式内连接:
SELECT * FROM cst_customer c,cst_linkman l WHERE c.cust_id = l.lkm_cust_id;
* 显示内连接:
SELECT * FROM cst_customer c INNER JOIN cst_linkman l ON c.cust_id = l.lkm_cust_id;

HQL连接的查询:
* 内连接：
List<Object[]> list = session.createQuery("from Customer c inner join c.linkMans").list();
// session.createQuery("from LinkMan l inner join l.customer");

* 迫切内连接:
    @Test
    /**
     * 迫切内连接查询
     */
    public void demo9(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();
        // 迫切内连接:
        // 迫切内连接和内连接所发送的SQL语句是一样的.fetch告诉Hibernate 封装的时候 要往对象中去封装.将客户封装到Customer中将Customer对应的联系人封装到Customer的LinMan的集合中.
        //List<Customer> list = session.createQuery("from Customer c inner join fetch c.linkMans").list();
        List<Customer> list = session.createQuery("select distinct c from Customer c inner join fetch c.linkMans").list();
        // System.out.println(list.size());
        for (Customer customer : list) {
            System.out.println(customer);
        }
        tx.commit();
    }

* 内连接和迫切内连接的区别:
    * 内连接:发送就是内连接的语句,封装的时候将每条记录封装到一个Object[]数组中,最后得到一个List<Object[]>.
    * 迫切内连接：发送的也是内连接的语句,在join后添加一个fetch关键字,Hibernate会将每条数据封装到对象中,最后List<Customer>. 需要去掉重复值.

案例二:完成CRM的查询优化
1.3 案例需求
1.3.1   需求描述
在CRM的案例中有很多地方需要用到查询操作，但是Hibernate本身的查询的效率不是很好，需要对查询语句进行一些优化操作
1.4 相关知识点
1.4.1   Hibernate的抓取策略:
1.4.1.1 延迟加载的分类:
【类级别的延迟加载】:类级别的延迟一般不修改.采用默认值即可.lazy=”true”
Customer customer = session.load(Customer.class,1l); // 通过一些延迟加载的方法load方法检索某个对象.这个对象是否采用延迟.
// 默认情况下类上的延迟是 lazy=”true”

***** 如何使延迟加载失效:
      * 在<class>标签上配置lazy=”false”
      * 定义类的时候采用final修饰.
      * Hibernate.initialize(Object proxy);

【关联级别的延迟加载】
Customer customer = session.get(Customer.class,1l); 
Set<LinkMan> linkMans = customer.getLinkMans(); // 通过客户关联其联系人的对象.联系人是否采用延迟.

<set>上的lazy         :
<many-to-one>上的lazy :

1.4.1.2 抓取策略:抓取其关联对象.
<set>和<many-to-one>标签上有一个fetch=””

1.4.1.3 <set>集合上的fetch和lazy:
fetch:  控制的是查询其关联对象的时候采用的SQL语句的格式.
    * select        :默认值.  发送一条select语句查询其关联对象.
    * join      :发送 一条迫切左外连接查询关联对象.
    * subselect :发送 一条子查询查询其关联对象.

lazy:   控制的是查询其关联对象的时候是否采用延迟加载的策略.
    * true      :默认值. 默认查询联系人的时候采用延迟加载.
    * false     :查询关联对象的时候 不采用延迟加载.
    * extra     :及其懒惰. 查询关联对象的时候 采用比延迟加载更懒惰的方式进行查询.
1.4.1.4 <many-to-one>上的fetch和lazy:
fetch:  控制查询其关联对象的SQL语句的格式
    * select        :默认值,发送普通的select语句查询
    * join      :发送一条迫切左外连接查询.

lazy:   查询其关联对象的时候是否采用延迟加载.
    * proxy     :默认值.是否采用延迟 取决于 一的一方的class上的lazy的值.
    * false     :不采用延迟加载其关联对象.
    * no-proxy  :不用研究