文档章节

day31_Hibernate学习笔记_03

o
 osc_odyg6b92
发布于 2018/07/13 13:55
字数 7939
阅读 3
收藏 0

行业解决方案、产品招募中!想赚钱就来传!>>>

一、Hibernate的关联关系映射(多对多)

在数据库表中如何表达多对多关系:
  使用中间表,分别引用两方的ID。
在对象中如何表达多对多关系:
  两方都使用集合表达
在配置文件中如何表达一对多关系:

    <!-- 配置多对多关联关系 -->
    <set name="courses" table="t_stu_cour">
        <key column="stu_id"/>
        <many-to-many class="Course" column="cour_id"/>
    </set>
    <!-- 配置多对多关联关系 -->
    <set name="students" table="t_stu_cour">
        <key column="cour_id"/>
        <many-to-many class="Student" column="stu_id"/>
    </set>      

操作:
  inverse:本方是否要放弃维护外键关系
  cascade:是否需要级联操作(有5个值)
注意配置级联删除时,要小心!当双方都配置级联删除时,任意删除一条记录,整个关系链数据都会被删除。

1.1、多对多实现【掌握】

1.1.1、实现类

Student.java

package com.itheima.domain;

import java.util.HashSet;
import java.util.Set;

public class Student {
    private Integer sid;
    private String sname;
    // 学生可以选择多门课程
    private Set<Course> courses = new HashSet<Course>();

    // getter和setter方法
}

Course.java

package com.itheima.domain;

import java.util.HashSet;
import java.util.Set;

public class Course {
    private Integer cid;
    private String cname;
    // 课程可以被多个学生选择
    private Set<Student> students = new HashSet<Student>();

    // getter和setter方法
}

1.1.2、配置文件

Student.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">


<hibernate-mapping  package="com.itheima.domain">
    <class name="Student" table="t_student">
        <id name="sid" column="sid">
            <generator class="native"></generator>
        </id>
        <property name="sname" column="sname"></property>
        <!-- 配置多对多关联关系 -->
        <set name="courses" table="t_stu_cour">
            <key column="stu_id"/>
            <many-to-many class="Course" column="cour_id"/>
        </set>
    </class>
</hibernate-mapping>

Course.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">


<hibernate-mapping  package="com.itheima.domain">
    <class name="Course" table="t_course">
        <id name="cid" column="cid">
            <generator class="native"></generator>
        </id>
        <property name="cname" column="cname"></property>
        <!-- 配置多对多关联关系 -->
        <set name="students" table="t_stu_cour">
            <key column="cour_id"/>
            <many-to-many class="Student" column="stu_id"/>
        </set>
    </class>
</hibernate-mapping>

hibernate.cfg.xml

......
<!-- 添加ORM映射文件 ,填写src之后的路径 -->
<mapping resource="com/itheima/domain/Student.hbm.xml"/>
<mapping resource="com/itheima/domain/Course.hbm.xml"/>
......

1.1.3、测试代码

架构图如下所示:


测试多对多代码:
package com.itheima.a_many2many;

import org.hibernate.Session;
import org.junit.Test;

import com.itheima.domain.Course;
import com.itheima.domain.Student;
import com.itheima.utils.HibernateUtils;

public class Demo1 {
    @Test
    // 保存学生 =>  通过学生保存课程,由学生来维护外键
    // Student 的
    //      inverse => false
    //      cascade => save-update
    // Course 的
    //      inverse => true
    // 注意:实际开发中,在配置多对多关系时,一般需要有一方放弃维护外键关联关系

    // 5条 select 语句 + 6条 update 语句  (因为1个学生关联了3个课程)
    public void fun1() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        Student stu1 = new Student();
        stu1.setSname("李晓艺");
        Student stu2 = new Student();
        stu2.setSname("陈明军");

        Course c1 = new Course();
        c1.setCname("Struts2");
        Course c2 = new Course();
        c2.setCname("Hibernate");
        Course c3 = new Course();
        c3.setCname("Spring");

        stu1.getCourses().add(c1); // 维护关系+级联保存
        stu1.getCourses().add(c2);
        stu1.getCourses().add(c3);

        stu2.getCourses().add(c1);
        stu2.getCourses().add(c2);
        stu2.getCourses().add(c3);

        session.save(stu1);
        session.save(stu2);

        session.getTransaction().commit();
        session.close();
    }
}

二、加载(抓取)策略(优化查询)

1、加载策略种类:
    延迟加载:等到使用的时候才会加载数据。
    立即加载:不管使用不使用,都会立刻将数据加载。

2、加载策略的应用:
    类级别的加载策略。
    关联级别的加载策略。

3、类级别加载策略:
    get/load
        get:立即查询数据库,将数据初始化。
        load:hbm文件中,class元素的lazy属性决定该方法的类级别加载策略,默认值是true
            true:先返回一个代理对象,使用代理对象的属性时,才去查询数据库。
            falseload方法一执行就会发送sql语句,与get一致,会立即加载数据。

