Hibernate入门4

HIbernate的导航查询：

　　适用场景：当一张A表关联到另一张B表的多条记录，存在一对多的关系（或者多对多），那么查询A表的记录时，就可以将A表某条记录关联的B表的所有记录查询出来，这种方式，就叫做Hibernate的导航查询（如：一张客户表，一张联系人表，客户表存在一条记录是百度公司的，而在联系人表中对应着多条联系人的记录，而在定义实体类的时候，客户实体类中就进行绑定联系人类用了一个Set进行绑定，因此在查询某个客户的时候，对应的此客户下的联系人Set集合中的数据也就一并查找出来了，这种查询的方式，就叫做导航查询）。

代码片段：

 // Hibernate的对象导航查询
     @Test
     public void fun1() {
         Transaction ts = null;
         Session session = null;
         SessionFactory factory = null;
         try {
             factory = Tools.getSessionFactory();
             session = factory.openSession();
             ts = session.beginTransaction();
             // 通过id找到对应的数据记录
             Customer customer = session.get(Customer.class, "4028db335e71d646015e71d64c8e0000");
             Set<LinkMan> sets = customer.getMans();
             System.out.println(customer.getCustName()+"的联系人人数为： "+sets.size());
             System.out.println("联系人具体的详情：");
             for(LinkMan man : sets) {
                 System.out.println(man);
             }
             ts.commit();
         } catch (Exception e) {
             ts.rollback();
             e.printStackTrace();
         } finally {
             session.close();
         }
     }

运行截图：

OID查询：

　　oid查询，就是根据id查询记录，调用的是Session的get()方法，这种方式比较简单，代码见下：

 // 通过id找到对应的数据记录
    Customer customer = session.get(Customer.class, "4028db335e71d646015e71d64c8e0000");

HIbernate的HQL查询方式：

　　HQL：HIbernate Query Language，由HIbernate提供的一种查询语言，HQL语言和普通sql很相似，两者的区别在于：sql操作的是数据库表和表的字段，hql操作的是实体类和实体类的属性。

　　使用HQL进行查询操作的步骤(使用Query对象进行操作):

　　　　1. 创建Query对象，写hql语句

　　　　2. 调用query对象里面的方法得到结果

HQL查询所有代码片段：

 /**
  * 查询：HQL查询
  *
  * @author Geore
  *
  */
 public class TestDemo6 {
     @Test
     // 查询所有
     public void fun1() {
         Transaction ts = null;
         Session session = null;
         SessionFactory factory = null;
         try {
             factory = Tools.getSessionFactory();
             session = factory.openSession();
             ts = session.beginTransaction();

             // 得到Query对象，通过session的createQuery方法(写hql语句)
             Query query = session.createQuery("from Customer");
             // 得到查询的结果
             List<Customer> list = query.list();
             for (Customer cust : list) {
                 System.out.println(cust.getCustName() + "--"
                         + cust.getCustSource() + "--联系人数："
                         + cust.getMans().size());
             }

             ts.commit();
         } catch (Exception e) {
             ts.rollback();
             e.printStackTrace();
         } finally {
             session.close();
         }
     }
 }

HQL查询所有的hql语句： from pojo类；

运行截图：

HQL的条件查询操作：

 @Test
     // hql条件查询
     public void fun2() {
         Transaction ts = null;
         Session session = null;
         SessionFactory factory = null;
         try {
             factory = Tools.getSessionFactory();
             session = factory.openSession();
             ts = session.beginTransaction();

             // 得到Query对象，通过session的createQuery方法(写hql语句)
             Query query = session.createQuery("from Customer where custLevel=?");
             // 设置占位符的值
             query.setParameter(0, "svip");
             // 查询，并得到结果集
             List<Customer> list = query.list();
             // 便利输出结果集合
             for (Customer cust : list) {
                 System.out.println(cust.getCustName() + "--"
                         + cust.getCustSource() + "--联系人数："
                         + cust.getMans().size());
             }
             ts.commit();
         } catch (Exception e) {
             ts.rollback();
             e.printStackTrace();
         } finally {
             session.close();
         }
     }
 -正常条件查询

