hibernate（三）多对多、加载策略、懒加载、HQL查询、整合c3p0、乐观锁悲观锁
1、多对多关系
2、加载策略（优化查询）
2.1、类级别加载策略
2.2、关联级别加载策略--一对多(查询集合时间时使用，比如查询Customer下面的Set<Order>)
2.3、关联级别加载策略--多对一(查询外键所在的对象，即查询Order时使用)
2.4、批量查询加载策略
2.5、加载策略-总结
3、查询总结
4、HQL详解
5、HQL查询--表连接
6、HQL的命名查询
7、QBC查询(了解)
8、整合c3p0连接池
9、事务&Hibernate中指定隔离级别
10、悲观锁
11、乐观锁
1、多对多关系 <--返回目录
创建实体类Student.java
public class Student{ private Integer id; private String name; private Set<Course> courses = new HashSet<>(); }
创建实体类Course.java
public class Course{ private Integer id; private String name; private Set<Student> students = new HashSet<>(); }
映射文件Student.hbm.xml
<class name="com.oy.domain.Student" table="t_student"> <id name="id" column="id"> <generator class="native"></generator> </id> <property name="name" column="name"></property> <set name="courses" table="t_student_course"> <key column="sid" /> <many-to-many class="com.oy.domain.Course" column="cid" /> </set> </class>
映射文件Course.hbm.xml
<class name="com.oy.domain.Course" table="t_course" > <id name="id" column="id" > <generator class="native"></generator> </id> <property name="name" column="name" ></property> <set name="students" table="t_student_course" inverse="true" > <key column="cid" ></key> <many-to-many class="Student" column="sid" ></many-to-many> </set> </class>
测试代码
@Test public void fun1() { Session session = HibernateUtils.openSession(); Transaction ts = session.beginTransaction(); // ============================================== Student s = new Student(); s.setName("张无忌"); Course c1 = new Course(); c1.setName("乾坤大挪移"); Course c2 = new Course(); c2.setName("九阳神功"); s.getCourses().add(c1); s.getCourses().add(c2); session.save(c1); session.save(c2); session.save(s); // ============================================== ts.commit(); // 事务提交，这里使用insert into语句 session.close(); }
控制台打印
Hibernate: insert into t_course (name) values (?) Hibernate: insert into t_course (name) values (?) Hibernate: insert into t_student (name) values (?) Hibernate: insert into t_student_course (sid, cid) values (?, ?) Hibernate: insert into t_student_course (sid, cid) values (?, ?) 虚拟机关闭!释放资源
数据库记录
t_student 表
t_course 表
t_student_course 表
操作:
- inverse: 是否要放弃维护外键关系
- cascade: 是否需要级联操作 (5个)
- 注意: 配置级联删除时,要小心,双方都配置级联删除, 任意删除一条记录, 整个关系链数据都会被删除
2、加载策略（优化查询） <--返回目录
策略种类:
延迟加载：等到使用的时候才会加载数据
立即加载：不管使用不使用,都会立刻将数据加载
策略的应用:
类级别的加载策略
关联级别的加载策略
2.1、类级别加载策略 <--返回目录
类级别加载策略：
get() 方法，立即查询数据库，将数据初始化
load() 方法，hbm 文件中，class 元素的 lazy 属性决定类级别 load 方法的加载策略，lazy 默认为 true
1) lazy=true（默认）： 先返回一个代理对象，使用代理对象的属性时，才去查询数据库
2) lazy=false: 与 get() 一致，会立即加载数据
类级别懒加载测试
- lazy：<class>元素属性，默认为 true，即使用懒加载
- 映射文件 Customer.hbm.xml:<class name="Customer" table="t_customer"> lazy 没有设置，默认为 true
Customer c = (Customer)session.load(Customer.class, 1);//断点发现，运行此行代码后，不打印sql语句 System.out.println(c.getName());//运行此行代码，打印sql语句
- 映射文件Customer.hbm.xml:<class name="Customer" table="t_customer" lazy="false">
Customer c = (Customer)session.load(Customer.class, 1);//断点发现，运行此行代码后，打印sql语句
2.2、关联级别加载策略--一对多(查询集合时间时使用，比如查询Customer下面的Set<Order>) <--返回目录
在查询有关联关系的数据时，加载一方的数据是否需要将另一方立即查询出。
默认: 关联的数据，在使用时才会加载。
lazy：<set>元素属性，默认为true，即使用懒加载
映射文件Customer.hbm.xml:<set name="orders" lazy="true"> lazy没有设置，默认为true
Customer c = (Customer)session.get(Customer.class, 1);//get()方法立即加载，查询Customer，但是不会查询Customer下面的Order for(Order o: c.getOrders){ //c.getOrders执行后，会查询Customer下面的所有Order System.out.println(o.getName()); }
映射文件 Customer.hbm.xml:<set name="orders" lazy="false">
Customer c = (Customer)session.get(Customer.class, 1);//查询Customer，并且查询Customer下面的所有Order
<set lazy="">: 是否对set数据使用懒加载
- true:(默认值) 对集合使用才加载
- false: 集合将会被立即加载
- extra: 极其懒惰,如果使用集合时,之调用size方法查询数量, Hibernate会发送count语句,只查询数量.不加载集合内数据.
<set fetch="">：<set>元素的属性，决定加载集合使用的sql语句种类
- select: (默认值) 普通select查询
- join: 表链接语句查询集合数据
- subselect: 使用子查询 一次加载多个Customer的订单数据
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.3、关联级别加载策略--多对一(查询外键所在的对象，即查询Order时使用) <--返回目录
<many-to-one lazy="">
- false: 关闭懒加载；加载订单时,会立即加载客户
- proxy: 看客户对象的类加载策略来决定
- no-proxy: 不做研究
<many-to-one fetch="">
- select:(默认值)使用普通select加载
- join:使用表链接加载数据
fetch lazy 结果
---------------------------------------------------------------------------------------
select false 加载订单时,立即加载客户数据.普通select语句加载客户.
select proxy 类加载策略为:lazy=false 同上
lazy=true 加载订单时,先不加载客户数据.使用客户数据时才加载
join false 使用表链接查询订单以及对应客户信息.lazy属性无效
join proxy 使用表链接查询订单以及对应客户信息.lazy属性无效
---------------------------------------------------------------------------------------
映射文件 Order.hbm.xml <many-to-one lazy="false" fetch="select">
Order o = (Order)session.get(Order.class, 1);//关闭懒加载；加载订单时,立即加载客户数据 System.out.println(o.getCustomer().getName());
2.4、批量查询加载策略 <--返回目录
查询所有客户，遍历客户，打印客户下的订单
List<Customer> list = session.createQuery("from Customer").list();
for(Customer c: list){
(System.out.println(c.getOrders().size());//每循环一次，发送一条sql语句，加载一个客户的order的集合
}
<set name="orders" batch-size="2">
List<Customer> list = session.createQuery("from Customer").list();
for(Customer c: list){
(System.out.println(c.getOrders().size());//一次加载两个客户的order集合
}
总结batch-size:决定一次加载几个对象的集合数据. in 条件加载多个用户的订单
2.5、加载策略-总结 <--返回目录
* 表连接件检索用到比较少
* 延迟检索和立即检索的优缺点
* 如何解决延迟加载的缺点：
缺点描述：在dao层有一个方法Customer getCustomer(int id),
return session.load(Customer.class, id);return的是查询出的Customer对象代理对象
中间没有使用查询出的Customer对象的属性，此时由于使用延迟加载，该return结果没有初始化。
* 解决方案1：设置lazy=false关闭懒加载
* 解决方案2：在Service层获得在页面要用到的属性=>在Service层中确保数据已经加载
3、查询总结 <--返回目录
HIbernate查询分类：
1）根据OID检索：get/load()
2）对象视图检索：customer.getOrders()
3）sql语句：createSqlQuery
4）HQL语句：createQuery
5）criteria查询：createcriteria
4、HQL详解 <--返回目录
要用到的表t_order 表t_customer
------------------- ------------------
oid oname cid cid cname
------------------- ------------------
1 香皂 1 1 zs
2 肥皂 1 2 ls
3 蜡烛 2 3 ww
4 手电筒 2
5 胶带 2
-------------------
HQL查询所有
Query query = session.createQuery("from Customer");
//Query query = session.createQuery("from Customer c");//指定别名为c
//Query query = session.createQuery("select c from Customer c");//其他写法
List<Customer> list = query.list();
选择查询（查询对象的某几个属性）
Query query = session.createQuery("select c.name from Customer c");//c.name为对象属性名，
List list = query.list();
System.out.println(list);//[tom,jerry]
Query query = session.createQuery("select c.id, c.name from Customer c");
List<Object[]> list = query.list();
for(Object[] objs: list){
System.out.println(Arrays.toString(objs));//[1, tom] [2,jerry]
}
投影查询:选择查询的基础上，把查询结果封装到对象中
Query query = session.createQuery("select new Customer(c.id, c.name) from Customer c");//Customer对象要有含参构造方法
List<Customer> list = query.list();
排序:asc升序，desc降序
Query query = session.createQuery("from Customer c order by c.id desc");
分页
Query query = session.createQuery("from Customer c");
query.setFirstResult(0);//从哪个索引开始取数据,firstResutl=(当前页数-1)*每页记录数
query.setMaxResults(10);//查询多少条数据
List<Customer> list = query.list();
绑定参数
Query query = session.createQuery("from Customer c where c.id=?");
query.setInteger(0,2);//0表示第一个？
Customer c = (Customer)query.uniqueResult();
另一种方式：
Query query = session.createQuery("from Customer c where c.id=haha");
query.setInteger("haha",2);
聚合函数
Query query = session.createQuery("select count(*) from Customer c");
Object count = query.uniqueResult();
select avg(c.id) from Customer c
select sum(c.id) from Customer c
select max(c.id) from Customer c
select min(c.id) from Customer c
分组
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));//[Customer对象, 3]
}
5、HQL查询--表连接 <--返回目录
表连接：交叉连接(笛卡尔积)、内连接(去笛卡尔积)、左外连接、右外连接
隐式内连接(mysql方言)--在笛卡尔积基础上过滤无效数据。
显示内连接(标准,建议使用)-- inner join
//Query query = session.createQuery("from Customer c, Order o where o.customer=c");//隐式内连接(mysql方言) Query query = session.createQuery("from Customer c inner join c.orders");//显示内连接 List<Object[]> list = query.list(); System.out.println(Arrays.toString(list.get(1)));//[Customer [cid=1, cname=zs, orders=[Order [oid=2, oname=肥皂], //Order [oid=1, oname=香皂]]], Order [oid=2, oname=肥皂]] for(Object[] objs: list){ //遍历打印 System.out.println(Arrays.toString(objs)); }
打印
[Customer [cid=1, cname=zs, orders=[Order [oid=2, oname=肥皂], Order [oid=1, oname=香皂]]], Order [oid=1, oname=香皂]] [Customer [cid=1, cname=zs, orders=[Order [oid=2, oname=肥皂], Order [oid=1, oname=香皂]]], Order [oid=2, oname=肥皂]] [Customer [cid=2, cname=ls, orders=[Order [oid=5, oname=胶带], Order [oid=4, oname=手电筒], Order [oid=3, oname=蜡烛]]], Order [oid=3, oname=蜡烛]] [Customer [cid=2, cname=ls, orders=[Order [oid=5, oname=胶带], Order [oid=4, oname=手电筒], Order [oid=3, oname=蜡烛]]], Order [oid=4, oname=手电筒]] [Customer [cid=2, cname=ls, orders=[Order [oid=5, oname=胶带], Order [oid=4, oname=手电筒], Order [oid=3, oname=蜡烛]]], Order [oid=5, oname=胶带]]
内连接(迫切)：查询结果List<Customer>；二非迫切查询List<Object[]>
Query query = session.createQuery("from Customer c inner join fetch c.orders");
List<Customer> list = query.list();
for(Customer c: list){
System.out.println(c);
}
打印
Customer [cid=1, cname=zs, orders=[Order [oid=1, oname=香皂], Order [oid=2, oname=肥皂]]] Customer [cid=1, cname=zs, orders=[Order [oid=1, oname=香皂], Order [oid=2, oname=肥皂]]] Customer [cid=2, cname=ls, orders=[Order [oid=4, oname=手电筒], Order [oid=5, oname=胶带], Order [oid=3, oname=蜡烛]]] Customer [cid=2, cname=ls, orders=[Order [oid=4, oname=手电筒], Order [oid=5, oname=胶带], Order [oid=3, oname=蜡烛]]] Customer [cid=2, cname=ls, orders=[Order [oid=4, oname=手电筒], Order [oid=5, oname=胶带], Order [oid=3, oname=蜡烛]]]
注意：以后实体类中重写toString()方法：包含外键的类toString()中不要包含代表外键的属性！！！
否则，在使用内连接查询后，打印结果抛异常：java.lang.StackOverflowError
左外连接：from Customer c left outer join fetch c.orders //会打印出[Customer [cid=3, cname=ww, orders=[]], null]
右外连接： from Customer c right outer join fetch c.orders
6、HQL的命名查询 <--返回目录
映射文件Customer.hbm.xml
<hibernate-mapping> <class> <!--局部配置--> <query name="bcd"><![CDATA[from Order]]</query> </class> <!--全局配置--> <query name="abc"><![CDATA[from Customer]]</query> </hibernate-mapping>
找到局部配置的HQL语句
Query query = session.getNamedQuery("com.oy.domain.Cumtomer.bcd");//表示从Cumtomer.hbm.xml找名称为bcd的HQL语句
找全局配置的HQL语句
Query query = session.getNamedQuery("Cumtomer.abc");
7、QBC查询(了解) <--返回目录
QBC查询结束criteria查询
只能单表查询(不能表连接查询)
8、整合c3p0连接池 <--返回目录
1) 导包
2) 在hibernate.cfg.xml中配置
<property name="hibernate.connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property> <property name="hibernate.c3p0.max_size">2</property>
设置参数：不设置的化，有默认值
#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
如果连接池参数设置不好，可能会降低系统效率
9、事务&Hibernate中指定隔离级别 <--返回目录
事务的特性ACID：
- 原子性：整体
- 一致性：数据
- 隔离性：并发
- 持久性：结果
改变Hibernate连接数据库的事务隔离级别
<property name="hibernate.connection.isolation">4</>
1: 读未提交
2：读已提交
4：可重复读
8：串行化
10、悲观锁 <--返回目录
悲观锁：数据库提供实现。防止别人跟我抢着修改数据，分为读锁和写锁
读锁/共享锁：在读取过程中，不希望别人修改，并且自己也不会修改，我们可以给读取的数据加上读锁
select * from t_user lock in share mode
写锁/排他锁：我不仅要读还要对数据进行修改，我就可以为读取的数据加上写锁
select * from t_user for update
hibernate 中使用悲观锁
@Test public void fun1() { Session session = HibernateUtils.openSession(); Transaction ts = session.beginTransaction(); // ============================================== Student s = (Student) session.get(Student.class, 1, LockOptions.UPGRADE); System.out.println(s); // ============================================== ts.commit(); // 事务提交，这里使用insert into语句 session.close(); }
打印
Hibernate: select student0_.id as id0_0_, student0_.name as name0_0_ from t_student student0_ where student0_.id=? for update
演示写锁
debug 模式调试
另一事务提交，写锁被释放，该事务可以读取到数据了
11、乐观锁 <--返回目录
乐观锁：人为来控制的锁，需要自己实现
乐观锁实现：通过字段 version实现，修改前判断 version，只有大于数据库表的version 才能修改成功
hibernate 中 乐观锁的实现
实体类中添加 version 字段
private Integer version; public Integer getVersion() { return version; } public void setVersion(Integer version) { this.version = version; }
实体类对应的映射文件添加
测试
@Test public void fun1() { Session session = HibernateUtils.openSession(); Transaction ts = session.beginTransaction(); // ============================================== Student s = (Student) session.get(Student.class, 1); s.setName("jack1"); System.out.println(s); // ============================================== ts.commit(); // 事务提交，这里使用insert into语句 session.close(); }
数据库实体类对应的表自动添加了字段 version。每次修改成功后 version 增1
断点测试乐观锁的生效
程序中查出version=2，如果程序update成功，会将 version 加1。为了演示乐观锁的生效，手动修改数据库表中该记录version+1
手动将 version 改为 3
程序往下执行
报错（乐观锁起作用了）
org.hibernate.StaleObjectStateException: Row was updated or deleted by another transaction
(or unsaved-value mapping was incorrect): [com.oy.domain.Student#1]
---
posted on 2020-06-14 01:19 wenbin_ouyang 阅读(269) 评论(0) 编辑 收藏 举报
