1.1.1Hibernate的关联关系映射:(多对多)
1.1.1.1多对多的配置:
步骤一创建实体和映射:
Student:
public class Student {
private Integer sid;
private String sname;
// 学生选择多门课程.
private Set courses = new HashSet();
…
}
Course:
public class Course {
private Integer cid;
private String cname;
// 课程可以被多个学生选择:
private Set students = new HashSet();
…
}
Student.hbm.xml
Course.hbm.xml
<property name="cname" column="cname"/>
<!-- 配置多对多关联关系映射 -->
<set name="students" table="stu_cour">
<key column="cno"/>
<many-to-many class="cn.itcast. demo3.Student" column="sno"/>
</set>
</class>
2.1检索方式
立即检索：立即查询，在执行查询语句时，立即查询所有的数据。
延迟检索：延迟查询，在执行查询语句之后，在需要时在查询。（懒加载）
2.2检查策略
类级别检索：当前的类的属性获取是否需要延迟。
关联级别的检索：当前类 关联 另一个类是否需要延迟。
2.3类级别检索
get：立即检索。get方法一执行，立即查询所有字段的数据。
load：延迟检索。默认情况，load方法执行后，如果只使用OID的值不进行查询，如果要使用其他属性值将查询 。 Customer.hbm.xml
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介绍
容器 提供两个属性：fetch、lazy
fetch：确定使用sql格式
lazy：关联对象是否延迟。
fetch：join、select、subselect
join：底层使用迫切左外连接
select：使用多个select语句（默认值）
subselect：使用子查询
lazy：false、true、extra
false：立即
true：延迟（默认值）
extra：极其懒惰
2.4.1.2fetch=“join”
fetch=“join” ，lazy无效。底层使用迫切左外连接，使用一条select将所有内容全部查询。
@Test
public void demo03() {
//关联级别：一对多，
// * Customer.hbm.xml
// *** 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.3fetch=“select”
当前对象 和 关联对象 使用多条select语句查询。
lazy=“false” , 立即，先查询客户select，立即查询订单select
lazy=“true”,延迟，先查询客户select，需要订单时，再查询订单select
lazy=“extra”，极其懒惰（延迟），先查询客户select， 如果只需要订单数，使用聚合函数（不查询详情）
2.4.1.4fetch=“subselect”
将使用子查询。注意：必须使用Query否则看不到效果。
lazy= 同上
@Test
public void demo04() {
//关联级别：一对多，
// 演示3：* Customer.hbm.xml
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介绍
()
fetch取值：join、select
join：底层使用迫切左外连接
select：多条select语句
lazy取值：false、proxy、no-proxy
false：立即
proxy：采用关联对象 类级别检索的策略。
订单 关联 客户 （多对一）
订单 立即获得 客户，需要在客户Customer.hbm.xml
订单 延迟获得 客户，需要在客户Customer.hbm.xml
no-proxy 不研究
2.4.2.2fetch=“join”
fecth=“join” select语句使用左外连接，此时lazy无效。
@Test
public void demo05() {
//关联级别：多对一，
// 演示1：* Order.hbm.xml 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.3fetch=“select”
将采用多条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 (?,?,?,?)
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();
}
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】
4HQL【掌握】
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 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.5投影查询（部分）
@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.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© 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命名查询
思想：将HQL从java源码中，提取到配置文件中。
分类：全局、布局
配置
全局：*.hbm.xml HQL语句
局部： HQL
获得
全局：
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();
}
4.11离线查询
DetachedCriteria 离线查询对象，不需要使用Session就可以拼凑查询条件。一般使用在web层或service层拼凑。将此对象传递给dao层，此时将与session进行绑定执行查询。
离线查询条件与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();
}
5QBC【了解】
5.1.1.1QBC查询:
QBC:Query By Criteria条件查询.面向对象的查询的方式.
5.1.1.2QBC简单的查询:
// 简单查询:
List list = session.createCriteria(Customer.class).list();
for (Customer customer : list) {
System.out.println(customer);
}
5.1.1.3QBC分页的查询:
Criteria criteria = session.createCriteria(Order.class);
criteria.setFirstResult(10);
criteria.setMaxResults(10);
List list = criteria.list();
5.1.1.4QBC排序查询:
Criteria criteria = session.createCriteria(Customer.class);
// criteria.addOrder(org.hibernate.criterion.Order.asc(“age”));
criteria.addOrder(org.hibernate.criterion.Order.desc(“age”));
List list = criteria.list();
5.1.1.5QBC条件查询:
// 按名称查询:
/Criteria criteria = session.createCriteria(Customer.class);
criteria.add(Restrictions.eq(“cname”, “任童”));
List list = criteria.list();/
// 模糊查询;
/*Criteria criteria = session.createCriteria(Customer.class);
criteria.add(Restrictions.like("cname", "任%"));
List<Customer> list = criteria.list();*/
// 条件并列查询
Criteria criteria = session.createCriteria(Customer.class);
criteria.add(Restrictions.like("cname", "任%"));
criteria.add(Restrictions.ge("age", 35));
List<Customer> list = criteria.list();
6常见配置
6.1整合c3p0(连接池) （了解）
别人这么说：hibernate 本身没有连接池，性能较低，需要整合其他连接池。
hibernate提供连接池，简单连接池，基本功能都有。
默认实现：DriverManagerConnectionProvider
整合c3p0
步骤一：导入c3p0 jar包
步骤二：hibernate.cfg.xml 配置
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
6.2事务
6.2.1回顾
事务：一组业务操作，要么全部成功，要么全部不成功。
特性：ACID
原子性：整体
一致性：数据
隔离性：并发
持久性：结果
隔离问题：
脏读：一个事务读到另一个事务未提交的内容
不可重复读：一个事务读到另一个事务已提交的内容（insert）
虚读（幻读）：一个事务读到另一个事务已提交的内容（update）
隔离级别–解决问题
read uncommittd，读未提交。存在3个问题。
read committed，读已提交。解决：脏读。存在2个问题。
repeatable read ，可重复读。解决：脏读、不可重复读。存在1个问题。
serializable，串行化。单事务。没有问题。
6.2.2hibernate设置隔离级别
在hibernate.cfg.xml 配置
hibernate.connection.isolation 4
6.2.3lost update 丢失更新
悲观锁：丢失更新肯定会发生。
采用数据库锁机制。
读锁：共享锁。
select … from … lock in share mode;
写锁：排他锁。（独占）
select … from … for update
乐观锁：丢失更新肯定不会发生
在表中提供一个字段（版本字段），用于标识记录。如果版本不一致，不允许操作。
6.2.4hibernate处理丢失更新
悲观锁：写锁
@Test
public void demo01(){
//1 查询所有
Session session = factory.openSession();
session.beginTransaction();
Customer customer = (Customer) session.get(Customer.class, 1 ,LockMode.UPGRADE);
System.out.println(customer);
session.getTransaction().commit();
session.close();
}
乐观锁：
在PO对象（javabean）提供字段，表示版本字段。一般Integer
在*.hbm.xml 文件配置
步骤一：
步骤二：
步骤三：测试
@Test
public void demo02(){
//1 查询所有
Session session = factory.openSession();
session.beginTransaction();
// Order order = new Order();
// order.setPrice(998d);
// session.save(order);
Order order = (Order) session.get(Order.class, 32);
order.setPrice(889d);
session.getTransaction().commit();
session.close();
}
595
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
