Hibernate3 多对多关系

Posted 阿肯新

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Hibernate3 多对多关系相关的知识,希望对你有一定的参考价值。

学习hibernate的笔迹第三篇,主要内容:多对多关系, 检索策略,HQL查询,QBC,事物管理,c3p0配置

 

1.1.1  Hibernate的关联关系映射:(多对多)

1.1.1.1     多对多的配置:

步骤一创建实体和映射:

 1 Student:
 2 
 3 public class Student {
 4 
 5 private Integer sid;
 6 
 7 private String sname;
 8 
 9 // 学生选择多门课程.
10 
11 private Set<Course> courses = new HashSet<Course>();
12 
13 ...
14 
15 }
Student
 1 public class Course {
 2 
 3 private Integer cid;
 4 
 5 private String cname;
 6 
 7 // 课程可以被多个学生选择:
 8 
 9 private Set<Student> students = new HashSet<Student>();
10 
11 ...
12 
13 }
Course
 1 Student.hbm.xml
 2 <hibernate-mapping>
 3     <class name="cn.itcast.demo3.Student" table="student">
 4         <id name="sid" column="sid">
 5             <generator class="native"/>
 6         </id>
 7         <property name="sname" column="sname"/>
 8         <!-- 配置多对多关联关系 -->
 9         <set name="courses" table="stu_cour">
10             <key column="sno"/>
11             <many-to-many class="cn.itcast. demo3.Course" column="cno"/>
12         </set>
13     </class>
14 </hibernate-mapping>
Student.hbm.xml
 1 Course.hbm.xml
 2 <hibernate-mapping>
 3     <class name="cn.itcast. demo3.Course" table="course">
 4         <id name="cid" column="cid">
 5             <generator class="native"/>
 6         </id>
 7         
 8         <property name="cname" column="cname"/>
 9         
10         <!-- 配置多对多关联关系映射 -->
11         <set name="students" table="stu_cour">
12             <key column="cno"/>
13             <many-to-many class="cn.itcast. demo3.Student" column="sno"/>
14         </set>
15     </class>
16 </hibernate-mapping>
Course.hbm.xml

 

 

2       抓取策略(优化)

2.1   检索方式

l  立即检索:立即查询,在执行查询语句时,立即查询所有的数据。

l  延迟检索:延迟查询,在执行查询语句之后,在需要时在查询。(懒加载)

 

2.2   检查策略

l  类级别检索:当前的类的属性获取是否需要延迟。

l  关联级别的检索:当前类 关联 另一个类是否需要延迟。

 

2.3   类级别检索

l  get:立即检索。get方法一执行,立即查询所有字段的数据。

l  load:延迟检索。默认情况,load方法执行后,如果只使用OID的值不进行查询,如果要使用其他属性值将查询 。 Customer.hbm.xml  <class  lazy="true | false">

              lazy 默认值true,表示延迟检索,如果设置false表示立即检索。

 

 

 

@Test

   public void demo02() {

      //类级别

      Session session = factory.openSession();

      session.beginTransaction();

 

      //1立即

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

      //2延迟

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

     

     

     

      //打印

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

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

 

      session.getTransaction().commit();

      session.close();

   }

 

2.4   关联级别检索

2.4.1   一对多或多对多

2.4.1.1         介绍

l  容器<set> 提供两个属性:fetch、lazy

       fetch:确定使用sql格式

       lazy:关联对象是否延迟。

l  fetch:join、select、subselect

       join:底层使用迫切左外连接

       select:使用多个select语句(默认值)

       subselect:使用子查询

l  lazy:false、true、extra

       false:立即

       true:延迟(默认值)

       extra:极其懒惰

 

 

一对多的时候:

fetch         lazy       结论
-----------------------------------------------------------------------------------------------------------
select         true     默认值, 会在使用集合时加载,普通select语句
select           false     立刻使用select语句加载集合数据
select        extra     会在使用集合时加载,普通select语句,如果只是获得集合的长度,会发送Count语句查询长度.
join         true     查询集合时使用表链接查询,会立刻加载集合数据
join         false     查询集合时使用表链接查询,会立刻加载集合数据
join         extra     查询集合时使用表链接查询,会立刻加载集合数据
subselect     true     会在使用集合时加载,子查询语句
subselect     false     会在查询用户时,立即使用子查询加载客户的订单数据
subselect     extra     会在使用集合时加载,子查询语句,如果只是获得集合的长度,会发送Count语句查询长度.

 