-条件查询

 @Test
     // hql的模糊查询
     public void fun3() {
         Transaction ts = null;
         Session session = null;
         SessionFactory factory = null;
         try {
             factory = Tools.getSessionFactory();
             session = factory.openSession();
             ts = session.beginTransaction();

             // 得到Query对象，通过session的createQuery方法(写hql语句)
             Query query = session.createQuery("from Customer where custLevel like ?");
             // 设置占位符的值
             query.setParameter(0, "%sv%");
             // 查询，并得到结果集
             List<Customer> list = query.list();
             // 便利输出结果集合
             for (Customer cust : list) {
                 System.out.println(cust.getCustName() + "--"
                         + cust.getCustSource() + "--联系人数："
                         + cust.getMans().size());
             }
             ts.commit();
         } catch (Exception e) {
             ts.rollback();
             e.printStackTrace();
         } finally {
             session.close();
         }
     }

-模糊查询

HQL的条件查询的hql语句：

 条件查询：
 FROM 实体类名称 WHERE 实体类属性名称1=? and 实体类属性名称n=?

 模糊查询：
 FROM 实体类名称 WHERE 实体类属性名称 LIKE ?

运行截图：

HQL的排序查询：

排序代码片段：

 @Test
     // hql的排序查询
     public void fun4() {
         Transaction ts = null;
         Session session = null;
         SessionFactory factory = null;
         try {
             factory = Tools.getSessionFactory();
             session = factory.openSession();
             ts = session.beginTransaction();

             // 得到Query对象，通过session的createQuery方法(写hql语句)
             Query query = session.createQuery("from LinkMan order by linkName desc");
             // 查询，并得到结果集
             List<LinkMan> list = query.list();
             // 便利输出结果集合
             for (LinkMan man : list) {
                 System.out.println(man.getLinkName() + " -- " + man.getLid());
             }
             ts.commit();
         } catch (Exception e) {
             ts.rollback();
             e.printStackTrace();
         } finally {
             session.close();
         }
     }

HQL的排序语句写法：

 FROM 实体类名称 ORDER BY 实体类属性名称 ASC/DESC

运行截图（按照字母倒序在排）：

HQL的分页查询：

　　在hql操作中，在语句里面不能写limit，hibernate的Query对象中封装了两个方法实现分页操作。

分页查询代码片段：

 @Test
     // 分页查询
     public void fun5() {
         Transaction ts = null;
         Session session = null;
         SessionFactory factory = null;
         try {
             factory = Tools.getSessionFactory();
             session = factory.openSession();
             ts = session.beginTransaction();

             // 得到Query对象，通过session的createQuery方法(写hql语句)
             Query query = session.createQuery("from LinkMan");
             // 设置分页查询的起始位置
             query.setFirstResult(0);
             query.setMaxResults(2);
             // 得到查询的结果
             List<LinkMan> list = query.list();
             for (LinkMan man : list) {
                 System.out.println(man.getLid() + " -- " + man.getLinkName());
             }

             ts.commit();
         } catch (Exception e) {
             ts.rollback();
             e.printStackTrace();
         } finally {
             session.close();
         }
     }

运行截图：

HQL投影查询：

　　查询的不是表的所有字段，而是部分字段的值

代码片段：

 @Test
     // 投影查询
     public void fun6() {
         Transaction ts = null;
         Session session = null;
         SessionFactory factory = null;
         try {
             factory = Tools.getSessionFactory();
             session = factory.openSession();
             ts = session.beginTransaction();

             // 得到Query对象，通过session的createQuery方法(写hql语句)
             Query query = session.createQuery("select linkName from LinkMan");
             // 得到查询的结果
             List<Object> list = query.list();
             for (Object man : list) {
                 System.out.println(man);
             }

             ts.commit();
         } catch (Exception e) {
             ts.rollback();
             e.printStackTrace();
         } finally {
             session.close();
         }
     }

