

1Hibernate的查询的方式

在Hibernate中提供了很多种的查询的方式。Hibernate共提供了五种查询方式。

1.1Hibernate的查询方式：OID查询

OID检索：Hibernate根据对象的OID（主键）进行检索。

1.1.1使用get方法

Customer customer = session.get(Customer.class,1l);

1.1.2使用load方法

Customer customer =session.load(Customer.class,1l);

1.2Hibernate的查询方式：对象导航检索

对象导航检索：Hibernate根据一个已经查询到的对象，获得其关联的对象的一种查询方式。

LinkMan linkMan = session.get(LinkMan.class,1l);
Customer customer  = linkMan.getCustomer();
Customer customer = session.get(Customer.class,2l);
Set<LinkMan> linkMans = customer.getLinkMans();

1.3Hibernate的查询方式：HQL检索

HQL查询：HibernateQuery Language，Hibernate的查询语言，是一种面向对象的方式的查询语言，语法类似SQL。通过session.createQuery()，用于接收一个HQL进行查询方式。

1.3.1初始化一些数据

@Test
 /**
     * 初始化数据
     */
 publicvoid demo1() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx =session.beginTransaction();
 // 创建一个客户
        Customer customer = new Customer();
        customer.setCust_name("张帅");
 for (int i = 1; i <=10; i++) {
            LinkMan linkMan = new LinkMan();
            linkMan.setLkm_name("王晓丹" + i);
            linkMan.setCustomer(customer);
            customer.getLinkMans().add(linkMan);
            session.save(linkMan);
        }
        session.save(customer);
        tx.commit();
    }
1.3.2HQL的简单查询
@Test
 /**
     * HQL的简单查询
     */
 publicvoid demo2() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx =session.beginTransaction();
 // 简单的查询
        Query query = session.createQuery("from Customer");
        List<Customer> list = query.list();
 // sql中支持*号的写法：select * from cst_customer; 但是在HQL中不支持*号的写法。
 /*
         *Query query = session.createQuery("select * from Customer");// 报错
         *List<Customer> list = query.list();
         */
 for (Customercustomer : list) {
            System.out.println(customer);
        }
        tx.commit();
    }
1.3.3HQL的别名查询
@Test
 /**
     * 别名查询
     */
 publicvoid demo3() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx =session.beginTransaction();
 // 别名的查询
 /*
         *Query query = session.createQuery("from Customer c");List<Customer>
         *list = query.list();
         */
        Query query = session.createQuery("select c from Customer c");
        List<Customer> list = query.list();
 for (Customercustomer : list) {
            System.out.println(customer);
        }
        tx.commit();
    }
1.3.4HQL的排序查询
@Test
 /**
     * 排序查询
     */
 publicvoid demo4() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx =session.beginTransaction();
 // 排序的查询
 // 默认情况
 // List<Customer> list = session.createQuery("from Customerorder by
 // cust_id").list();
 // 设置降序排序 升序使用asc降序使用desc
        List<Customer> list = session.createQuery("from Customer order by cust_id desc").list();
 for (Customercustomer : list) {
            System.out.println(customer);
        }
        tx.commit();
    }
1.3.5HQL的条件查询
@Test
 /**
     * 条件查询
     */
 publicvoid demo5() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx =session.beginTransaction();
 // 条件的查询
 // 一、按位置绑定：根据参数的位置进行绑定。
 // 一个条件
 /*
         *Query query = session.createQuery("from Customer where cust_name = ?"
         *); query.setParameter(0, "李兵"); List<Customer> list = query.list();
         */
 // 多个条件
 /*
         *Query query = session.createQuery(
         *"from Customer where cust_source = ? and cust_name like ?");
         *query.setParameter(0, "小广告"); query.setParameter(1, "李%");
         *List<Customer> list = query.list();
         */
 // 二、按名称绑定
        Query query = session.createQuery("from Customer where cust_source = :aaa andcust_name like :bbb");
 // 设置参数:
        query.setParameter("aaa", "朋友推荐");
        query.setParameter("bbb", "李%");
        List<Customer> list = query.list();
 for (Customercustomer : list) {
            System.out.println(customer);
        }
        tx.commit();
    }