4、关联级别加载策略:
    在查询有关联关系的数据时,加载一方的数据是否需要将另一方立即查询出。
    默认是:与我关联的数据,在使用时才会被加载。

    注意:下面所用的例子是:客户(一)和订单(多)
    ------------------------------------------------------------------------------------------------------------------------------
    一对多(集合的检索策略):根据客户去找订单
    <set 
        lazy:是否对set数据使用懒加载
            true        (默认值)对集合使用赖加载
            false       集合将会被立即加载
            extra       极其懒惰,在使用集合时,若调用size方法查询数量,则Hibernate会发送count语句,只查询数量,不加载集合内的数据
        fetch:决定加载集合使用的sql语句种类
            select      (默认值)普通select语句查询
            join        使用 表连接语句 查询集合数据,即使用 多表查询语句 集合数据
            subselect   使用子查询语句,在一次加载多个客户的订单数据的情况下才有效

        fetch       lazy    结果
        ------------------------
        select      true    都是默认值,会在使用集合(订单)时才加载,使用普通select语句查询集合数据
        select      false   立刻使用select语句加载集合数据
        select      extra   会在使用集合(订单)时才加载,普通select语句,如果你使用集合只是为了获得集合的长度,则Hibernate只会发送count语句查询集合长度

        join        true    因为查询集合(订单)时使用表连接语句查询,所以会立刻加载集合数据(与lazy属性无关了,lazy属性失效)
        join        false   因为查询集合(订单)时使用表连接语句查询,所以会立刻加载集合数据(与lazy属性无关了,lazy属性失效)
        join        extra   因为查询集合(订单)时使用表连接语句查询,所以会立刻加载集合数据(与lazy属性无关了,lazy属性失效)

        subselect   true    会在使用集合(订单)时才加载,使用子查询语句查询集合(订单)数据
        subselect   false   会在查询客户时,立即使用子查询语句加载客户的订单数据
        subselect   extra   会在使用集合(订单)时才加载,子查询语句,如果你使用集合只是为了获取集合的长度,则Hibernate只会发送count语句查询集合长度
    ------------------------------------------------------------------------------------------------------------------------------  
    多对一:根据订单去找客户
    <many-to-one
        lazy
            false       加载订单时,会立即加载客户
            proxy       看客户对象的类加载策略来决定
            no-proxy    不做研究
        fetch
            select      (默认值)使用普通select加载
            join        使用表连接加载数据

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

5、批量加载
    set
        batch-size  决定一次加载几个对象的集合数据,in 条件加载多个用户的订单

2.1、类级别加载策略

示例代码如下:演示类级别加载策略--懒加载

package com.itheima.b_lazy;

import org.hibernate.Session;
import org.junit.Test;

import com.itheima.domain.Customer;

import com.itheima.utils.HibernateUtils;

public class Demo1 {
    @Test
    // 演示类级别加载策略--懒加载
    // load方法
    // class的lazy属性
    // 默认值是:true   load获得时,会返回一个代理对象,当使用代理对象的属性时,才去查询数据库。
    public void fun1() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

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

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

        session.getTransaction().commit();
        session.close();
    }

    @Test
    // 演示类级别加载策略--懒加载
    // load方法
    // class的lazy属性
    // 属性值改为:false load方法一执行就会发送sql语句,与get方法一致。
    public void fun2() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

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

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

        session.getTransaction().commit();
        session.close();
    }
}

2.2、关联级别加载策略

2.2.1、一对多:根据客户去查找订单

一对多加载策略,也叫集合的检索策略
示例代码如下:

package com.itheima.b_lazy;

import java.util.List;

import org.hibernate.Session;
import org.junit.Test;

import com.itheima.domain.Customer;
import com.itheima.domain.Order;
import com.itheima.utils.HibernateUtils;

// 一对多(集合的检索策略):根据客户去查找订单
// 特别注意:本示例代码中,为了简化演示,共有1个客户:表示客户数 >= 1 才可以演示; 共有2个客户:表示客户数 >= 2 才可以演示。
public class Demo2 {
    @Test
    // 演示关联级别加载策略
    // <set 
    //      lazy 的值为 true 时,
    // 结果:(默认值为true)即对集合使用赖加载,即与客户关联的数据,在使用时才会被加载。
    // 演示前提:一对多,1个客户有2个订单,共有1个客户
    public void fun1() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        Customer c = (Customer) session.get(Customer.class, 1); // 1条 select 语句,查询出1个客户

        for (Order o : c.getOrders()) { 
            System.out.println(o.getOname()); // 1条 select 语句,查询出对应客户的订单
        }