2.4.1.2         fetch="join"

l  fetch="join" ,lazy无效。底层使用迫切左外连接,使用一条select将所有内容全部查询。

 

 

@Test

   public void demo03() {

      //关联级别:一对多,

      // * Customer.hbm.xml  <set fetch="join">

      // *** select语句使用左外连接,一次性查询所有

      Session session = factory.openSession();

      session.beginTransaction();

 

      //1 查询客户

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

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

     

      //2 查询客户订单数

      Set<Order> orderSet = customer.getOrderSet();

      System.out.println(orderSet.size());

     

      //3 查询客户订单详情

      for (Order order : orderSet) {

         System.out.println(order);

      }

     

 

      session.getTransaction().commit();

      session.close();

   }

 

2.4.1.3         fetch="select"

  当前对象   和   关联对象 使用多条select语句查询。

  lazy="false" , 立即,先查询客户select,立即查询订单select

  lazy="true",延迟,先查询客户select,需要订单时,再查询订单select

  lazy="extra",极其懒惰(延迟),先查询客户select, 如果只需要订单数,使用聚合函数(不查询详情)

 

 

 

 

 

 

 

2.4.1.4         fetch="subselect"

  将使用子查询。注意:必须使用Query否则看不到效果。

  lazy= 同上

@Test

   public void demo04() {

      //关联级别:一对多,

      // 演示3:* Customer.hbm.xml  <set fetch="subselect">

      Session session = factory.openSession();

      session.beginTransaction();

 

      //1 查询客户

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

      Customer customer = allCustomer.get(0);

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

     

      //2 查询客户订单数

      Set<Order> orderSet = customer.getOrderSet();

      System.out.println(orderSet.size());

     

      //3 查询客户订单详情

      for (Order order : orderSet) {

         System.out.println(order);

      }

     

 

      session.getTransaction().commit();

      session.close();

   }

 

 

2.4.2   多对一

2.4.2.1         介绍

  <many-to-one fetch="" lazy="">  (<one-to-one>)

  fetch取值:join、select

           join:底层使用迫切左外连接

           select:多条select语句

  lazy取值:false、proxy、no-proxy

       false:立即

       proxy:采用关联对象 类级别检索的策略。

                订单 关联 客户 (多对一)

                订单 立即获得 客户,需要在客户Customer.hbm.xml <class lazy="false">

                订单 延迟获得 客户,需要在客户Customer.hbm.xml <class lazy="true">

       no-proxy 不研究

 

fetch         lazy       结果
---------------------------------------------------
select          false      加载订单时,立即加载客户数据.普通select语句加载客户.
select          proxy     类加载策略为:lazy=false 同上
                                lazy=true 加载订单时,先不加载客户数据.使用客户数据时才加载
join           false     使用表链接查询订单以及对应客户信息.lazy属性无效
join           proxy       使用表链接查询订单以及对应客户信息.lazy属性无效

2.4.2.2         fetch="join"

  fecth="join" select语句使用左外连接,此时lazy无效。

 

@Test

   public void demo05() {

      //关联级别:多对一,

      // 演示1:* Order.hbm.xml  <set fetch="join">  lazy无效

      // * 注意:检查Customer.hbm.xml 和 Order.hbm.xml 没有额外的配置

      Session session = factory.openSession();

      session.beginTransaction();

 

      //1 查询订单

      Order order = (Order) session.get(Order.class, 1);

      System.out.println(order.getPrice());

     

      //2 查询订单客户信息

      Customer customer = order.getCustomer();

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

     

 

      session.getTransaction().commit();

      session.close();

   }

2.4.2.3         fetch="select"l 

  将采用多条select语句,lazy="proxy"是否延迟,取决关联对象 类级别检索策略。

 

  lazy="false"

 

 

  lazy="proxy"

 

 

 

 