1.3.6HQL的投影查询
投影查询：查询对象的某个或某些属性。
 @Test
 /**
      * 投影查询
      */
 publicvoiddemo6() {
         Sessionsession = HibernateUtils.getCurrentSession();
         Transactiontx = session.beginTransaction();
 // 投影查询
 // 单个属性
 /*
          * List<Object> list =session.createQuery(
          * "select c.cust_name from Customerc").list(); for (Object object :
          * list) { System.out.println(object); }
          */
 // 多个属性:
 /*
          * List<Object[]> list =session.createQuery(
          * "select c.cust_name,c.cust_source fromCustomer c").list(); for
          * (Object[] objects : list) {
          * System.out.println(Arrays.toString(objects));}
          */
 // 查询多个属性，但是我想封装到对象中。
         List<Customer>list = session.createQuery("selectnew Customer(cust_name,cust_source) from Customer").list();
 for (Customer customer : list) {
              System.out.println(customer);
         }
         tx.commit();
     }
1.3.7HQL的分页查询
@Test
 /**
      * 分页查询
      */
 publicvoiddemo7() {
         Sessionsession = HibernateUtils.getCurrentSession();
         Transactiontx = session.beginTransaction();
 // 分页查询
         Queryquery = session.createQuery("fromLinkMan");
         query.setFirstResult(20);
         query.setMaxResults(10);
         List<LinkMan>list = query.list();
 for (LinkMan linkMan : list) {
              System.out.println(linkMan);
         }
         tx.commit();
     }
1.3.8HQL的分组统计查询
@Test
 /**
      * 分组统计查询
      */
 publicvoiddemo8() {
         Sessionsession = HibernateUtils.getCurrentSession();
         Transactiontx = session.beginTransaction();
 // 聚合函数的使用：count(),max(),min(),avg(),sum()
         Objectobject = session.createQuery("selectcount(*) from Customer").uniqueResult();
         System.out.println(object);
 // 分组统计：
         List<Object[]>list = session.createQuery("selectcust_source,count(*) from Customer group by cust_source").list();
 for (Object[] objects : list) {
              System.out.println(Arrays.toString(objects));
         }
         tx.commit();
     }
1.3.9HQL的多表查询
l SQL的多表查询
n 连接查询
u 交叉连接：笛卡尔积
select * from A,B;
u 内连接     :inner join (inner 可以省略)
l 隐式内连接：
select * fromA,B where A.id = B.aid;
l 显示内连接：
select * from Ainner join B on A.id = B.aid;
u  外连接  :
l 左外连接:left outer join(outer 可以省略)
select * from Aleft outer join B on A.id= B.aid;
l 右外连接:right outer join(outer 可以省略)
select * from Aright outer join B on A.id = B.aid;
n 子查询
l HQL的多表查询
n 连接查询
u 交叉连接
u 内连接
l 显示内连接
l 隐式内连接
l 迫切内连接
u 外连接
l 左外连接
l 右外连接
l 迫切左外连接
@Test
 /**
      * HQL的多表查询
      */
 publicvoiddemo9() {
         Sessionsession = HibernateUtils.getCurrentSession();
         Transactiontx = session.beginTransaction();
 // SQL:SELECT * FROM cst_customer c INNER JOIN cst_linkman l ON
 // c.cust_id = l.lkm_cust_id;
 // HQL:内连接 from Customer c inner joinc.linkMans
 /*
          * List<Object[]> list =session.createQuery(
          * "from Customer c inner joinc.linkMans").list(); for (Object[]
          * objects : list) {System.out.println(Arrays.toString(objects)); }
          */
 // HQL:迫切内连接 其实就在普通的内连接inner join后添加一个关键字fetch. from Customer c inner
 // join fetch c.linkMans
         List<Customer>list = session.createQuery("selectdistinct c from Customer c inner join fetch c.linkMans").list();// 通知hibernate，将另一个对象的数据封装到该对象中
 for (Customer customer : list) {
              System.out.println(customer);
         }
         tx.commit();
     }

1.4Hibernate的查询方式：QBC检索

QBC查询：Query By Criteria，条件查询。是一种更加面向对象化的查询的方式。

1.4.1简单查询

