Hibernate第四天:Hibernate的查询方式、抓取策略

目录

1Hibernate的查询的方式

1.1Hibernate的查询方式:OID查询

1.1.1使用get方法

1.1.2使用load方法

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

1.3Hibernate的查询方式:HQL检索

1.3.1初始化一些数据

1.3.2HQL的简单查询

1.3.3HQL的别名查询

1.3.4HQL的排序查询

1.3.5HQL的条件查询

1.3.6HQL的投影查询

1.3.7HQL的分页查询

1.3.8HQL的分组统计查询

1.3.9HQL的多表查询

1.4Hibernate的查询方式:QBC检索

1.4.1简单查询

1.4.2排序查询

1.4.3分页查询

1.4.4条件查询

1.4.5统计查询

1.4.6离线条件查询(SSH)---DetachedCriteria

1.5Hibernate的查询方式:SQL检索

2Hibernate的抓取策略(优化)

2.1延迟加载的概述

2.1.1什么是延迟加载

2.1.2延迟加载的分类

2.2抓取策略

2.2.1抓取策略的概述

2.2.2上的fetch和lazy

2.2.3上的fetch和lazy

2.3批量抓取

2.3.1什么是批量抓取

2.3.2测试批量抓取


 

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查询:Hibernate Query Language,Hibernate的查询语言,是一种面向对象的方式的查询语言,语法类似SQL。通过session.createQuery(),用于接收一个HQL进行查询方式。

1.3.1初始化一些数据

 


 

@Test

    /**

     * 初始化数据

     */

    public void 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的简单查询

     */

    public void 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 (Customer customer : list) {

            System.out.println(customer);

        }

        tx.commit();

    }



1.3.3HQL的别名查询


@Test

    /**

     * 别名查询

     */

    public void 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 (Customer customer : list) {

            System.out.println(customer);

        }

        tx.commit();

    }



1.3.4HQL的排序查询

@Test

    /**

     * 排序查询

     */

    public void demo4() {

        Session session = HibernateUtils.getCurrentSession();

        Transaction tx = session.beginTransaction();

        // 排序的查询

        // 默认情况

        // List<Customer> list = session.createQuery("from Customer order by

        // cust_id").list();

        // 设置降序排序 升序使用asc 降序使用desc

        List<Customer> list = session.createQuery("from Customer order by cust_id desc").list();



        for (Customer customer : list) {

            System.out.println(customer);

        }

        tx.commit();

    }



1.3.5HQL的条件查询


@Test

    /**

     * 条件查询

     */

    public void 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 and cust_name like :bbb");

        // 设置参数:

        query.setParameter("aaa", "朋友推荐");

        query.setParameter("bbb", "李%");

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



        for (Customer customer : list) {

            System.out.println(customer);

        }

        tx.commit();

    }

1.3.6HQL的投影查询

投影查询:查询对象的某个或某些属性。


     @Test

     /**

      * 投影查询

      */

     public void demo6() {

         Session session = HibernateUtils.getCurrentSession();

         Transaction tx = session.beginTransaction();



         // 投影查询

         // 单个属性

         /*

          * List<Object> list = session.createQuery(

          * "select c.cust_name from Customer c").list(); for (Object object :

          * list) { System.out.println(object); }

          */



         // 多个属性:

         /*

          * List<Object[]> list = session.createQuery(

          * "select c.cust_name,c.cust_source from Customer c").list(); for

          * (Object[] objects : list) {

          * System.out.println(Arrays.toString(objects)); }

          */



         // 查询多个属性,但是我想封装到对象中。

         List<Customer> list = session.createQuery("select new Customer(cust_name,cust_source) from Customer").list();

         for (Customer customer : list) {

              System.out.println(customer);

         }

         tx.commit();

     }





1.3.7HQL的分页查询