2.5   批量查询

  当客户 关联查询 订单,给每一个客户生产一个select语句查询订单。批量查询使用in语句减少查询订单语句个数。

       默认:select * from t_order where customer_id = ?

       批量:select * from t_order where customer_id in (?,?,?,?)

  <set batch-size="5"> 5表示括号中?个数。

 

@Test

   public void demo06() {

      //批量查询

      Session session = factory.openSession();

      session.beginTransaction();

     

      //1 查询所有客户

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

     

      //2遍历

      for (Customer customer : allCustomer) {

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

         System.out.println(customer.getOrderSet().size());

      }

      

      session.getTransaction().commit();

      session.close();

   }

2.6   检索总结

 

检索策略

优点

缺点

优先考虑使用的场合

立即检索

对应用程序完全透明,不管对象处于持久化状态还是游离状态,应用程序都可以从一个对象导航到关联的对象

(1)select语句多

(2)可能会加载应用程序不需要访问的对象,浪费许多内存空间。

(1)类级别

(2)应用程序需要立即访问的对象

(3)使用了二级缓存

延迟检索

由应用程序决定需要加载哪些对象,可以避免执行多余的select语句,以及避免加载应用程序不需要访问的对象。因此能提高检索性能,并节省内存空间。

应用程序如果希望访问游离状态的代理类实例,必须保证她在持久化状态时已经被初始化。

(1)一对多或者多对多关联

(2)应用程序不需要立即访问或者根本不会访问的对象

              

表连接检索

(1)对应用程序完全透明,不管对象处于持久化状态还是游离状态,都可从一个对象导航到另一个对象。

(2)使用了外连接,select语句少

(1)可能会加载应用程序不需要访问的对象,浪费内存。

(2)复杂的数据库表连接也会影响检索性能。

(1)多对一或一对一关联

(2)需要立即访问的对象

(3)数据库有良好的表连接性能。

 

Customer  Get(int id)

       Return Session.load(Customer.class,id);

  1. layz=false
  2. 在Service层获得在页面要上要用到的属性=> 在Service层中确保数据已经

3       查询方式总结

1.通过OID检索(查询)

       get()立即、如果没有数据返回null

       load()延迟,如果没有数据抛异常。

2.导航对象图检索方式:关联查询

       customer.getOrderSet()

       user.getPost().getDepartment().getDepName();

3.原始sql语句

       SQLQuery sqlQuery = session.createSQLQuery("sql 语句")   --->表,表字段(列)

              sqlQuery.list() 查询所有

              sqlQuery.uniqueResult() 查询一个

4.HQL,hibernate query language hibernate 查询语言【1】

       Query query = session.createQuery("hql语句")  --> 对象,对象属性

5.QBC,query by criteria 纯面对对象查询语言【2】

 

4       HQL【掌握】

4.1   介绍

 

 

4.2   查询所有客户

@Test

   public void demo01(){

      //1 查询所有

      Session session = factory.openSession();

      session.beginTransaction();

     

      //1  使用简单类名 , 存在自动导包

      // * Customer.hbm.xml <hibernate-mapping auto-import="true">

//    Query query = session.createQuery("from Customer");

      //2 使用全限定类名

      Query query = session.createQuery("from com.itheima.a_init.Customer");

     

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

      for (Customer customer : allCustomer) {

         System.out.println(customer);

      }

     

      session.getTransaction().commit();

      session.close();

   }

 

4.3   选择查询

@Test

   public void demo02(){

      //2 简单条件查询

      Session session = factory.openSession();

      session.beginTransaction();

     

     

      //1 指定数据,cid OID名称

//    Query query = session.createQuery("from Customer where cid = 1");

      //2 如果使用id,也可以(了解)

//    Query query = session.createQuery("from Customer where id = 1");

      //3 对象别名 ,格式: 类 [as] 别名

//    Query query = session.createQuery("from Customer as c where c.cid = 1");

      //4 查询所有项,mysql--> select * from...

      Query query = session.createQuery("select c from Customer as c where c.cid = 1");

     

      Customer customer = (Customer) query.uniqueResult();

      System.out.println(customer);

     

      session.getTransaction().commit();

      session.close();

   }

4.4   投影查询(部分)