投影查询的hql语句　

 SELECT 实体类属性名1,实体类属性名2...实体类属性名n FROM 实体类名称（select后不能写*号）

运行截图：

HQL的聚集函数的使用：

　　在数据库的操作中存在很多的聚合函数，如count，max，min等。同时在hql也提供了聚合函数的支持，和sql的一样。

count聚集函数代码片段：

 @Test
     // 聚集函数的使用
     public void fun7() {
         Transaction ts = null;
         Session session = null;
         SessionFactory factory = null;
         try {
             factory = Tools.getSessionFactory();
             session = factory.openSession();
             ts = session.beginTransaction();

             // 得到Query对象，通过session的createQuery方法(写hql语句)
             Query query = session.createQuery("select count(*) from LinkMan");
             // 得到查询的结果
             Object obj = query.uniqueResult();
             System.out.println("t_linkman表有： " + obj + " 条记录。");

             ts.commit();
         } catch (Exception e) {
             ts.rollback();
             e.printStackTrace();
         } finally {
             session.close();
         }
     }

运行截图：

Hibernate的QBC查询：

　　使用QBC查询的话，不需要使用HQL语句了，而是通过方法进行实现，QBC查询操作的是实体类和属性，要使用QBC进行查询，那么就必须了解到Criteria类的使用。

QBC查询所有：

代码片段：

 // 查询所有
 @Test
     public void fun1() {
         SessionFactory factory = null;
         Session session = null;
         Transaction tx = null;
         try {
             factory = Tools.getSessionFactory();
             session = factory.openSession();
             tx = session.beginTransaction();

             // 得到Criteria
             Criteria criteria = session.createCriteria(Customer.class);
             // 进行查询，得到Customer的集合结果集
             List<Customer> list = criteria.list();
             // 遍历输出
             for(Customer customer : list) {
                 System.out.println(customer.getCid() + " -- " + customer.getCustName());
             }
             tx.commit();
         } catch(Exception e){
             tx.rollback();
             e.printStackTrace();
         } finally {
             session.close();
         }
     }

运行截图：

QBC的条件查询：

　　QBC的条件查询需要进行条件的绑定，而进行条件绑定则需要使用到Criteria类的add()方法，并且在add方法中进行条件绑定，而add方法中则需要传人一个参数，我们只需要在add中使用Restrictions类的静态方法来进行条件绑定即可，Restrictions类的主要的方法，如下：

代码片段：

 @Test
     // QBC条件查询，条件查询要使用到一个类：Restrictions,这个类用来绑定条件
     public void fun2() {
         SessionFactory factory = null;
         Session session = null;
         Transaction tx = null;
         try {
             factory = Tools.getSessionFactory();
             session = factory.openSession();
             tx = session.beginTransaction();

             // 得到Criteria
             Criteria criteria = session.createCriteria(Customer.class);
             // 进行条件查询，设置条件值
             criteria.add(Restrictions.eq("custName", "Geore"));
             // 进行查询得到结果集
             List<Customer> list = criteria.list();
             // 遍历输出
             for(Customer customer : list) {
                 System.out.println(customer.getCid() + " -- " + customer.getCustName());
             }
             tx.commit();
         } catch(Exception e){
             tx.rollback();
             e.printStackTrace();
         } finally {
             session.close();
         }
     }

运行截图：

QBC的排序查询：

　　QBC的排序查询：使用Criteria类的addOrder()方法，在addOrder()中需要传入参数Order对象，而Order类有两个方法asc()和desc()，分别对应的就是升序和降序的方法。