        session.getTransaction().commit();
        session.close();
    }

    @Test
    // 演示关联级别加载策略
    // <set 
    //      lazy 的值为 false 时,
    // 结果:集合将会被立即加载
    // 演示环境:一对多,1个客户有2个订单,共有1个客户
    public void fun2() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        Customer c = (Customer) session.get(Customer.class, 1); // 2条 select 语句,查询出客户以及查询出客户对应的订单

        for (Order o : c.getOrders()) {
            System.out.println(o.getOname());
        }

        session.getTransaction().commit();
        session.close();
    }

    @Test
    // 演示关联级别加载策略
    // <set 
    //      lazy 的值为 false/true/extra 时
    //      fetch 的值为 join 时
    // 结果:因为查询集合时使用表连接语句查询,所以会立刻加载集合数据,lazy的属性失效
    // 演示环境:一对多,1个客户有2个订单,共有1个客户
    public void fun3() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        Customer c = (Customer) session.get(Customer.class, 1); // 1条 表连接查询 语句(左外连接查询)

        for (Order o : c.getOrders()) {
            System.out.println(o.getOname());
        }

        session.getTransaction().commit();
        session.close();
    }

    @SuppressWarnings("unchecked")
    @Test
    // 演示关联级别加载策略
    // <set 
    //      lazy 的值为 true 时
    //      fetch 的值为 subselect 时,注意:该属性的值,在一次加载多个客户的订单数据的情况下才有效
    // 结果:会在使用集合(订单)时才加载,使用子查询语句查询集合(订单)数据
    // 演示环境:一对多,1个客户有2个订单,共有2个客户
    public void fun4() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        List<Customer> list = session.createQuery("from Customer").list(); // 1条 select 语句,查询出2个客户

        for (Customer c : list) { 
            System.out.println(c.getCname() + "下单数量:" + c.getOrders().size()); // 1条 子查询 语句,查询出2个客户各自所有的订单
        }

        session.getTransaction().commit();
        session.close();
    }

    @SuppressWarnings("unchecked")
    @Test
    // 演示关联级别加载策略
    // <set 
    //      lazy 的值为 false 时
    //      fetch 的值为 subselect 时,注意:该属性的值,在一次加载多个客户的订单数据的情况下才有效
    // 结果:会在查询客户时,立即使用子查询语句加载客户的订单数据
    // 演示前提:一对多,1个客户有2个订单,共有2个客户
    public void fun5() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        List<Customer> list = session.createQuery("from Customer").list(); // 1条 select 语句,查询出2个客户   + 1条 子查询 语句,查询出2个客户各自所有的订单

        for (Customer c : list) {
            System.out.println(c.getCname() + "下单数量:" + c.getOrders().size());
        }

        session.getTransaction().commit();
        session.close();
    }

    @Test
    // 演示关联级别加载策略
    // <set 
    //      lazy 的值为 extra 时
    //      fetch 的值为 select 时
    // 结果:会在使用集合(订单)时才加载,普通select语句,如果你使用集合只是为了获得集合的长度,则Hibernate只会发送count语句查询集合长度
    // 演示环境:一对多,1个顾客有2个订单,共有1个顾客
    public void fun6() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        // 查询Customer
        Customer c = (Customer) session.get(Customer.class, 1); // 1条 select 语句,查询出1个客户
        // 查询Customer下的订单数量
        System.out.println(c.getOrders().size()); // 1条 select count() 语句,查询出集合的长度

        // 真正使用订单中的数据
        for (Order o : c.getOrders()) { 
            System.out.println(o.getOname()); // 1条 select 语句,查询出对应客户的订单数据
        }

        session.getTransaction().commit();
        session.close();
    }

    @SuppressWarnings("unchecked")
    @Test
    // 演示关联级别加载策略
    // <set 
    //      lazy 的值为 extra 时
    //      fetch 的值为 subselect 时,注意:该属性的值,在一次加载多个客户的订单数据的情况下才有效
    // 结果:会在使用集合(订单)时才加载,子查询语句,如果你使用集合只是为了获取集合的长度,则Hibernate只会发送count语句查询集合长度
    // 演示环境:一对多,1个客户有2个订单,共有2个客户
    public void fun7() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        List<Customer> list = session.createQuery("from Customer").list(); // 1条 select 语句,查询出2个客户

        for (Customer c : list) { // 遍历Customer,获取每个Customer的订单数量
            System.out.println(c.getCname() + "下单数量:" + c.getOrders().size()); // 1条 select count 语句,查询出对应客户的订单的长度
        }                                                                       // 1条 select count 语句,查询出对应客户的订单的长度

        for (Customer c : list) {
            for (Order o : c.getOrders()) { // 遍历每个订单的具体数据
                System.out.println(c.getCname() + "下单名称:" + o.getOname()); // 1条 子查询语句,查询出订单的详细信息
            }
        }

        session.getTransaction().commit();
        session.close(); 
    }
}

2.2.2、多对一:根据订单去查找客户

示例代码如下:

package com.itheima.b_lazy;

import org.hibernate.Session;
import org.junit.Test;

import com.itheima.domain.Order;
import com.itheima.utils.HibernateUtils;

// 多对一 检索策略:根据订单去查找客户
public class Demo3 {
    @Test
    // Order <many-to-one
    //      fetch: select
    //      lazy: false
    // 结果:加载订单时,会立即加载客户数据,使用普通select语句加载客户数据
    public void fun1() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();


        Order o = (Order) session.get(Order.class, 2);  // 2条 select 语句
        System.out.println(o.getCustomer().getCname());

        session.getTransaction().commit();
        session.close();
    }

    @Test
    // Order <many-to-one
    //      fetch: select
    //      lazy: proxy
    // Customer <class
    //      lazy: false 
    // 结果:结果同fun1()
    public void fun2() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        Order o = (Order) session.get(Order.class, 2);  // 2条 select 语句
        System.out.println(o.getCustomer().getCname());

        session.getTransaction().commit();
        session.close();
    }

    @Test
    // Order <many-to-one
    //      fetch: select
    //      lazy: proxy
    // Customer <class
    //      lazy: true
    // 结果:加载订单时,先不加载客户数据,使用客户数据时才加载客户数据
    public void fun3() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        Order o = (Order) session.get(Order.class, 2);  // 1条 select 语句 
        System.out.println(o.getCustomer().getCname()); // 1条 select 语句 

        session.getTransaction().commit();
        session.close();
    }

    @Test
    // Order <many-to-one
    //      fetch: join
    //      lazy: proxy|false   该属性失效
    // 结果:使用表连接查询订单以及对应客户信息,lazy属性无效
    public void fun4() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        Order o = (Order) session.get(Order.class, 2); // 1条 表连接查询 语句(左外连接查询)
        System.out.println(o.getCustomer().getCname());

        session.getTransaction().commit();
        session.close(); 
    }
}

2.2.3、批量加载策略

示例代码如下:

package com.itheima.b_lazy;

import java.util.List;

import org.hibernate.Session;
import org.junit.Test;

import com.itheima.domain.Customer;
import com.itheima.utils.HibernateUtils;