@Test

   public void demo04(){

      //4 投影

      Session session = factory.openSession();

      session.beginTransaction();

     

      //1 默认

      //如果单列 ,select c.cname from,需要List<Object>

      //如果多列,select c.cid,c.cname from ,需要List<Object[]>  ,list存放每行,Object[]多列

//    Query query = session.createQuery("select c.cid,c.cname from Customer c");

      //2 将查询部分数据,设置Customer对象中

      // * 格式:new Customer(c.cid,c.cname)

      // * 注意:Customer必须提供相应的构造方法。

      // * 如果投影使用oid,结果脱管态对象。

      Query query = session.createQuery("select new Customer(c.cid,c.cname) from Customer c");

     

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

      for (Customer customer : allCustomer) {

         System.out.println(customer.getCid() + " : " + customer.getOrderSet().size());

      }

     

      session.getTransaction().commit();

      session.close();

   }

 

4.5   排序

@Test

   public void demo03(){

      //3排序 ,mysql--> select... order by 字段  [asc]|desc ,....

      Session session = factory.openSession();

      session.beginTransaction();

     

      Query query = session.createQuery("from Customer order by cid desc");

     

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

      for (Customer customer : allCustomer) {

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

      }

     

      session.getTransaction().commit();

      session.close();

   }

 

 

4.6   分页

@Test

   public void demo05(){

      //分页

      Session session = factory.openSession();

      session.beginTransaction();

     

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

      // * 开始索引 , startIndex 算法: startIndex = (pageNum - 1) * pageSize;

      // *** pageNum 当前页(之前的 pageCode)

      query.setFirstResult(0);

      // * 每页显示个数 , pageSize

      query.setMaxResults(2);

     

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

      for (Customer customer : allCustomer) {

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

      }

     

      session.getTransaction().commit();

      session.close();

   }

 

4.7   绑定参数

@Test

   public void demo06(){

      /* 6 绑定参数

       * 方式1:占位符,使用? 在hql语句替换具体参数

       *    设置参数 query.setXxx(int , object)

       *        参数1:?位置,从0开始。

       *        参数2:实际参数

       *    例如:String --> query.setString(int,String)

       * 方式2:别名 , 格式 “属性= :别名 ”

       *    设置参数 query.setXxx(String,object)

       *        参数1:别名

       *        参数2:实际参数

       *    例如:Integer --> query.setInteger(String,Integer)

       * 提供公共设置方法

       * setParameter(int|string , Object)

       */

      Session session = factory.openSession();

      session.beginTransaction();

     

      Integer cid = 1;

     

      //方式1

//    Query query = session.createQuery("from Customer where cid = ?");

//    query.setInteger(0, cid);

      //方式2

      Query query = session.createQuery("from Customer where cid = :xxx");

//    query.setInteger("xxx", cid);

      query.setParameter("xxx", cid);

     

      Customer customer = (Customer) query.uniqueResult();

      System.out.println(customer);

     

      session.getTransaction().commit();

      session.close();

   }

 

4.8   聚合函数和分组

@Test

   public void demo07(){

      /* 7  聚合函数

       */

      Session session = factory.openSession();

      session.beginTransaction();

     

      //1

//    Query query = session.createQuery("select count(*) from Customer");

      //2 别名

//    Query query = session.createQuery("select count(c) from Customer c");

      //3 oid

      Query query = session.createQuery("select count(cid) from Customer");

     

      Long numLong = (Long) query.uniqueResult();

      int num = numLong.intValue();

     

      System.out.println(num);

     

     

      session.getTransaction().commit();

      session.close();

   }

 

4.9   连接查询

 

 

1.交叉连接 ,等效 sql 笛卡尔积

2.隐式内连接,等效 sql 隐式内连接

3.内连接,等效sql内连接

4.迫切内连接,hibernate底层使用 内连接。

5.左外连接,等效sql左外连接

6.迫切左外连接,hibernate底层使用 左外连接

7.右外连接,等效sql右外连接

 

内连接和迫切内连接?

左外连接和迫切左外连接?

