Hibernate(4)

妖狐艹你老母 2022-06-10 02:21 103阅读 0赞

   案例一:使用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  :不用研究