// 演示:批量加载策略
public class Demo4 {
    @SuppressWarnings("unchecked")
    @Test
    // 查询所有客户
    // 遍历客户,打印客户下的订单信息
    // 演示环境:一对多,1个客户有2个订单,共有2个客户
    // <set
    //      batch-size="1"
    // 结果:一次加载1个对象(客户)的集合数据
    public void fun1() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        List<Customer> list = session.createQuery("from Customer").list(); // 1条 select 语句,查询出2个客户

        for (Customer c : list) {
            System.out.println(c.getOrders().size()); // 1条 select 语句,查询出第一个客户的所有的订单信息
        }                                             // 1条 select 语句,查询出第二个客户的所有的订单信息

        session.getTransaction().commit();
        session.close();
    }

    @SuppressWarnings("unchecked")
    @Test
    // 批量加载策略
    // <set
    //      batch-size="2"
    // 结果:一次加载2个对象(客户)的集合数据
    public void fun2() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        List<Customer> list = session.createQuery("from Customer").list(); // 1条 select 语句,查询出2个客户

        for (Customer c : list) {
            System.out.println(c.getOrders().size()); // 1条 select ... in ... 语句,就查询出2个客户的所有订单信息
        }                                            

        session.getTransaction().commit();
        session.close();
    }
}

2.2.4、检索总结

如下表所示:

检索策略 优点 缺点 优先考虑使用的场合
立即检索 对应用程序完全透明,不管对象处于持久化状态还是游离状态,应用程序都可以从一个对象导航到关联的对象。即使用关联对象的属性很方便。 (1)select语句多,检索效率低。
(2)可能会加载应用程序不需要访问的对象,浪费许多内存空间。
(1)类级别检索中使用。
(2)应用程序需要立即访问的对象中使用。
(3)使用了二级缓存的情况下。
延迟检索
(懒加载/检索)
(1)由应用程序决定需要加载哪些对象,可以避免执行多余的select语句。
(2)避免加载应用程序不需要访问的对象。因此能提高检索性能,并节省内存空间。
应用程序如果希望访问游离状态的代理类实例,必须保证它在持久化状态时已经被初始化。 (1)一对多或者多对多关联检索中使用。
(2)应用程序不需要立即访问或者根本不会访问的对象延时检索使用。
要特别注意代理对象的问题。
开发中常见这种问题!
表连接检索
(用的比较少,不灵活)
(1)对应用程序完全透明,不管对象处于持久化状态还是游离状态,都可从一个对象导航到另一个对象。
(2)使用了外连接,select语句少。
(1)可能会加载应用程序不需要访问的对象,浪费内存。
(2)复杂的数据库表连接也会影响检索性能。
(1)多对一或一对一关联检索中使用
(2)需要立即访问的对象
(3)数据库有良好的表连接性能。

类级别加载策略:
  get/load
    get:立即查询数据库,将数据初始化。
    load:hbm文件中,class元素的lazy属性决定该方法的类级别加载策略,默认值是true。
      true:先返回一个代理对象,使用代理对象的属性时,才去查询数据库。
      false:load方法一执行就会发送sql语句,与get一致,会立即加载数据。

由以上的类级别加载策略可知,代理对象在Session关闭之后可能会取不到值,该如何解决呢?

  • 法一:配置layz="false" ,集合将会被立即加载,此法不好,当数据量级很大时,比如:银行项目、三大运营商项目,服务器就要疯了。
  • 法二:因为是在Service层调用的Dao层的方法,那么我们在Service层就知道以后我们在页面上要用的数据,所以我们在Seesion关闭之前,在Service层先getXxx()在页面要上要用到的属性(数据),即在Service层中确保数据已经加载进来了。

三、查询方式总结

    Hibernate查询分类:
        1get/load          根据OID检索
        2、对象导航图检索   c.getOrders();
        3、Sql语句         createSqlQuery
        4、Hql语句         createQuery
        5、Criteria查询    createCriteria 
        --------------------------------------------------    
        1.通过OID检索(查询)
            get(int);           立即、如果没有数据返回null
            load(Class, int);   延迟,如果没有数据抛异常。

        2.导航对象图检索方式(关联查询)
            customer.getOrders();

        3.Sql: Structured Query Language    结构化查询语言,原始Sql语句查询
            SQLQuery sqlQuery = session.createSQLQuery("sql语句"); // 查询的是:表,表字段(列)
            sqlQuery.list();            查询所有
            sqlQuery.uniqueResult();    查询一个

        4.HQL: Hibernate Query Language     Hibernate查询语言
            Query query = session.createQuery("hql语句"); // 查询的是:对象,对象属性

        5.QBC: Query By Criteria            条件查询,纯面向对象查询语言
            Criteria criteria = session.createCriteria(Class);  

四、HQL【掌握】

4.1、HQL介绍

  • HQL(Hibernate Query Language:Hibernate查询语言)是描述对象操作的查询语言,是Hibernate所特有。
  • 与SQL语法基本一致,不同的是HQL是面向对象的查询,查询的是对象和对象中的属性。
  • HQL的关键字不区分大小写,但是类名和属性名区分大小写。

HQL语法示例:

关键字 说明
select 别名/属性名/表达式
from 实体类名 as 别名 (as可以省略哦)
where 过滤条件
group by 分组条件
having 分组后的结果的过滤条件
order by 排序条件

4.2、HQL查询所有客户