@Test

     /**

      * 分页查询

      */

     public void demo7() {

         Session session = HibernateUtils.getCurrentSession();

         Transaction tx = session.beginTransaction();



         // 分页查询

         Query query = session.createQuery("from LinkMan");

         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

     /**

      * 分组统计查询

      */

     public void demo8() {

         Session session = HibernateUtils.getCurrentSession();

         Transaction tx = session.beginTransaction();



         // 聚合函数的使用:count(),max(),min(),avg(),sum()

         Object object = session.createQuery("select count(*) from Customer").uniqueResult();

         System.out.println(object);

         // 分组统计:

         List<Object[]> list = session.createQuery("select cust_source,count(*) from Customer group by cust_source").list();

         for (Object[] objects : list) {

              System.out.println(Arrays.toString(objects));

         }

         tx.commit();

     }





1.3.9HQL的多表查询

  1. SQL的多表查询
    1. 连接查询
      1. 交叉连接:笛卡尔积

select * from A,B;

      1. 内连接     :inner join (inner 可以省略)
        1. 隐式内连接:

select * from A,B where A.id = B.aid;

        1. 显示内连接:

select * from A inner join B on A.id = B.aid;

      1.  外连接  :
        1. 左外连接:left outer join(outer 可以省略)

select * from A left outer join B on A.id= B.aid;

        1. 右外连接:right outer join(outer 可以省略)

select * from A right outer join B on A.id = B.aid;

    1. 子查询

 

  1. HQL的多表查询
    1. 连接查询
      1. 交叉连接
      2. 内连接
        1. 显示内连接
        2. 隐式内连接
        3. 迫切内连接
      3. 外连接
        1. 左外连接
        2. 右外连接
        3. 迫切左外连接


 

@Test

     /**

      * HQL的多表查询

      */

     public void demo9() {

         Session session = HibernateUtils.getCurrentSession();

         Transaction tx = 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 join c.linkMans

         /*

          * List<Object[]> list = session.createQuery(

          * "from Customer c inner join c.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("select distinct 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

     /**

      * 简单的查询

      */

     public void demo1(){

         Session session = HibernateUtils.getCurrentSession();

         Transaction tx = session.beginTransaction();

        

         // 获得Criteria的对象

         Criteria criteria = session.createCriteria(Customer.class);

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

        

         for (Customer customer : list) {

              System.out.println(customer);

         }

         tx.commit();

     }

 

1.4.2排序查询


 

@Test

     /**

      * 排序查询

      */

     public void demo2(){

         Session session = HibernateUtils.getCurrentSession();

         Transaction tx = session.beginTransaction();

        

         // 排序查询

         Criteria criteria = 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

     /**

      * 分页查询

      */

     public void demo3(){

         Session session = HibernateUtils.getCurrentSession();

         Transaction tx = session.beginTransaction();

        

         // 分页查询

         Criteria criteria = 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

     /**

      * 条件查询

      */

     public void demo4(){

         Session session = HibernateUtils.getCurrentSession();

         Transaction tx = session.beginTransaction();

        

         // 条件查询

         Criteria criteria = 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

     /**

      * 统计查询

      */

     public void demo5(){

         Session session = HibernateUtils.getCurrentSession();

         Transaction tx = session.beginTransaction();

        

         Criteria criteria = session.createCriteria(Customer.class);

         /**

          * add                 :普通的条件。where后面条件

          * addOrder            :排序

          * setProjection   :聚合函数 和 group by having

          */

         criteria.setProjection(Projections.rowCount());

         Long num = (Long) criteria.uniqueResult();

         System.out.println(num);

         tx.commit();

     }

1.4.6离线条件查询(SSH)---DetachedCriteria

 

@Test

     /**

      * 离线条件查询

      */

     public void demo6(){

         DetachedCriteria detachedCriteria = 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语句进行查询


 

package top.yangxianyang.demo1;



import java.util.Arrays;

import java.util.List;



import org.hibernate.SQLQuery;

import org.hibernate.Session;

import org.hibernate.Transaction;

import org.junit.Test;



import top.yangxianyang.entity.Customer;

import top.yangxianyang.utils.HibernateUtils;





/**

 * SQL查询

 * @author yxy

 *

 */

public class HibernateTest3 {



     @Test

     public void demo1(){

         Session session = HibernateUtils.getCurrentSession();

         Transaction tx = session.beginTransaction();

        

         /*SQLQuery sqlQuery = session.createSQLQuery("select * from cst_customer");

         List<Object[]> list = sqlQuery.list();

         for (Object[] objects : list) {

              System.out.println(Arrays.toString(objects));

         }*/

        

         SQLQuery sqlQuery = 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延迟加载的分类

  1. 类级别的延迟加载
    1. 指的是通过load方法查询某个对象的时候,是否采用延迟。session.load(Customer.class,1l);
    2. 类级别延迟加载通过<class>上的lazy进行配置,如果让lazy失效
      1. 将lazy设置为false
      2. 将持久化类使用final修饰
      3. Hibernate. Initialize()


 

package top.yangxianyang.demo1;



import org.hibernate.Hibernate;

import org.hibernate.Session;

import org.hibernate.Transaction;

import org.junit.Test;



import top.yangxianyang.entity.Customer;

import top.yangxianyang.utils.HibernateUtils;





/**

 * Hibernate的延迟加载

 * @author yxy

 *

 */

public class HibernateTest4 {



     @Test

     /**

      * 类级别的延迟加载

      * * 在<class>的标签上配置的lazy

      */

     public void demo1(){

         Session session = HibernateUtils.getCurrentSession();

         Transaction tx = session.beginTransaction();

        

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

         Hibernate.initialize(customer);

         System.out.println(customer);

        

         tx.commit();

     }

}

  1. 关联级别的延迟加载
    1. 指的是在查询到某个对象的时候,查询其关联的对象的时候,是否采用延迟加载。

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

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

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

2.2抓取策略

2.2.1抓取策略的概述

  1. 通过一个对象抓取到关联对象需要发送SQL语句,SQL语句如何发送,发送成什么样格式通过策略进行配置。
    1. 通 过<set>或者<many-to-one>上通过fetch属性进行设置
    2. fetch和这些标签上的lazy如何设置优化发送的SQL语句

2.2.2<set>上的fetch和lazy

  1. fetch:抓取策略,控制SQL语句格式
    1. select                 :默认值,发送普通的select语句,查询关联对象
    2. join                     :发送一条迫切左外连接查询关联对象
    3. subselect          :发送一条子查询查询其关联对象
  2. lazy:延迟加载,控制查询关联对象的时候是否采用延迟
    1. true                    :默认值,查询关联对象的时候,采用延迟加载
    2. false                            :查询关联对象的时候,不采用延迟加载
    3. extra                  :及其懒惰。
  3. 在实际开发中,一般都采用默认值。如果有特殊的需求,可能需要配置join


 

package top.yangxianyang.demo1;



import java.util.List;



import org.hibernate.Session;

import org.hibernate.Transaction;

import org.junit.Test;



import top.yangxianyang.entity.Customer;

import top.yangxianyang.entity.LinkMan;

import top.yangxianyang.utils.HibernateUtils;





/**

 * 在<set>上的fetch和lazy

 * @author yxy

 *

 */

public class HibernateTest5 {



     @Test

     /**

      * 默认情况:

      */

     public void demo1(){

         Session session = HibernateUtils.getCurrentSession();

         Transaction tx = session.beginTransaction();

        

         // 查询1号客户

         Customer customer = 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"

      */

     public void demo2(){

         Session session = HibernateUtils.getCurrentSession();

         Transaction tx = session.beginTransaction();

        

         // 查询1号客户

         Customer customer = 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"

      */

     public void demo3(){

         Session session = HibernateUtils.getCurrentSession();

         Transaction tx = session.beginTransaction();

        

         // 查询1号客户

         Customer customer = 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"

      */

     public void demo4(){

         Session session = HibernateUtils.getCurrentSession();

         Transaction tx = session.beginTransaction();

        

         // 查询1号客户

         Customer customer = 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=失效

      */

     public void demo5(){

         Session session = HibernateUtils.getCurrentSession();

         Transaction tx = session.beginTransaction();

        

         // 查询1号客户

         Customer customer = 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"

      */

     public void demo6(){

         Session session = HibernateUtils.getCurrentSession();

         Transaction tx = session.beginTransaction();

        

         List<Customer> list = session.createQuery("from Customer").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"

      */

     public void demo7(){

         Session session = HibernateUtils.getCurrentSession();

         Transaction tx = session.beginTransaction();

        

         List<Customer> list = session.createQuery("from Customer").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

  1. fetch :抓取策略,控制SQL语句格式。
    1. select       :默认值,发送普通的select语句,查询关联对象。
    2. join            :发送一条迫切左外连接。
  2. lazy   :延迟加载,控制查询关联对象的时候是否采用延迟。
    1. proxy        :默认值,proxy具体的取值,取决于另一端的<class>上的lazy的值。
    2. false                   :查询关联对象,不采用延迟。
    3. no-proxy  :(不会使用)
  3. 在实际开发中,一般都采用默认值。如果有特殊的需求,可能需要配置join


 

package top.yangxianyang.demo1;



import org.hibernate.Session;

import org.hibernate.Transaction;

import org.junit.Test;



import top.yangxianyang.entity.LinkMan;

import top.yangxianyang.utils.HibernateUtils;





/**

 * many-to-one上的fetch和lazy测试

 * @author yxy

 *

 */

public class HibernateTest6 {



     @Test

     /**

      * 默认值

      */

     public void demo1(){

         Session session = HibernateUtils.getCurrentSession();

         Transaction tx = session.beginTransaction();

        

         LinkMan linkMan = session.get(LinkMan.class, 1l);// 发送一条查询联系人语句

         System.out.println(linkMan.getLkm_name());

         System.out.println(linkMan.getCustomer().getCust_name());// 发送一条select语句查询联系人所关联的客户

        

         tx.commit();

     }

    

     @Test

     /**

      * fetch="select" lazy="proxy"

      */

     public void demo2(){

         Session session = HibernateUtils.getCurrentSession();

         Transaction tx = session.beginTransaction();

        

         LinkMan linkMan = session.get(LinkMan.class, 1l);// 发送一条查询联系人语句

         System.out.println(linkMan.getLkm_name());

         System.out.println(linkMan.getCustomer().getCust_name());// 发送一条select语句查询联系人所关联的客户

        

         tx.commit();

     }

    

     @Test

     /**

      * fetch="select" lazy="false"

      */

     public void demo3(){

         Session session = HibernateUtils.getCurrentSession();

         Transaction tx = session.beginTransaction();

        

         LinkMan linkMan = session.get(LinkMan.class, 1l);// 发送一条查询联系人语句,发送一条select语句查询联系人所关联的客户

         System.out.println(linkMan.getLkm_name());

         System.out.println(linkMan.getCustomer().getCust_name());//

        

         tx.commit();

     }

    

     @Test

     /**

      * fetch="join" lazy=失效

      */

     public void demo4(){

         Session session = HibernateUtils.getCurrentSession();

         Transaction tx = session.beginTransaction();

        

         LinkMan linkMan = session.get(LinkMan.class, 1l);// 发送一条迫切左外连接查询联系人所关联的客户。

         System.out.println(linkMan.getLkm_name());

         System.out.println(linkMan.getCustomer().getCust_name());//

        

         tx.commit();

     }

}

2.3批量抓取

2.3.1什么是批量抓取

一批关联对象一起抓取,batch-size

2.3.2测试批量抓取


package top.yangxianyang.demo1;



import java.util.List;



import org.hibernate.Session;

import org.hibernate.Transaction;

import org.junit.Test;



import top.yangxianyang.entity.Customer;

import top.yangxianyang.entity.LinkMan;

import top.yangxianyang.utils.HibernateUtils;





/**

 * 批量抓取

 * @author yxy

 *

 */

public class HibernateTest7 {



     @SuppressWarnings("unchecked")

     @Test

     /**

      * 获取客户的时候,批量抓取联系人

      * 在Customer.hbm.xml中set上配置batch-size

      */

     public void demo1(){

         Session session = HibernateUtils.getCurrentSession();

         Transaction tx = session.beginTransaction();

        

         List<Customer> list = session.createQuery("from Customer").list();

         for (Customer customer : list) {

              System.out.println(customer.getCust_name());

              for (LinkMan linkMan : customer.getLinkMans()) {

                  System.out.println(linkMan.getLkm_name());

              }

         }

         tx.commit();

     }

    

     @SuppressWarnings("unchecked")

     @Test

     /**

      * 获取联系人的时候,批量抓取客户

      * * 在Customer.hbm.xml中<class>上配置

      */

     public void demo2(){

         Session session = HibernateUtils.getCurrentSession();

         Transaction tx = session.beginTransaction();

        

         List<LinkMan> list = session.createQuery("from LinkMan").list();

         for (LinkMan linkMan : list) {

              System.out.println(linkMan.getLkm_name());

              System.out.println(linkMan.getCustomer().getCust_name());

         }

         tx.commit();

     }

}

 

 

源码链接:

       链接: https://pan.baidu.com/s/1FP2wVYkUJBjVqmHkGiP7og 提取码: aaeh

 

 

 

 

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 博客之星2020 设计师:CY__0809 返回首页