@Test

   public void demo08(){

      /* 8 链接查询 : 左外连接和迫切左外连接?

       * * 左外连接 , left outer join

       *    底层使用sql的左外连接,hibernate进行数据自动封装,将一条记录,封装给两个对象(Customer,Order)

       *    将两个对象添加到一个对象数组中Object[Customer,Order]

       * * 迫切左外链接 left outer join fetch

       *    底层使用sql的左外连接,hibernate将一条记录封装给Customer,讲order数据封装Order,并将order关联到Customer

       *        customer.getOrderSet().add(order)

       *    默认查询的数据重复

       */

      Session session = factory.openSession();

      session.beginTransaction();

     

      //左外连接

//    List list = session.createQuery("from Customer c left outer join c.orderSet ").list();

      //迫切左外链接 (默认数据重复)

//    List list = session.createQuery("from Customer c left outer join fetch c.orderSet ").list();

      //迫切左外链接 (去重复)

      List list = session.createQuery("select distinct c from Customer c left outer join fetch c.orderSet ").list();

     

     

      session.getTransaction().commit();

      session.close();

   }

 

4.10     命名查询

l  思想:将HQL从java源码中,提取到配置文件中。

l  分类:全局、布局

l  配置

       全局:*.hbm.xml   <class></class><query name="名称">HQL语句

             

 

       局部: <class name="" table=""><id><property> <query name="">HQL</class>

             

 

l  获得

       全局:

              session.getNamedQuery("queryName")

       局部:

              session.getNamedQuery("className.queryName")  需要使用类的全限定名称

 

 

 

@Test

   public void demo09(){

      /* 9 命名查询

       */

      Session session = factory.openSession();

      session.beginTransaction();

     

      //全局

      //List list = session.getNamedQuery("findAll").list();

      //局部

      List list = session.getNamedQuery("com.itheima.a_init.Customer.findAll").list();

     

      System.out.println(list.size());

     

      session.getTransaction().commit();

      session.close();

   }

 

 

5       QBC【了解】

 

5.1.1.1     QBC查询:

QBC:Query By Criteria条件查询.面向对象的查询的方式.

5.1.1.2     QBC简单的查询:

     // 简单查询:

     List<Customer> list = session.createCriteria(Customer.class).list();

     for (Customer customer : list) {

         System.out.println(customer);

     }

5.1.1.3     QBC分页的查询:

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

     criteria.setFirstResult(10);

     criteria.setMaxResults(10);

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

5.1.1.4     QBC排序查询:

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

 //   criteria.addOrder(org.hibernate.criterion.Order.asc("age"));

     criteria.addOrder(org.hibernate.criterion.Order.desc("age"));

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

5.1.1.5     QBC条件查询:

     // 按名称查询:

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

     criteria.add(Restrictions.eq("cname", "tom"));

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

    

     // 模糊查询;

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

     criteria.add(Restrictions.like("cname", "t%"));

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

    

     // 条件并列查询

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

     criteria.add(Restrictions.like("cname", "t%"));

     criteria.add(Restrictions.ge("age", 35));

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

 

 

5.1.1.6         离线查询(了解)

l  DetachedCriteria 离线查询对象,不需要使用Session就可以拼凑查询条件。一般使用在web层或service层拼凑。将此对象传递给dao层,此时将与session进行绑定执行查询。

l  离线查询条件与QBC一样的。

 

 

 

@Test

   public void demo10(){

      /* 10 离线查询

       */

     

      //web & service

      DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Customer.class);

      detachedCriteria.add(Restrictions.eq("cid", 1));

     

      //---------------dao

     

      Session session = factory.openSession();

      session.beginTransaction();

     

      // 离线Criteria 与session绑定

      Criteria criteria = detachedCriteria.getExecutableCriteria(session);

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

      System.out.println(allCustomer.size());

     

      session.getTransaction().commit();

      session.close();

   }

 

 

 

 

以上是关于Hibernate3 多对多关系的主要内容,如果未能解决你的问题,请参考以下文章

059:表关系之多对多

在 laravel 中查看多对多关系

实体框架代码优先,同一张表上的多对多关系

JPA:多对多关系 - JsonMappingException:无限递归

在模板中显示多对多关系关系

QueryDSL 和多对多关系