示例代码如下:

    @Test
    // HQL查询所有客户
    public void fun1() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        // 下面五种语句等效
        // Query query = session.createQuery("from Customer"); // 使用简单类名
        // Query query = session.createQuery("from Customer c"); // 使用简单类名+别名
        // Query query = session.createQuery("select c from Customer c");
        // Query query = session.createQuery("select c from Customer as c");
        Query query = session.createQuery("select c from com.itheima.domain.Customer as c"); // 使用全限定类名

        List<Customer> list = query.list();
        System.out.println(list);

        session.getTransaction().commit();
        session.close();
    }

4.3、HQL选择查询

示例代码如下:

    @Test
    // HQL选择查询对象的某几个属性
    public void fun2() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        // 注意:点后面是属性名称,因为HQL已经不跟数据库有关系了,而是跟对象有关系了,HQL是面向对象语言
        // Query query = session.createQuery("select c.cid from Customer c"); 
        Query query = session.createQuery("select c.cid, c.cname from Customer c"); 

        // 如果单列 ,select c.cname from ,需要List<Object>
        // 如果多列,select c.cid, c.cname from ,需要List<Object[]>,list存放每行,Object[]多列
        List<Object[]> list = query.list();
        for (Object[] objs : list) {
            System.out.println(Arrays.toString(objs));
        }

        session.getTransaction().commit();
        session.close();
    }

4.4、HQL投影查询(部分)

示例代码如下:

    @Test
    // HQL投影查询:在选择查询的基础上,把查询结果封装到对象中
    public void fun3() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        // 注意:点后面是属性名称,因为HQL已经不跟数据库有关系了,而是跟对象有关系了,HQL是面向对象语言
        // Query query = session.createQuery("select c.cname from Customer c");
        Query query = session.createQuery("select new Customer(c.cid, c.cname) from Customer c"); // 注意:Customer必须提供相应的构造方法。

        List<Customer> list = query.list();
        System.out.println(list);

        session.getTransaction().commit();
        session.close();
    }

4.5、HQL排序

示例代码如下:

    @Test
    // HQL排序
    public void fun5() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        // Query query = session.createQuery("from Customer c order by c.cid desc"); // desc 降序:由大到小
        Query query = session.createQuery("from Customer c order by c.cid asc "); // asc 升序:由小到大

        List<Customer> list = query.list();
        System.out.println(list);

        session.getTransaction().commit();
        session.close();
    }

4.6、HQL分页

示例代码如下:

    @Test
    // HQL分页
    public void fun6() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

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

        // 分页思路:                第一个问号           第二个问号
        // limit ?,?    =>  setFirstResult  setMaxResults
        // setFirstResult = (当前页数-1)*每页最大记录数        当前页数是从1开始的。

        // 0,1  表示:从数据库表的第一行开始,一行为一页
        // 1,1  表示:从数据库表的第二行开始,一行为一页
        // 2,1  表示:从数据库表的第三行开始,一行为一页
        // 2,2  表示:从数据库表的第三行开始,两行为一页


        query.setFirstResult(1);    // 从数据库表的哪个索引(数据库表的行号=索引+1)开始取数据,包裹索引本身的记录,索引是从0开始的,角标是从1开始。
        query.setMaxResults(2);     // 一页查询出多少条数据

        List<Customer> list = query.list();
        System.out.println(list);

        session.getTransaction().commit();
        session.close();
    }

4.7、HQL绑定参数

示例代码如下:

    @Test
    // HQL绑定参数
    public void fun7() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        // 方式一:需要考虑索引的变化
        // Query query = session.createQuery("from Customer c where c.cid=?");
        // 第一个参数:问号作为占位符的索引 ,第一个问号的索引为0 
        // query.setInteger(0,2);


        // 方式二:不需要考虑索引的变化
        Query query = session.createQuery("from Customer c where c.cid=:haha");
        // 第一个参数:绑定实际参数作为占位符的名称
        query.setInteger("haha"2);

        Customer c = (Customer) query.uniqueResult();
        System.out.println(c);

        session.getTransaction().commit();
        session.close();
    }

4.8、聚合函数和分组

示例代码如下:

    @Test
    // HQL聚合函数
    public void fun8() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        // Query query = session.createQuery("select count(*) from Customer c");
        // Query query = session.createQuery("select avg(c.cid) from Customer c");
        // Query query = session.createQuery("select sum(c.cid) from Customer c");
        // Query query = session.createQuery("select max(c.cid) from Customer c");
        Query query = session.createQuery("select min(c.cid) from Customer c");

        Object count = query.uniqueResult();
        System.out.println(count);

        session.getTransaction().commit();
        session.close(); 
    }

    @Test
    // HQL分组
    // group by ... having ...
    public void fun9() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        // 从订单表中,我查询满足如下条件的客户和客户的订单数量:把订单通过客户进行分组后,统计订单的数量且订单的数量大于2的 。
        Query query = session.createQuery("select o.customer, count(o) " + " from Order o " + " group by o.customer " + " having count(o)> 2");

        List<Object[]> list = query.list();
        for (Object[] objs : list) {
            System.out.println(Arrays.toString(objs));
        }

        session.getTransaction().commit();
        session.close();
    }

4.9、HQL连接查询

示例代码如下:

package com.itheima.c_hql;

import java.util.Arrays;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.junit.Test;

import com.itheima.utils.HibernateUtils;
// 演示:HQL详解_02 表连接

// 内连接        =>
// 左外连接    =>
// 右外连接    =>

@SuppressWarnings("unchecked")
public class Demo2 {
    @Test
    // 交叉连   => 笛卡尔积
    // 开发时要避免出现笛卡尔积
    public void fun1() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        Query query = session.createQuery("from Customer c,Order o");

        List<Object[]> list = query.list();
        for (Object[] objs : list) {
            System.out.println(Arrays.toString(objs));
        }

