day31_Hibernate学习笔记_03
2018-07-16 02:38:53来源：博客园 阅读 ()
一、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：先返回一个代理对象，使用代理对象的属性时，才去查询数据库。
false：load方法一执行就会发送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查询分类：
1、get/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.class, 1, 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.class, 1, 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.class, 1);
c.setCname("lucy");
System.out.println(c);
session.getTransaction().commit();
session.close();
}
}
标签：
版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有
相关文章
- 学习Java 8 Stream Api (4) - Stream 终端操作之 collect 2020-06-11
- java学习之第一天 2020-06-11
- Java学习之第二天 2020-06-11
- Spring WebFlux 学习笔记 - (一) 前传:学习Java 8 Stream Ap 2020-06-11
- Linux简单命令的学习 2020-06-10
IDC资讯： 主机资讯 注册资讯 托管资讯 vps资讯 网站建设
网站运营： 建站经验 策划盈利 搜索优化 网站推广 免费资源
网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它
服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护
软件技巧： 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷
网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash
热门词条
最新资讯
热门关注
热门标签