代码片段：

 @Test
     // QBC排序查询
     public void fun3() {
         SessionFactory factory = null;
         Session session = null;
         Transaction tx = null;
         try {
             factory = Tools.getSessionFactory();
             session = factory.openSession();
             tx = session.beginTransaction();

             // 得到Criteria
             Criteria criteria = session.createCriteria(Customer.class);
             // 进行排序查询
             criteria.addOrder(Order.asc("cid"));  // 升序
             // criteria.addOrder(Order.desc("")); 降序
             // 进行查询得到结果集
             List<Customer> list = criteria.list();
             // 遍历输出
             for(Customer customer : list) {
                 System.out.println(customer.getCid() + " -- " + customer.getCustName());
             }
             tx.commit();
         } catch(Exception e){
             tx.rollback();
             e.printStackTrace();
         } finally {
             session.close();
         }
     }

运行截图：

QBC的分页查询：

　　使用两个方法：setFirstResult(0) 设置起始位置 和 setMaxResults(2) 设置每页最大数

代码片段：

 @Test
     // QBC分页查询
     public void fun4() {
         SessionFactory factory = null;
         Session session = null;
         Transaction tx = null;
         try {
             factory = Tools.getSessionFactory();
             session = factory.openSession();
             tx = session.beginTransaction();

             // 得到Criteria
             Criteria criteria = session.createCriteria(Customer.class);
             // 进行分页查询
             criteria.setFirstResult(0); // 设置起始位置
             criteria.setMaxResults(2);    // 设置每页最大数

             // 进行查询得到结果集
             List<Customer> list = criteria.list();
             // 遍历输出
             for(Customer customer : list) {
                 System.out.println(customer.getCid() + " -- " + customer.getCustName());
             }
             tx.commit();
         } catch(Exception e){
             tx.rollback();
             e.printStackTrace();
         } finally {
             session.close();
         }
     }

运行截图：

QBC的聚合函数：

　　对于QBC的聚合函数的查询，使用Criteria类的setProjection()方法，在setProjection()方法中使用Projections类调用这个类的方法即可实现聚合函数的查询，Projections的方法如下：

代码片段：

 @Test
     // QBC聚合函数
     public void fun5() {
         SessionFactory factory = null;
         Session session = null;
         Transaction tx = null;
         try {
             factory = Tools.getSessionFactory();
             session = factory.openSession();
             tx = session.beginTransaction();

             // 得到Criteria
             Criteria criteria = session.createCriteria(Customer.class);
             // 进行统计查询
             criteria.setProjection(Projections.rowCount());
             Object obj = criteria.uniqueResult();
             System.out.println(obj);

             tx.commit();
         } catch(Exception e){
             tx.rollback();
             e.printStackTrace();
         } finally {
             session.close();
         }
     }

运行截图：

QBC的离线查询：

　　QBC离线查询使用的是DetachedCriteria类，并使用此类的forClass()静态方法创建这个类的对象，并在最终执行查询的时候，使用Session，得到Criteria。

代码片段：

 @Test
     // QBC离线查询
     public void fun6() {
         SessionFactory factory = null;
         Session session = null;
         Transaction tx = null;
         try {
             factory = Tools.getSessionFactory();
             session = factory.openSession();
             tx = session.beginTransaction();

             // 离线查询使用的是DetachedCriteria类，并使用此类的forClass()静态方法创建这个类的对象
             DetachedCriteria dCriteria = DetachedCriteria.forClass(Customer.class);
             // 在最终执行查询的时候，使用Session，得到Criteria
             Criteria criteria = dCriteria.getExecutableCriteria(session);
             // 得到查询的结果集
             List<Customer> list = criteria.list();
             // 便利输出
             for(Customer customer : list) {
                 System.out.println(customer.getCid() + " -- " + customer.getCustName());
             }
             tx.commit();
         } catch(Exception e){
             tx.rollback();
             e.printStackTrace();
         } finally {
             session.close();
         }
     }

运行截图：