        session.getTransaction().commit();
        session.close();
    }

    @Test
    // 内连接
    // 隐式内连接    =>  在笛卡尔积基础上过滤掉无效数据
    public void fun2() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        Query query = session.createQuery("from Customer c, Order o where o.customer=c");

        List<Object[]> list = query.list();
        for (Object[] objs : list) {
            System.out.println(Arrays.toString(objs));
        }

        session.getTransaction().commit();
        session.close();
    }

    @Test
    // 内连接
    // 显式内连接(非迫切)   =>  inner join
    // List<Object[]>
    //      Object[] => [Customer, Order]
    // 非迫切连接会将父与子对象装入数组中分别返回。
    public void fun3() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        Query query = session.createQuery("from Customer c inner join c.orders");

        List<Object[]> list = query.list();
        for (Object[] objs : list) {
            System.out.println(Arrays.toString(objs));
        }

        session.getTransaction().commit();
        session.close();
    }

    @Test
    // 内连接
    // 显式内连接(迫切)    =>  inner join fetch
    // List<Customer>
    // 迫切连接会将子装入父中,组装成一个对象再返回。
    public void fun4() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        Query query = session.createQuery("from Customer c inner join fetch c.orders");

        List<Object> list = query.list();
        for (Object obj : list) {
            System.out.println(obj);
        }

        session.getTransaction().commit();
        session.close();
    }

    @Test
    // 左外连接(非迫切)
    // left [outer] join
    public void fun5() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        Query query = session.createQuery("from Customer c left outer join c.orders");

        List<Object[]> list = query.list();
        for (Object[] objs : list) {
            System.out.println(Arrays.toString(objs));
        }

        session.getTransaction().commit();
        session.close();
    }

    @Test
    // 左外连接 (迫切)
    // left [outer] join fetch
    public void fun6() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        Query query = session.createQuery("from Customer c left outer join fetch c.orders");

        List<Object> list = query.list();
        for (Object obj : list) {
            System.out.println(obj);
        }

        session.getTransaction().commit();
        session.close();
    }

    @Test
    // 右外连接(非迫切)
    // right [outer] join
    public void fun7() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        Query query = session.createQuery("from Customer c right outer join c.orders");

        List<Object[]> list = query.list();
        for (Object[] objs : list) {
            System.out.println(Arrays.toString(objs));
        }

        session.getTransaction().commit();
        session.close();
    }

    @Test
    // 右外连接 (迫切)
    // right [outer] join fetch
    public void fun8() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        Query query = session.createQuery("from Customer c right outer join fetch c.orders");

        List<Object> list = query.list();
        for (Object obj : list) {
            System.out.println(obj);
        }

        session.getTransaction().commit();
        session.close();
    }
}

4.10、HQL命名查询

思想:将HQL从java源码中,提取到配置文件中。
分类:全局、局部
配置:
  全局


  局部

获得:
  全局:
    session.getNamedQuery("queryName");
  局部:
    session.getNamedQuery("className.queryName"); // 需要使用类的全限定名称
示例代码如下:
Customer.hbm.xml
<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">


<hibernate-mapping  package="com.itheima.domain">
    <class name="Customer" table="t_customer" lazy="false">
        <id name="cid" column="cid">
            <generator class="native"></generator>
        </id>
        <property name="cname" column="cname" type="string"></property>

        <!-- 一对多:一个客户当前客户 拥有 多个订单 -->
        <set name="orders" batch-size="2">
            <key column="customer_id"></key>
            <one-to-many class="Order"/>
        </set>

        <!-- 配置局部的HQL语句 -->
        <query name="def"><![CDATA[from Order]]></query>
    </class>

    <!-- 配置全局的HQL语句 -->
    <query name="abc"><![CDATA[from Customer]]></query>
</hibernate-mapping>

测试代码如下:

package com.itheima.c_hql;

import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.junit.Test;

import com.itheima.utils.HibernateUtils;

// 演示:HQL详解_03 命名查询

// 思想:将HQL从java源码中,提取到配置文件中。
// 分类:全局、局部
@SuppressWarnings("unchecked")
public class Demo3 {
    @Test
    // 找到全局配置的HQL语句
    public void fun1() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        // 从com.itheima.domain.Customer 的 hbm文件中找
        Query query = session.getNamedQuery("abc");

        List<Object> list = query.list();
        System.out.println(list);

        session.getTransaction().commit();
        session.close(); 
    }

    @Test
    // 找到局部配置的HQL语句
    public void fun2() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        // 从com.itheima.domain.Customer 的 hbm文件中找
        Query query = session.getNamedQuery("com.itheima.domain.Customer.def");

        List<Object> list = query.list();
        System.out.println(list);

        session.getTransaction().commit();
        session.close(); 
    }
}

五、QBC【了解】

5.1、QBC查询

  QBC:Query By Criteria 条件查询(面向对象的查询的方式),不支持连接查询,开发中不常用。

5.2、QBC简单查询

  示例代码如下:(往下看)

5.3、QBC分页查询

  示例代码如下:(往下看)

5.4、QBC排序查询

  示例代码如下:(往下看)

5.5、QBC条件查询

5.2~5.5示例代码如下:

package com.itheima.d_qbc;

import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.criterion.Restrictions;
import org.junit.Test;

import com.itheima.domain.Customer;
import com.itheima.domain.Order;
import com.itheima.utils.HibernateUtils;

// 演示:QBC详解
@SuppressWarnings("unchecked")
public class Demo1 {

    @Test
    // QBC简单查询
    public void fun1() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        List<Customer> list = session.createCriteria(Customer.class).list();
        for (Customer customer : list) {
            System.out.println(customer);
        }

