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();
        }
    }

运行截图：