Hibernate 复习
Paste_Image.png
Paste_Image.png
Paste_Image.png
基本演示：
hibernate创建的 java 工程，需要的 jar包：
hibernate.cfg.xml
com.mysql.jdbc.Driver
jdbc:mysql:///hibernate_demo
root
root
org.hibernate.dialect.MySQLDialect
true
true
update
Customer.java
public class Customer {
/*
* CREATE TABLE `cst_customer` (
`cust_id` BIGINT(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
`cust_name` VARCHAR(32) NOT NULL COMMENT '客户名称(公司名称)',
`cust_source` VARCHAR(32) DEFAULT NULL COMMENT '客户信息来源',
`cust_industry` VARCHAR(32) DEFAULT NULL COMMENT '客户所属行业',
`cust_level` VARCHAR(32) DEFAULT NULL COMMENT '客户级别',
`cust_linkman` VARCHAR(64) DEFAULT NULL COMMENT '联系人',
`cust_phone` VARCHAR(64) DEFAULT NULL COMMENT '固定电话',
`cust_mobile` VARCHAR(16) DEFAULT NULL COMMENT '移动电话',
PRIMARY KEY (`cust_id`)
) ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
*/
private Long cust_id;
private String cust_name;
private String cust_source;
private String cust_industry;
private String cust_level;
private String cust_linkman;
private String cust_phone;
private String cust_mobile;
set/get ...
@Override
public String toString() {
return "Customer [cust_id=" + cust_id + ", cust_name=" + cust_name + "]";
}
}
Customer.hbm.xml
测试
public class Test1 {
private static SessionFactory sessionFactory;
@Test
public void test1() {
Configuration configuration = new Configuration();
configuration.configure();
sessionFactory = configuration.buildSessionFactory();
Session session = sessionFactory.openSession();
Transaction transaction = session.beginTransaction();
Customer customer = new Customer();
customer.setCust_name("百度");
session.save(customer);
transaction.commit();
sessionFactory.close();
}
}
API 学习
Configuration对象
// Configuration功能: 配置加载类.用于加载主配置,orm元数据加载
public class Demo {
@Test
public void fun1(){
//1 创建,调用空参构造
Configuration conf = new Configuration();
//2 读取指定主配置文件 => 空参加载方法,加载src下的hibernate.cfg.xml文件
conf.configure();
//3 读取指定orm元数据(扩展),如果主配置中已经引入映射配置.不需要手动加载
//conf.addResource(resourceName);
//conf.addClass(persistentClass);
//4 根据配置信息,创建 SessionFactory对象
SessionFactory sf = conf.buildSessionFactory();
}
}
SessionFactory对象
// SessionFactory功能: 用于创建操作数据库核心对象session对象的工厂.
// 简单说功能就一个---创建session对象
//注意:1.sessionfactory 负责保存和使用所有配置信息.消耗内存资源非常大.
// 2.sessionFactory属于线程安全的对象设计.
//结论: 保证在web项目中,只创建一个sessionFactory.
public class Demo2 {
@Test
public void fun1(){
//1 创建,调用空参构造
Configuration conf = new Configuration();
//2 读取指定主配置文件 => 空参加载方法,加载src下的hibernate.cfg.xml文件
conf.configure();
//3 读取指定orm元数据(扩展),如果主配置中已经引入映射配置.不需要手动加载
//conf.addResource(resourceName);
//conf.addClass(persistentClass);
//4 根据配置信息,创建 SessionFactory对象
SessionFactory sf = conf.buildSessionFactory();
//--------------------------------------------------
//5 获得session
//打开一个新的session对象
sf.openSession();
//获得一个与线程绑定的session对象(明天讲解)
sf.getCurrentSession();
}
}
Session对象
//session对象功能: 表达hibernate框架与数据库之间的连接(会话).
//session类似于JDBC年代的connection对象. 还可以完成对数据库中数据的增删改查操作.
//session是hibernate操作数据库的核心对象
public class Demo3 {
@Test
//事务操作
public void fun1(){
//1 创建,调用空参构造
Configuration conf = new Configuration().configure();
//2 根据配置信息,创建 SessionFactory对象
SessionFactory sf = conf.buildSessionFactory();
//3 获得session
Session session = sf.openSession();
//4 session获得操作事务的Transaction对象
//获得操作事务的tx对象
//Transaction tx = session.getTransaction();
//开启事务并获得操作事务的tx对象(建议使用)
Transaction tx2 = session.beginTransaction();
//----------------------------------------------
//----------------------------------------------
tx2.commit();//提交事务
tx2.rollback();//回滚事务
session.close();//释放资源
sf.close();//释放资源
}
@Test
//session的新增
public void fun2(){
//1 创建,调用空参构造
Configuration conf = new Configuration().configure();
//2 根据配置信息,创建 SessionFactory对象
SessionFactory sf = conf.buildSessionFactory();
//3 获得session
Session session = sf.openSession();
//4 session获得操作事务的Transaction对象
//获得操作事务的tx对象
//Transaction tx = session.getTransaction();
//开启事务并获得操作事务的tx对象(建议使用)
Transaction tx2 = session.beginTransaction();
//----------------------------------------------
Customer c = new Customer();
c.setCust_name("谷歌");
session.save(c);
//----------------------------------------------
tx2.commit();//提交事务
session.close();//释放资源
sf.close();//释放资源
}
@Test
//session的查询
//查询id为1的customer对象
public void fun3(){
//1 创建,调用空参构造
Configuration conf = new Configuration().configure();
//2 根据配置信息,创建 SessionFactory对象
SessionFactory sf = conf.buildSessionFactory();
//3 获得session
Session session = sf.openSession();
//4 session获得操作事务的Transaction对象
//获得操作事务的tx对象
//Transaction tx = session.getTransaction();
//开启事务并获得操作事务的tx对象(建议使用)
Transaction tx2 = session.beginTransaction();
//----------------------------------------------
Customer customer = session.get(Customer.class, 1l);
System.out.println(customer);
//----------------------------------------------
tx2.commit();//提交事务
session.close();//释放资源
sf.close();//释放资源
}
@Test
//session的修改
//修改id为1的customer对象的name属性为脸书
public void fun4(){
//1 创建,调用空参构造
Configuration conf = new Configuration().configure();
//2 根据配置信息,创建 SessionFactory对象
SessionFactory sf = conf.buildSessionFactory();
//3 获得session
Session session = sf.openSession();
//4 session获得操作事务的Transaction对象
//获得操作事务的tx对象
//Transaction tx = session.getTransaction();
//开启事务并获得操作事务的tx对象(建议使用)
Transaction tx2 = session.beginTransaction();
//----------------------------------------------
//1 获得要修改的对象
Customer c = session.get(Customer.class, 1l);
//2 修改
c.setCust_name("脸书");
//3 执行update
session.update(c);
//----------------------------------------------
tx2.commit();//提交事务
session.close();//释放资源
sf.close();//释放资源
}
@Test
//session的删除
//删除id为1的customer对象
public void fun5(){
//1 创建,调用空参构造
Configuration conf = new Configuration().configure();
//2 根据配置信息,创建 SessionFactory对象
SessionFactory sf = conf.buildSessionFactory();
//3 获得session
Session session = sf.openSession();
//4 session获得操作事务的Transaction对象
//获得操作事务的tx对象
Transaction tx = session.getTransaction();
tx.begin();
//开启事务并获得操作事务的tx对象(建议使用)
Transaction tx2 = session.beginTransaction();
//----------------------------------------------
//1 获得要修改的对象
Customer c = session.get(Customer.class, 1l);
//2 调用delete删除对象
session.delete(c);
//----------------------------------------------
tx2.commit();//提交事务
session.close();//释放资源
sf.close();//释放资源
}
}
hibernate实体规则
实体类创建的注意事项
- 持久化类提供无参数构造
- 成员变量私有,提供共有get/set方法访问.需提供属性
- 持久化类中的属性,应尽量使用包装类型（数据库 null 无法给 基本类型赋值）
- 持久化类需要提供主键.与数据库中的主键列对应，没有主键不能映射到 hibernate。
- 不要用final修饰class
- hibernate使用cglib代理生成代理对象.代理对象是继承被代理对象.如果被final修饰.将无法生成代理.
主键类型
自然主键(少见)
表的业务列中,有某业务列符合,必须有,并且不重复的特征时,该列可以作为主键使用，例如身份证号，但是不推荐.
代理主键(常见)
表的业务列中,没有某业务列符合,必须有,并且不重复的特征时,创建一个没有业务意义的列作为主键，例如：id，uuid等，推荐。
主键生成策略
代理主键
- identity : 主键自增.由数据库来维护主键值.录入时不需要指定主键.
sequence: Oracle中的主键生成策略.
increment（了解）: 主键自增.由hibernate来维护.每次插入前会先查询表中id最大值.+1作为新主键值，具有线程安全问题.
hilo(了解): 高低位算法.主键自增.由hibernate来维护.开发时不使用.
native（推荐）:hilo+sequence+identity 自动三选一策略.
uuid（推荐）: 产生随机字符串作为主键. 主键类型必须为string 类型.
自然主键
- assigned:自然主键生成策略. hibernate不会管理主键值.由开发人员自己录入.
hibernate中的对象状态
对象分为三种状态
- 瞬时状态
- 没有id,没有在session缓存中
- 持久化状态
- 有id,在session缓存中
- 游离|托管状态
- 有id,没有在session缓存中
//测试对象的三种状态
public class Demo {
@Test
//查看三种状态
public void fun1(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
Customer c = new Customer(); // 没有id, 没有与session关联 => 瞬时状态
c.setCust_name("联想"); // 瞬时状态
session.save(c); // 持久化状态, 有id,有关联
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
@Test
//三种状态特点
//save方法: 其实不能理解成保存.理解成将瞬时状态转换成持久状态的方法
//主键自增 : 执行save方法时,为了将对象转换为持久化状态.必须生成id值.所以需要执行insert语句生成.
//increment: 执行save方法,为了生成id.会执行查询id最大值的sql语句.
public void fun2(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
Customer c = new Customer(); // 没有id, 没有与session关联 => 瞬时状态
c.setCust_name("联想"); // 瞬时状态
session.save(c); // 持久化状态, 有id,有关联
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
@Test
//三种状态特点
// 持久化状态特点: 持久化状态对象的任何变化都会自动同步到数据库中.
public void fun3(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
Customer c = session.get(Customer.class, 1l);//持久化状态对象
c.setCust_name("微软公司");
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
}
hibernate进阶-一级缓存
缓存:提高效率.hibernate中的一级缓存也是为了提高操作数据库的效率.
提高效率手段1:提高查询效率
提高效率手段2:减少不必要的修改语句发送
hibernate中的事务
事务特性
a 原子性（像物理原子一样，最小而不可分隔，全成功或全失败）
c 一致性（例如，转账 相加总量不变）
i 隔离性（隔离级别）
d 持久性（数据写到硬盘等持久化的物质上）
事务并发问题
1.脏读（查询正在操作还没有提交的数据）
2.不可重复度（两次查询数据不一致，中间可能别人操作了数据）
3.幻|虚读（删除记录的同时，别人又插入记录了，产生幻觉了）
事务的隔离级别
（表示上面的并发问题代表的1，2，3）
读未提交- 123
读已提交 - 23
可重复读(mysql默认级别)-3
串行化 - 没有问题，效率太低，不考虑。
在hibernate中指定数据库的隔离级别
hibernate.cfg.xml
com.mysql.jdbc.Driver
jdbc:mysql:///hibernate_32
root
1234
org.hibernate.dialect.MySQLDialect
true
true
update
4
thread
在项目中如何管理事务
业务开始之前打开事务,业务执行之后提交事务. 执行过程中出现异常.回滚事务.
在dao层操作数据库需要用到session对象.
在service控制事务也是使用session对象完成.
我们要确保dao层和service层使用的使用同一个session对象
在hibernate中,确保使用同一个session的问题,hibernate已经帮我们解决了. 我们开发人员只需要调用sf.getCurrentSession()方法即可获得与当前线程绑定的session对象，底层还是 ThreadLocal。
注意1:
调用getCurrentSession方法必须配置
thread
注意2:
通过getCurrentSession方法获得的session对象.当事务提交时,session会自动关闭.不要手动调用close关闭，手动 close 会报异常。
hibernate中的批量查询(概述)
HQL查询-hibernate Query Language
(多表查询,但不复杂时使用)
Hibernate独家查询语言,属于面向对象的查询语言
基本查询
//测试HQL语句
public class Demo {
@Test
//基本查询
public void fun1(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
//-------------------------------------------
//1> 书写HQL语句
// String hql = " from cn.itheima.domain.Customer ";
// 只有一个类名的话，那么可以不写包名。
String hql = " from Customer "; // 查询所有Customer对象
//2> 根据HQL语句创建查询对象
Query query = session.createQuery(hql);
//3> 根据查询对象获得查询结果
List list = query.list(); // 返回list结果
//query.uniqueResult();//接收唯一的查询结果
System.out.println(list);
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
}
条件查询
@Test
//条件查询
//HQL语句中,不可能出现任何数据库相关的信息的
public void fun2(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
//-------------------------------------------
//1> 书写HQL语句
String hql = " from Customer where cust_id = 1 "; // 查询所有Customer对象
//2> 根据HQL语句创建查询对象
Query query = session.createQuery(hql);
//3> 根据查询对象获得查询结果
Customer c = (Customer) query.uniqueResult();
System.out.println(c);
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
排序查询
@Test
//排序
public void fun2(){
Session session = HibernateUtils.openSession();
Transaction tx = session.beginTransaction();
//----------------------------------------------------
String hql1 = " from cn.itcast.domain.Customer order by cust_id asc ";//完整写法
String hql2 = " from cn.itcast.domain.Customer order by cust_id desc ";//完整写法
Query query = session.createQuery(hql2);
List list = query.list();
System.out.println(list);
//----------------------------------------------------
tx.commit();
session.close();
}
?号占位符
@Test
//条件查询
//问号占位符
public void fun3(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
//-------------------------------------------
//1> 书写HQL语句
String hql = " from Customer where cust_id = ? "; // 查询所有Customer对象
//2> 根据HQL语句创建查询对象
Query query = session.createQuery(hql);
//设置参数
//query.setLong(0, 1l);
query.setParameter(0, 1l);
//3> 根据查询对象获得查询结果
Customer c = (Customer) query.uniqueResult();
System.out.println(c);
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
命名占位符
@Test
//条件查询
//命名占位符
public void fun4(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
//-------------------------------------------
//1> 书写HQL语句
String hql = " from Customer where cust_id = :cust_id "; // 查询所有Customer对象
//2> 根据HQL语句创建查询对象
Query query = session.createQuery(hql);
//设置参数
query.setParameter("cust_id", 1l);
//3> 根据查询对象获得查询结果
Customer c = (Customer) query.uniqueResult();
System.out.println(c);
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
分页查询
@Test
//分页查询
public void fun5(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
//-------------------------------------------
//1> 书写HQL语句
String hql = " from Customer "; // 查询所有Customer对象
//2> 根据HQL语句创建查询对象
Query query = session.createQuery(hql);
//设置分页信息 limit ?,?
query.setFirstResult(1);
query.setMaxResults(1);
//3> 根据查询对象获得查询结果
List list = query.list();
System.out.println(list);
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
统计查询
@Test
//统计查询
//count 计数
//sum 求和
//avg 平均数
//max
//min
public void fun5(){
Session session = HibernateUtils.openSession();
Transaction tx = session.beginTransaction();
//----------------------------------------------------
String hql1 = " select count(*) from cn.itcast.domain.Customer ";//完整写法
String hql2 = " select sum(cust_id) from cn.itcast.domain.Customer ";//完整写法
String hql3 = " select avg(cust_id) from cn.itcast.domain.Customer ";//完整写法
String hql4 = " select max(cust_id) from cn.itcast.domain.Customer ";//完整写法
String hql5 = " select min(cust_id) from cn.itcast.domain.Customer ";//完整写法
Query query = session.createQuery(hql5);
Number number = (Number) query.uniqueResult();
System.out.println(number);
//----------------------------------------------------
tx.commit();
session.close();
}
投影查询
就是查询默写字段名字，不是全部* 。
@Test
//投影查询
public void fun6(){
Session session = HibernateUtils.openSession();
Transaction tx = session.beginTransaction();
//----------------------------------------------------
String hql1 = " select cust_name from cn.itcast.domain.Customer ";
// 字段查询到自动封装Object[] 中
String hql2 = " select cust_name,cust_id from cn.itcast.domain.Customer ";
// 字段查询到自动封装到 Model中，同时Customer需要创建2个参数的构造函数。
String hql3 = " select new Customer(cust_id,cust_name) from cn.itcast.domain.Customer ";
Query query = session.createQuery(hql3);
List list = query.list();
System.out.println(list);
//----------------------------------------------------
tx.commit();
session.close();
}
多表查询
//学习HQL语法(不常用) - 多表查询语法
public class Demo2 {
//回顾-原生SQL
// 交叉连接-笛卡尔积(避免)
// select * from A,B
// 内连接
// |-隐式内连接
// select * from A,B where b.aid = a.id
// |-显式内连接
// select * from A inner join B on b.aid = a.id
// 外连接
// |- 左外
// select * from A left [outer] join B on b.aid = a.id
// |- 右外
// select * from A right [outer] join B on b.aid = a.id
//---------------------------------------------------------------------
//HQL的多表查询
//内连接(迫切)
//外连接
// |-左外(迫切)
// |-右外(迫切)
@Test
//HQL 内连接 => 将连接的两端对象分别返回.放到数组中.
public void fun1(){
Session session = HibernateUtils.openSession();
Transaction tx = session.beginTransaction();
//----------------------------------------------------
String hql = " from Customer c inner join c.linkMens ";
Query query = session.createQuery(hql);
List list = query.list();
for(Object[] arr : list){
System.out.println(Arrays.toString(arr));
}
//----------------------------------------------------
tx.commit();
session.close();
}
@Test
//HQL 迫切内连接 => 帮我们进行封装.返回值就是一个对象
public void fun2(){
Session session = HibernateUtils.openSession();
Transaction tx = session.beginTransaction();
//----------------------------------------------------
String hql = " from Customer c inner join fetch c.linkMens ";
Query query = session.createQuery(hql);
List list = query.list();
System.out.println(list);
//----------------------------------------------------
tx.commit();
session.close();
}
@Test
//HQL 左外连接 => 将连接的两端对象分别返回.放到数组中.
public void fun3(){
Session session = HibernateUtils.openSession();
Transaction tx = session.beginTransaction();
//----------------------------------------------------
String hql = " from Customer c left join c.linkMens ";
Query query = session.createQuery(hql);
List list = query.list();
for(Object[] arr : list){
System.out.println(Arrays.toString(arr));
}
//----------------------------------------------------
tx.commit();
session.close();
}
@Test
//HQL 右外连接 => 将连接的两端对象分别返回.放到数组中.
public void fun4(){
Session session = HibernateUtils.openSession();
Transaction tx = session.beginTransaction();
//----------------------------------------------------
String hql = " from Customer c right join c.linkMens ";
Query query = session.createQuery(hql);
List list = query.list();
for(Object[] arr : list){
System.out.println(Arrays.toString(arr));
}
//----------------------------------------------------
tx.commit();
session.close();
}
}
Criteria查询
(单表条件查询)
Hibernate自创的无语句面向对象查询
基本查询
//测试Criteria查询
public class Demo {
@Test
//基本查询
public void fun1(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
//-------------------------------------------
//查询所有的Customer对象
Criteria criteria = session.createCriteria(Customer.class);
List list = criteria.list();
System.out.println(list);
// Customer c = (Customer) criteria.uniqueResult();
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
}
条件查询
@Test
//条件查询
//HQL语句中,不可能出现任何数据库相关的信息的
// > gt
// >= ge
// < lt
// <= le
// == eq
// != ne
// in in
// between and between
// like like
// is not null isNotNull
// is null isNull
// or or
// and and
public void fun2(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
//-------------------------------------------
//创建criteria查询对象
Criteria criteria = session.createCriteria(Customer.class);
//添加查询参数 => 查询cust_id为1的Customer对象
criteria.add(Restrictions.eq("cust_id", 1l));
//执行查询获得结果
Customer c = (Customer) criteria.uniqueResult();
System.out.println(c);
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
分页 查询
@Test
//分页查询
public void fun3(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
//-------------------------------------------
//创建criteria查询对象
Criteria criteria = session.createCriteria(Customer.class);
//设置分页信息 limit ?,?
criteria.setFirstResult(1);
criteria.setMaxResults(2);
//执行查询
List list = criteria.list();
System.out.println(list);
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
设置查询总记录数
@Test
//查询总记录数
public void fun4(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
//-------------------------------------------
//创建criteria查询对象
Criteria criteria = session.createCriteria(Customer.class);
//设置查询的聚合函数 => 总行数
criteria.setProjection(Projections.rowCount());
//执行查询
Long count = (Long) criteria.uniqueResult();
System.out.println(count);
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
排序
@Test
//排序语法
public void fun4(){
Session session = HibernateUtils.openSession();
Transaction tx = session.beginTransaction();
//----------------------------------------------------
Criteria c = session.createCriteria(Customer.class);
c.addOrder(Order.asc("cust_id"));
//c.addOrder(Order.desc("cust_id"));
List list = c.list();
System.out.println(list);
//----------------------------------------------------
tx.commit();
session.close();
}
离线查询
区别就是创建的时候是否需要 session
非离线
离线
//学习离线Criteria
public class Demo2 {
@Test
public void fun1(){
//Service/web层
DetachedCriteria dc = DetachedCriteria.forClass(Customer.class);
dc.add(Restrictions.idEq(6l));//拼装条件(全部与普通Criteria一致)
//----------------------------------------------------
Session session = HibernateUtils.openSession();
Transaction tx = session.beginTransaction();
//----------------------------------------------------
Criteria c = dc.getExecutableCriteria(session);
List list = c.list();
System.out.println(list);
//----------------------------------------------------
tx.commit();
session.close();
}
}
演示
原生SQL查询
(复杂的业务查询)
基本查询
返回数组List
@Test
//基本查询
public void fun1(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
//-------------------------------------------
//1 书写sql语句
String sql = "select * from cst_customer";
//2 创建sql查询对象
SQLQuery query = session.createSQLQuery(sql);
//3 调用方法查询结果
List list = query.list();
//query.uniqueResult();
for(Object[] objs : list){
System.out.println(Arrays.toString(objs));
}
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
返回对象List
@Test
//基本查询
public void fun2(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
//-------------------------------------------
//1 书写sql语句
String sql = "select * from cst_customer";
//2 创建sql查询对象
SQLQuery query = session.createSQLQuery(sql);
//指定将结果集封装到哪个对象中
query.addEntity(Customer.class);
//3 调用方法查询结果
List list = query.list();
System.out.println(list);
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
条件查询
@Test
//条件查询
public void fun3(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
//-------------------------------------------
//1 书写sql语句
String sql = "select * from cst_customer where cust_id = ? ";
//2 创建sql查询对象
SQLQuery query = session.createSQLQuery(sql);
query.setParameter(0, 1l);
//指定将结果集封装到哪个对象中
query.addEntity(Customer.class);
//3 调用方法查询结果
List list = query.list();
System.out.println(list);
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
分页查询
@Test
//分页查询
public void fun4(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
//-------------------------------------------
//1 书写sql语句
String sql = "select * from cst_customer limit ?,? ";
//2 创建sql查询对象
SQLQuery query = session.createSQLQuery(sql);
query.setParameter(0, 0);
query.setParameter(1, 1);
//指定将结果集封装到哪个对象中
query.addEntity(Customer.class);
//3 调用方法查询结果
List list = query.list();
System.out.println(list);
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
多表查询
一对多|多对一
关系表达
表中的表达
表中的表达
实体中的表达
orm元数据中表达
一对多
Customer.hbm.xml
多对一
LinkMan.hbm.xml
操作
操作关联属性
使用级联操作
//一对多|多对一关系操作
public class Demo {
@Test
//保存客户 以及客户 下的联系人
public void fun1(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 开启事务
Transaction tx = session.beginTransaction();
//-------------------------------------------------
//3操作
Customer c = new Customer();
c.setCust_name("百度公司");
LinkMan lm1 = new LinkMan();
lm1.setLkm_name("李彦宏");
LinkMan lm2 = new LinkMan();
lm2.setLkm_name("小度");
//表达一对多,客户下有多个联系人
c.getLinkMens().add(lm1);
c.getLinkMens().add(lm2);
//表达对对对,联系人属于哪个客户
lm1.setCustomer(c);
lm2.setCustomer(c);
session.save(c);
// 使用级联操作，不用互相保存
// session.save(lm1);
// session.save(lm2);
//-------------------------------------------------
//4提交事务
tx.commit();
//5关闭资源
session.close();
}
@Test
//为客户增加联系人
public void fun2(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 开启事务
Transaction tx = session.beginTransaction();
//-------------------------------------------------
//3操作
//1> 获得要操作的客户对象
Customer c = session.get(Customer.class,1l);
//2> 创建联系人
LinkMan lm1 = new LinkMan();
lm1.setLkm_name("郝强勇");
//3> 将联系人添加到客户,将客户设置到联系人中
c.getLinkMens().add(lm1);
lm1.setCustomer(c);
//4> 执行保存
session.save(lm1);
//-------------------------------------------------
//4提交事务
tx.commit();
//5关闭资源
session.close();
}
@Test
//为客户删除联系人
public void fun3(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 开启事务
Transaction tx = session.beginTransaction();
//-------------------------------------------------
//3操作
//1> 获得要操作的客户对象
Customer c = session.get(Customer.class,1l);
//2> 获得要移除的联系人
LinkMan lm = session.get(LinkMan.class, 3l);
//3> 将联系人从客户集合中移除
c.getLinkMens().remove(lm);
lm.setCustomer(null);
//-------------------------------------------------
//4提交事务
tx.commit();
//5关闭资源
session.close();
}
}
//测试级联操作
public class Demo2 {
@Test
//保存客户 以及客户 下的联系人
//cascade:save-update
public void fun1(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 开启事务
Transaction tx = session.beginTransaction();
//-------------------------------------------------
//3操作
Customer c = new Customer();
c.setCust_name("百度公司");
LinkMan lm1 = new LinkMan();
lm1.setLkm_name("李彦宏");
LinkMan lm2 = new LinkMan();
lm2.setLkm_name("小度");
//表达一对多,客户下有多个联系人
c.getLinkMens().add(lm1);
c.getLinkMens().add(lm2);
//表达对对对,联系人属于哪个客户
lm1.setCustomer(c);
lm2.setCustomer(c);
session.save(c);
// session.save(lm1);
// session.save(lm2);
//-------------------------------------------------
//4提交事务
tx.commit();
//5关闭资源
session.close();
}
@Test
//测试删除客户时,级联删除客户下的联系人
//cascade:delete
public void fun2(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 开启事务
Transaction tx = session.beginTransaction();
//-------------------------------------------------
//3操作
//1> 获得要操作的客户对象
Customer c = session.get(Customer.class,1l);
//2>调用delete删除客户
session.delete(c);
//-------------------------------------------------
//4提交事务
tx.commit();
//5关闭资源
session.close();
}
@Test
//保存联系人以及联系人对应的客户
//cascade:save-update
public void fun3(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 开启事务
Transaction tx = session.beginTransaction();
//-------------------------------------------------
//3操作
Customer c = new Customer();
c.setCust_name("北大青鸟");
LinkMan lm1 = new LinkMan();
lm1.setLkm_name("刘总");
//表达一对多,客户下有多个联系人
c.getLinkMens().add(lm1);
//表达多对一,联系人属于哪个客户
lm1.setCustomer(c);
session.save(lm1);
//-------------------------------------------------
//4提交事务
tx.commit();
//5关闭资源
session.close();
}
}
进阶操作
结论:
简化操作.一定要用：save-update,不建议使用delete，delete 会把外键关联的记录也删除，太危险了.
关系维护
inverse属性: 性能优化，提高关系维护的性能。
原则: 无论怎么放弃，总有一方必须要维护主键关系。
inverse="true"放弃维护。
一对多关系中: 一的一方放弃，也只能一的一方放弃。
多的一方不能放弃，外键在多方的表中。
//操作进阶--关系维护属性
public class Demo3 {
@Test
//保存客户 以及客户 下的联系人
public void fun1(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 开启事务
Transaction tx = session.beginTransaction();
//-------------------------------------------------
//3操作
Customer c = new Customer();
c.setCust_name("百度");
LinkMan lm1 = new LinkMan();
lm1.setLkm_name("李彦宏");
LinkMan lm2 = new LinkMan();
lm2.setLkm_name("小度");
//表达一对多,客户下有多个联系人.
// 如果客户放弃维护与联系人的关系. 维护关系的代码可以省略
//c.getLinkMens().add(lm1);
//c.getLinkMens().add(lm2);
//表达多对一,联系人属于哪个客户
lm1.setCustomer(c);
lm2.setCustomer(c);
session.save(c);
session.save(lm1);
session.save(lm2);
//-------------------------------------------------
//4提交事务
tx.commit();
//5关闭资源
session.close();
}
}
删除客户
因为联系人表外键了客户表，所以不能直接删除客户。
- 方式一：级联：cascade="delete" ，删除客户表同时也会删除联系人表。
- 方式二：外键关系：inverse="false" ，删除客户表，同时联系人表外键变为 null。
@Test
//删除客户
public void fun2(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 开启事务
Transaction tx = session.beginTransaction();
//-------------------------------------------------
//3操作
Customer customer = session.get(Customer.class, 1l);
session.delete(customer);
//-------------------------------------------------
//4提交事务
tx.commit();
//5关闭资源
session.close();
}
多对多
关系表达
表中
对象中
orm元数据
Role.hbm.xml
User.hbm.xml
注意：
中间表报错，必须只能一方维护外键关系，如果双方都维护外键关系，那么中间表会插入练体能一样的记录，造成中间表的主键重复。
结论:
将来在开发中,如果遇到多对多关系.一定要选择一方放弃维护关系.
一般谁来放弃要看业务方向. 例如录入员工时,需要为员工指定所属角色.
那么业务方向就是由员工维护角色. 角色不需要维护与员工关系.角色放弃维护.
操作
操作关联属性
//多对多关系操作
public class Demo {
//为郝强勇解除一个角色
@Test
public void fun4(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 开启事务
Transaction tx = session.beginTransaction();
//-------------------------------------------------
//3操作
//1> 获得郝强勇用户
User user = session.get(User.class, 1l);
//2> 获得要操作的角色对象(保洁,保安)
Role r1 = session.get(Role.class, 1l);
Role r2 = session.get(Role.class, 2l);
//3> 将角色从用户的角色集合中移除
user.getRoles().remove(r1);
user.getRoles().remove(r2);
//-------------------------------------------------
//4提交事务
tx.commit();
//5关闭资源
session.close();
}
}
操作进阶
inverse属性
- true: 放弃维护外键关系
- false(默认值):维护关系
//保存员工以及角色
@Test
public void fun1(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 开启事务
Transaction tx = session.beginTransaction();
//-------------------------------------------------
//3操作
//1> 创建两个 User
User u1 = new User();
u1.setUser_name("郝强勇");
User u2 = new User();
u2.setUser_name("金家德");
//2> 创建两个 Role
Role r1 = new Role();
r1.setRole_name("保洁");
Role r2 = new Role();
r2.setRole_name("保安");
//3> 用户表达关系
u1.getRoles().add(r1);
u1.getRoles().add(r2);
u2.getRoles().add(r1);
u2.getRoles().add(r2);
//4> 角色表达关系
r1.getUsers().add(u1);
r1.getUsers().add(u2);
r2.getUsers().add(u1);
r2.getUsers().add(u2);
//5> 调用Save方法一次保存
session.save(u1);
session.save(u2);
session.save(r1);
session.save(r2);
//-------------------------------------------------
//4提交事务
tx.commit();
//5关闭资源
session.close();
}
注意：
中间表报错，必须只能一方维护外键关系，如果双方都维护外键关系，那么中间表会插入练体能一样的记录，造成中间表的主键重复。
cascade属性
- cascade级联操作:
- save-update: 级联保存更新
- delete:级联删除
- all:级联保存更新+级联删除
//为郝强勇新增一个角色
@Test
public void fun3(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 开启事务
Transaction tx = session.beginTransaction();
//-------------------------------------------------
//3操作
//1> 获得郝强勇用户
User user = session.get(User.class, 1l);
//2> 创建公关角色
Role r = new Role();
r.setRole_name("男公关");
//3> 将角色添加到用户中
user.getRoles().add(r);
//4> 将角色转换为持久化
//session.save(r);//增加级联操作可以省略这一行
//-------------------------------------------------
//4提交事务
tx.commit();
//5关闭资源
session.close();
}
结论: cascade简化代码书写.该属性使不使用无所谓.
建议要用只用save-update.
如果使用delete操作太过危险.尤其在多对多中.不建议使用.
查询优化
类级别查询
get方法:没有任何策略.调用即立即查询数据库加载数据.
-
load方法: 应用类级别的加载策略
lazy="true"(默认值)， 查询类时,会返回代理对象。会在使用属性时,根据关联的session查询数据库.加载数据.
-
lazy="false"。load方法会与get方法没有任何区别.调用时即加载数据.
结论:为了提高效率.建议使用延迟加载(懒加载)- 注意：使用懒加载时要确保,调用属性加载数据时,session还是打开的.不然会抛出异常
Customer.hbm.xml 属性：lazy="false"
关联级别查询
集合策略
关联属性策略
结论:
为了提高效率.fetch的选择上应选择select. lazy的取值应选择 true. 全部使用默认值.
批量抓取
参考自某某培训机构。