        session.getTransaction().commit();
        session.close();
    }

    @Test
    // QBC分页查询
    public void fun2() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        Criteria criteria = session.createCriteria(Order.class);
        criteria.setFirstResult(2);
        criteria.setMaxResults(2);

        List<Order> list = criteria.list();
        System.out.println(list);

        session.getTransaction().commit();
        session.close();
    }

    @Test
    // QBC排序查询
    public void fun3() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        Criteria criteria = session.createCriteria(Customer.class);
        // criteria.addOrder(org.hibernate.criterion.Order.asc("cid")); // asc 升序:由小到大
        criteria.addOrder(org.hibernate.criterion.Order.desc("cid")); // desc 降序:由大到小

        List<Customer> list = criteria.list();
        System.out.println(list);

        session.getTransaction().commit();
        session.close();
    }

    @Test
    // QBC条件查询
    public void fun5() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        // 按名称查询
        // Criteria criteria = session.createCriteria(Customer.class);
        // criteria.add(Restrictions.eq("cname", "李晓艺")); 
        // List<Customer> list = criteria.list();
        // System.out.println(list); 

        // 模糊查询
        // Criteria criteria = session.createCriteria(Customer.class);
        // criteria.add(Restrictions.like("cname", "子%")); 
        // List<Customer> list = criteria.list();
        // System.out.println(list); 

        // 条件并列查询
        Criteria criteria = session.createCriteria(Customer.class);
        criteria.add(Restrictions.like("cname""子%"));
        criteria.add(Restrictions.ge("cid"4));
        List<Customer> list = criteria.list();
        System.out.println(list);

        session.getTransaction().commit();
        session.close();
    }
}

5.6、离线查询(了解)

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

示例代码如下:

package com.itheima.d_qbc;

import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Restrictions;
import org.junit.Test;

import com.itheima.domain.Customer;
import com.itheima.utils.HibernateUtils;

// 演示:QBC详解
@SuppressWarnings("unchecked")
public class Demo2 {

    @Test
    // QBC离线查询
    public void fun1() {
        // Web层或者Service层,DetachedCriteria 离线查询对象
        DetachedCriteria dc = DetachedCriteria.forClass(Customer.class);
        dc.add(Restrictions.eq("cid"2));

        // Dao层
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        // 离线 Criteria 与 Session 进行绑定,执行查询
        Criteria c = dc.getExecutableCriteria(session);
        List<Customer> list = c.list();
        System.out.println(list);

        session.getTransaction().commit();
        session.close();
    }
}

六、连接池、事务、锁 相关常见设置

6.1、整合c3p0(连接池) (了解)

步骤如下:
步骤一:导入c3p0 jar包,并添加至构建路径


步骤二:hibernate.cfg.xml 进行配置,先在Hibernate.properties中找到对应的键和值,如下图所示:

代码如下:
hibernate.connection.provider_class org.hibernate.connection.C3P0ConnectionProvider

配置截图如下:


步骤三:c3p0具体配置参数

代码如下:
###########################
### C3P0 Connection Pool###
###########################

#hibernate.c3p0.max_size 2
#hibernate.c3p0.min_size 2
#hibernate.c3p0.timeout 5000
#hibernate.c3p0.max_statements 100
#hibernate.c3p0.idle_test_period 3000
#hibernate.c3p0.acquire_increment 2
#hibernate.c3p0.validate false

配置截图如下:


示例代码如下:
package com.itheima.e_api;

import org.hibernate.Session;

import org.junit.Test;

import com.itheima.utils.HibernateUtils;

public class Demo1 {
    @Test
    // 验证c3p0连接池
    public void fun1(){
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        System.out.println(session);

        session.getTransaction().commit();
        session.close(); 
    }
}

控制台运行结果如下图所示:

6.2、事务

6.2.1、回顾之前学的知识

  • 事务:一组业务操作,要么全部成功,要么全部不成功。
  • 特性:ACID
    原子性:整体(被事务包裹的sql语句,看作是一个整体,要么都成功,要么都失败:同进退)
    一致性:数据(数据在事务的操作过程中,数据的总量是不能变化的:转账前和转账后的总金额不变)
    隔离性:并发(在并发(多线程)的情况下,事务与事务之间不受干扰)
    持久性:结果(指一个事务一旦被提交,它对数据库中数据的改变就是永久性的,接下来即使数据库发生故障也不应该对其有任何影响)
  • 隔离问题:
    脏读:一个事务读到另一个事务未提交的内容。(读到的是假的数据)
    不可重复读:一个事务读到另一个事务已提交的内容(update,每次读到的结果不一样)
    虚读(幻读):一个事务读到另一个事务已提交的内容(insert,读到的数据变多了)
  • 使用隔离级别,解决问题
    1、read uncommittd,读未提交。存在3个问题。赃读、不可重复读、虚读都有可能发生。
    2、read committed,读已提交。解决:脏读。存在2个问题。不可重复读、虚读都有可能发生。(oracle默认的)
    4、repeatable read,可重复读。解决:脏读、不可重复读。存在1个问题。虚读有可能发生。(mysql默认的)
    8、serializable,串行化。单事务。没有问题。

6.2.2、hibernate设置隔离级别

  • 在hibernate.cfg.xml 配置
    hibernate.connection.isolation 4

6.2.3、数据库中的锁