@Test
 /**
      * 简单的查询
      */
 publicvoiddemo1(){
         Sessionsession = HibernateUtils.getCurrentSession();
         Transactiontx = session.beginTransaction();
 // 获得Criteria的对象
         Criteriacriteria = session.createCriteria(Customer.class);
         List<Customer>list = criteria.list();
 for (Customer customer : list) {
              System.out.println(customer);
         }
         tx.commit();
     }

1.4.2排序查询

@Test
 /**
      * 排序查询
      */
 publicvoiddemo2(){
         Sessionsession = HibernateUtils.getCurrentSession();
         Transactiontx = session.beginTransaction();
 // 排序查询
         Criteriacriteria = session.createCriteria(Customer.class);
//       criteria.addOrder(Order.asc("cust_id"));// 升序
         criteria.addOrder(Order.desc("cust_id")); // 降序
         List<Customer>list = criteria.list();
 for (Customer customer : list) {
              System.out.println(customer);
         }
         tx.commit();
     }
1.4.3分页查询
@Test
 /**
      * 分页查询
      */
 publicvoiddemo3(){
         Sessionsession = HibernateUtils.getCurrentSession();
         Transactiontx = session.beginTransaction();
 // 分页查询
         Criteriacriteria = session.createCriteria(LinkMan.class);
         criteria.setFirstResult(10);
         criteria.setMaxResults(10);
         List<LinkMan>list = criteria.list();
 for (LinkMan linkMan : list) {
              System.out.println(linkMan);
         }
         tx.commit();
     }

1.4.4条件查询

@Test
 /**
      * 条件查询
      */
 publicvoiddemo4(){
         Sessionsession = HibernateUtils.getCurrentSession();
         Transactiontx = session.beginTransaction();
 // 条件查询
         Criteriacriteria = session.createCriteria(Customer.class);
 // 设置条件:
 /**
          * =   eq
          * >  gt
          * >= ge
          * <  lt
          * <= le
          * <> ne
          * like
          * in
          * and
          * or
          */
         criteria.add(Restrictions.eq("cust_source", "小广告"));
//       criteria.add(Restrictions.or(Restrictions.like("cust_name","李%")));
         criteria.add(Restrictions.like("cust_name", "李%"));
         List<Customer>list = criteria.list();
 for (Customer customer : list) {
              System.out.println(customer);
         }
         tx.commit();
     }
1.4.5统计查询
@Test
 /**
      * 统计查询
      */
 publicvoiddemo5(){
         Sessionsession = HibernateUtils.getCurrentSession();
         Transactiontx = session.beginTransaction();
         Criteriacriteria = session.createCriteria(Customer.class);
 /**
          * add                 :普通的条件。where后面条件
          * addOrder            :排序
          * setProjection   :聚合函数 和 group by having
          */
         criteria.setProjection(Projections.rowCount());
         Longnum = (Long) criteria.uniqueResult();
         System.out.println(num);
         tx.commit();
     }

1.4.6离线条件查询（SSH）---DetachedCriteria

@Test

 /**
      * 离线条件查询
      */
 publicvoid demo6(){
         DetachedCriteriadetachedCriteria = DetachedCriteria.forClass(Customer.class);
         detachedCriteria.add(Restrictions.like("cust_name", "李%"));
         Session session =HibernateUtils.getCurrentSession();
         Transaction transaction =session.beginTransaction();
         Criteria criteria =detachedCriteria.getExecutableCriteria(session);
         List<Customer> list = criteria.list();
 for (Customer customer : list) {
              System.out.println(customer);
         }
         transaction.commit();
     }
1.5Hibernate的查询方式：SQL检索
SQL查询
SQL查询：通过使用sql语句进行查询
packagetop.yangxianyang.demo1;
import java.util.Arrays;
importjava.util.List;
importorg.hibernate.SQLQuery;
importorg.hibernate.Session;
importorg.hibernate.Transaction;
importorg.junit.Test;
importtop.yangxianyang.entity.Customer;
importtop.yangxianyang.utils.HibernateUtils;
/**
 *SQL查询
 * @author yxy
 *
 */