悲观锁(数据库提供实现):默认认为别人一定会要修改我使用的数据,那我就可以为我读取的数据加锁。
  读锁/共享锁 => 读锁可被其他线程所共享,如果是读取的话大家都可以用这把锁读到数据。
    select * from t_Customer lock in share mode;(读锁、共享锁)
  写锁/排他锁 => 写锁不能共享,只要有人为数据加入了写锁,其他人就不能为数据加任何锁。
    select * from t_Customer for update; (写锁、排它锁)

  • 悲观锁:丢失更新肯定会发生。
    如下图所示:

乐观锁(需要自己实现,但Hibernate帮我们实现了,我们只需配置一下就可以使用了):

  • 乐观锁:丢失更新肯定不会发生。
    在表中提供一个字段(版本字段),用于标识记录。如果版本不一致,不允许操作。
    如下图所示:

悲观锁测试代码如下:

package com.itheima.e_api;

import org.hibernate.LockOptions;
import org.hibernate.Session;
import org.junit.Test;

import com.itheima.domain.Customer;
import com.itheima.utils.HibernateUtils;

public class Demo2 {
    @Test
    // 悲观锁
    // 写锁
    public void fun1() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        Customer c = (Customer) session.get(Customer.class1, LockOptions.UPGRADE);
        System.out.println(c);

        session.getTransaction().commit();
        session.close();
    }

    @Test
    // 悲观锁
    // 读锁
    public void fun2() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        Customer c = (Customer) session.get(Customer.class1, LockOptions.READ);
        System.out.println(c);

        session.getTransaction().commit();
        session.close();
    }
}

乐观锁示例代码:
在PO对象(JavaBean)中提供字段,表示版本字段。一般为Integer。


在Custmoer.hbm.xml 文件配置

配置截图如下:

乐观锁测试代码如下:
package com.itheima.e_api;

import org.hibernate.Session;
import org.junit.Test;

import com.itheima.domain.Customer;
import com.itheima.utils.HibernateUtils;

public class Demo3 {
    @Test
    // 乐观锁
    public void fun1() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        Customer c = (Customer) session.get(Customer.class1);
        c.setCname("lucy");
        System.out.println(c);

        session.getTransaction().commit();
        session.close();
    }
}
o
粉丝 1
博文 500
码字总数 0
作品 0
私信 提问
加载中
请先登录后再评论。
我的架构演化笔记 功能1: 基本的用户注册

“咚咚”,一阵急促的敲门声, 我从睡梦中惊醒,我靠,这才几点,谁这么早, 开门一看,原来我的小表弟放暑假了,来南京玩,顺便说跟我后面学习一个网站是怎么做出来的。 于是有了下面的一段...

强子哥哥
2014/05/31
976
3
Nutch学习笔记4-Nutch 1.7 的 索引篇 ElasticSearch

上一篇讲解了爬取和分析的流程,很重要的收获就是: 解析过程中,会根据页面的ContentType获得一系列的注册解析器, 依次调用每个解析器,当其中一个解析成功后就返回,否则继续执行下一个解...

强子哥哥
2014/06/26
712
0
桌面即时贴软件--GloboNote

GloboNote 是一个桌面记事软件,可帮你创建待办事宜、提醒和其他笔记信息。无限制即时贴的数量,可分组整理,支持搜索,可定制文本的显示格式(字体、颜色和大小),可将某个即时贴始终显示在...

匿名
2013/01/21
6.7K
1
高效 Java Web 开发框架--JessMA

JessMA 是功能完备的高性能 Full-Stack Web 应用开发框架,内置可扩展的 MVC Web 基础架构和 DAO 数据库访问组件(内部已提供了 Hibernate、MyBatis 与 JDBC DAO 组件),集成了 Action 拦截...

伤神小怪兽
2012/11/13
9.2K
3
开源GUI框架库--Nana C++ Library

Nana C++库是由国人Jinhao开发的开源GUI框架库,类似标准库和boost代码风格,很“现代”,包含GUI、线程以及文件系统等函数和类。目前支持windows和Linux X11平台,分为C++03和C++11两个分支...

匿名
2012/12/09
6.3K
0

没有更多内容

加载失败,请刷新页面

加载更多

如何使用pip升级所有Python软件包? - How to upgrade all Python packages with pip?

问题: Is it possible to upgrade all Python packages at one time with pip ? 是否可以通过pip一次升级所有Python软件包? Note : that there is a feature request for this on the off......

法国红酒甜
11分钟前
0
0
活体检测+合成图鉴别面前,人脸“照片活化”黑产攻击一秒被擒

本文作者:y****n 如今,随着人脸技术的日趋成熟,新兴娱乐文化得到了极大的推动,尤其是随着 DeepFake、FaceSwap 等人脸编辑及生成技术的发展,虚拟主播、人脸合成带给人们全新的体验,但同...

百度开发者中心
昨天
0
0
如何在SQL Server中将多行文本合并为单个文本字符串?

问题: Consider a database table holding names, with three rows: 考虑一个包含名称的数据库表,该表具有三行: PeterPaulMary Is there an easy way to turn this into a single str......

富含淀粉
42分钟前
9
0
在JavaScript中生成特定范围内的随机整数? - Generating random whole numbers in JavaScript in a specific range?

问题: 如何可以生成两个指定的变量之间的随机整数在JavaScript中,例如x = 4和y = 8将输出任何的4, 5, 6, 7, 8 ? 解决方案: 参考一: https://stackoom.com/question/6PRz/在JavaScript中...

fyin1314
今天
8
0
Vim清除最后一个搜索突出显示 - Vim clear last search highlighting

问题: Want to improve this post? 想要改善这篇文章吗? Provide detailed answers to this question, including citations and an explanation of why your answer is correct. 提供此问题......

技术盛宴
今天
23
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部