publicclass HibernateTest3 {
 @Test
 publicvoiddemo1(){
         Sessionsession = HibernateUtils.getCurrentSession();
         Transactiontx = session.beginTransaction();
 /*SQLQuery sqlQuery = session.createSQLQuery("select * fromcst_customer");
         List<Object[]>list = sqlQuery.list();
         for(Object[] objects : list) {
              System.out.println(Arrays.toString(objects));
         }*/
         SQLQuerysqlQuery = session.createSQLQuery("select* from cst_customer");
         sqlQuery.addEntity(Customer.class);
         List<Customer>list = sqlQuery.list();
 for (Customer customer : list) {
              System.out.println(customer);
         }
         tx.commit();
     }
}

2Hibernate的抓取策略（优化）

2.1延迟加载的概述

2.1.1什么是延迟加载

延迟加载：lazy（懒加载）。执行到该行代码的时候，不会发送语句去进行查询，在真正使用这个对象的属性的时候才会发送SQL语句进行查询。

2.1.2延迟加载的分类

l 类级别的延迟加载

n 指的是通过load方法查询某个对象的时候，是否采用延迟。session.load(Customer.class,1l);

n 类级别延迟加载通过<class>上的lazy进行配置，如果让lazy失效

u 将lazy设置为false

u 将持久化类使用final修饰

u Hibernate. Initialize()

packagetop.yangxianyang.demo1;
importorg.hibernate.Hibernate;
importorg.hibernate.Session;
importorg.hibernate.Transaction;
importorg.junit.Test;
importtop.yangxianyang.entity.Customer;
importtop.yangxianyang.utils.HibernateUtils;
/**
 * Hibernate的延迟加载
 * @author yxy
 *
 */
publicclass HibernateTest4 {
 @Test
 /**
      * 类级别的延迟加载
      * * 在<class>的标签上配置的lazy
      */
 publicvoiddemo1(){
         Sessionsession = HibernateUtils.getCurrentSession();
         Transactiontx = session.beginTransaction();
         Customercustomer = session.load(Customer.class,1l);
         Hibernate.initialize(customer);
         System.out.println(customer);
         tx.commit();
     }
}

l 关联级别的延迟加载

n 指的是在查询到某个对象的时候，查询其关联的对象的时候，是否采用延迟加载。

Customercustomer = session.get(Customer.class,1l);

customer.getLinkMans();----通过客户获得联系人的时候，联系人对象是否采用了延迟加载，称为是关联级别的延迟。

n 抓取策略往往会和关联级别的延迟加载一起使用，优化语句。

2.2抓取策略

2.2.1抓取策略的概述

l 通过一个对象抓取到关联对象需要发送SQL语句，SQL语句如何发送，发送成什么样格式通过策略进行配置。

n 通过<set>或者<many-to-one>上通过fetch属性进行设置

n fetch和这些标签上的lazy如何设置优化发送的SQL语句

2.2.2<set>上的fetch和lazy

l fetch：抓取策略，控制SQL语句格式

n select ：默认值，发送普通的select语句，查询关联对象

n join ：发送一条迫切左外连接查询关联对象

n subselect ：发送一条子查询查询其关联对象

l lazy：延迟加载，控制查询关联对象的时候是否采用延迟

n true ：默认值，查询关联对象的时候，采用延迟加载

n false ：查询关联对象的时候，不采用延迟加载

n extra ：及其懒惰。

l 在实际开发中，一般都采用默认值。如果有特殊的需求，可能需要配置join。

packagetop.yangxianyang.demo1;
importjava.util.List;
importorg.hibernate.Session;
importorg.hibernate.Transaction;
importorg.junit.Test;
importtop.yangxianyang.entity.Customer;
importtop.yangxianyang.entity.LinkMan;
importtop.yangxianyang.utils.HibernateUtils;
/**
 * 在<set>上的fetch和lazy
 * @author yxy
 *
 */
publicclass HibernateTest5 {
 @Test
 /**
      * 默认情况：
      */
 publicvoiddemo1(){
         Sessionsession = HibernateUtils.getCurrentSession();
         Transactiontx = session.beginTransaction();
 // 查询1号客户
         Customercustomer = session.get(Customer.class,1l);// 发送一条查询客户的SQL
         System.out.println(customer.getCust_name());
 // 查看1号客户的每个联系人的信息
 for (LinkMan linkMan : customer.getLinkMans()) {// 发送一条根据客户ID查询联系人的SQL
              System.out.println(linkMan.getLkm_name());
         }
         tx.commit();
     }
 @Test
 /**
      * 设置fetch="select" lazy="true"
      */
 publicvoiddemo2(){
         Sessionsession = HibernateUtils.getCurrentSession();
         Transactiontx = session.beginTransaction();
 // 查询1号客户
         Customercustomer = session.get(Customer.class,1l);// 发送一条查询客户的SQL
         System.out.println(customer.getCust_name());
 // 查看1号客户的每个联系人的信息
 for (LinkMan linkMan : customer.getLinkMans()) {// 发送一条根据客户ID查询联系人的SQL
              System.out.println(linkMan.getLkm_name());
         }
         tx.commit();
     }
 @Test
 /**
      * 设置  fetch="select"lazy="false"
      */
 publicvoiddemo3(){
         Sessionsession = HibernateUtils.getCurrentSession();
         Transactiontx = session.beginTransaction();
 // 查询1号客户
         Customercustomer = session.get(Customer.class,1l);// 发送两条SQL语句：查询客户的名称，查询客户关联联系人
         System.out.println(customer.getCust_name());
 /*// 查看1号客户的每个联系人的信息
         for(LinkMan linkMan : customer.getLinkMans()) {// 
              System.out.println(linkMan.getLkm_name());
         }*/
         System.out.println(customer.getLinkMans().size());
         tx.commit();
     }
 @Test
 /**
      * 设置fetch="select" lazy="extra"
      */
 publicvoiddemo4(){
         Sessionsession = HibernateUtils.getCurrentSession();
         Transactiontx = session.beginTransaction();
 // 查询1号客户
         Customercustomer = session.get(Customer.class,1l);// 发送一条查询1号客户的SQL语句
         System.out.println(customer.getCust_name());
         System.out.println(customer.getLinkMans().size());// 发送一条select count() from ...;
         tx.commit();
     }
 @Test
 /**
      * 设置fetch="join" lazy=失效
      */
 publicvoiddemo5(){
         Sessionsession = HibernateUtils.getCurrentSession();
         Transactiontx = session.beginTransaction();
 // 查询1号客户
         Customercustomer = session.get(Customer.class,1l);// 发送一条迫切左外连接查询记录
         System.out.println(customer.getCust_name());
         System.out.println(customer.getLinkMans().size());// 不发送
         tx.commit();
     }
 @SuppressWarnings("unchecked")
 @Test
 /**
      * 设置fetch="subselect" lazy="true"
      */
 publicvoiddemo6(){
         Sessionsession = HibernateUtils.getCurrentSession();
         Transactiontx = session.beginTransaction();
         List<Customer>list = session.createQuery("fromCustomer").list();// 发送查询所有客户的SQL
 for (Customer customer : list) {
              System.out.println(customer.getCust_name());
              System.out.println(customer.getLinkMans().size());// 发送一条子查询
         }
         tx.commit();
     }
 @SuppressWarnings("unchecked")
 @Test
 /**
      * 设置fetch="subselect" lazy="false"
      */
 publicvoiddemo7(){
         Sessionsession = HibernateUtils.getCurrentSession();
         Transactiontx = session.beginTransaction();
         List<Customer>list = session.createQuery("fromCustomer").list();// 发送查询所有客户的SQL，发送一条子查询
 for (Customer customer : list) {
              System.out.println(customer.getCust_name());
              System.out.println(customer.getLinkMans().size());// 
         }
         tx.commit();
     }
}

2.2.3<many-to-one>上的fetch和lazy

l fetch ：抓取策略，控制SQL语句格式。

n select ：默认值，发送普通的select语句，查询关联对象。

n join ：发送一条迫切左外连接。

l lazy ：延迟加载，控制查询关联对象的时候是否采用延迟。

n proxy ：默认值，proxy具体的取值，取决于另一端的<class>上的lazy的值。

n false ：查询关联对象，不采用延迟。

n no-proxy ：（不会使用）