Hibernate学习笔记二
一、持久化类的编写规则
1、持久化类的概述
持久化:将内存中的一个对象持久化到数据库中的过程.Hibernate 框架就是用来持久化的框架
持久化类:一个 Java 类与数据库中的表建立映射关系.那么这个类在 Hibernate 中称为持久化类
持久化类 = Java 类 + 映射文件
2、持久化类的编写规则
- 对持久化类提供一个无参构造方法 :Hibernate 底层需要使用反射生成实例
- 属性需要私有,私有的属性提供 get 和 set 方法 :Hibernate 中获取、设置对象的值
- 对持久化类提供一个唯一标识 OID 与数据库主键对应 :Java 中通过内存地址区分是否是同一个
- 对象,数据库中通过主键区分是否为同一条记录,Hibernate 中通过 OID 区分是否为同一个对象
- 持久化类中属性尽量使用包装类 :因为基本数据类型默认值是:0,0有很多歧义.包装类默认值为 null
- 持久化类不要使用 final 修饰 :延迟加载本身是 Hibernate 的一个优化手段,返回一个代理对象(javassist可以对没有实现接口的类产生代理--使用类非常底层的字节码增强技术,继承这个类进行代理)。如果不能被继承，就不能产生代理对象，延迟加载也就失效了。load和 get 方法一致。
二、主键生成策略
1、主键的分类
-
自然主键
自然主键:主键本身就是表中的一个字段(实体类中的一个属性)。创建一个人员表,使用身份证(唯一不可重复)作为主键,这种主键称为自然主键 -
代理主键
代理主键:主键本身不是表中必须的一个字段(不是实体中的具体的属性)。创建一个人员表,不使用身份证作为主键,使用不相关的ID作为主键,这种主键称为代理主键。实际开发中,尽量使用代理主键
2、主键的生成策略
Hibernate 的主键生成策略，在实际开发中一般不允许用户手动设置主键，一般将主键交给数据库，或者手动编写程序进行设
置。在 Hibernate 中为了减少代码编写，提供了很多种主键生成的策略。
-
increment
Hibernate 中提供的自动增长机制,适用 short int lang 类型的主键,在单线程程序中使用首先发送一条SQL语句:select max(id) from 表; 然后让 id+1,作为下一条记录的主键 -
identity
适用 short int lang 类型的主键,使用的是数据库底层的自动增长机制.适用于有自动增长机制的数据库(MySQL), Oracle 没有自动增长机制. -
sequence
适用于 short int lang 类型的主键,采用序列的方式.(Oracle支持序列),MySQL 不支持序列. -
uuid
适用于字符串类型的主键,使用 Hibernate 中随机的方式生成字符串主键 -
native
本地策略,可以在 identity 和 sequence 之间切换. -
assigned
Hibernate 放弃外键的管理,需要通过手动编写程序和用户自己设置. -
foreign
外部的,在一对一的关联映射情况下使用.
三、持久化类的三种状态
Hibernate 是持久层的 ORM 框架，专注于数据的持久化工作。在进行数据持久化操作时，持久化对象可能处于不同的状态当中。这些状态可分为三种，分别为瞬时态、持久态和脱管态。下面分别针对这三种状态进行简单介绍。
1、三种状态的介绍
-
瞬时态（transient）
瞬时态也称为临时态或者自由态，瞬时态的对象是由 new 关键字开辟内存空间的对象，不存在持久化标识 OID（相当于主键值），且未与任何的 Session 实例相关联，在数据库中也没有记录，失去引用后将被 JVM 回收。瞬时对象在内存孤立存在，它是携带信息的载体，不和数据库的数据有任何关联关系。 -
持久态（persistent）
持久态的对象存在一个持久化标识 OID，当对象加入到 Session 缓存中时，就与 Session 实例相关联。它在数据库中存在与之对应的记录，每条记录只对应唯一的持久化对象。需要注意的是，持久态对象是在事务还未提交前变成持久态的。 -
脱管态（detached）
脱管态也称离线态或者游离态，当持久化对象与 Session 断开时就变成了脱管态，但是脱管态依然存在持久化标识 OID，只是失去了与当前 Session 的关联。需要注意的是，脱管态对象发生改变时Hibernate 是不能检测到的。
2、三种状态的区分
package com.qidishixun.Hibernate;
import com.qidishixun.Hibernate.domain.Customer;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;
import java.io.Serializable;
public class HibernateDemo2 {
@Test
public void test1(){
Session session = HibernateUtils.openSession();
Transaction transaction = session.beginTransaction();
Customer customer = new Customer();
//瞬时态对象：没有唯一标识OID，被session 管理
customer.setCust_name("张三丰");
Serializable id = session.save(customer);
//持久态对象：有唯一表示OID，被session 管理
Customer customer2 = session.get(Customer.class,id);
transaction.commit();
session.close();
//托管态对象：有唯一表示OID， 没有被session管理，session已经close了
System.out.println("客户名称：" + customer.getCust_name());
}
}
3、三种状态转换
- 三种状态转换图
- 瞬时态对象
获得
Customer customer = new Customer();
状态转换
瞬时 --> 持久
save(Object obj)、saveOrUpdate(Object obj)
瞬时 --> 托管
customer.setCust_id(1L);
- 持久态对象
获得
get()、load()
状态转换
持久 --> 瞬时
delete();
持久 --> 托管
close()、clear()、evict()
- 托管态对象
获得
Customer customer = new Customer();
customer.setCust_id(1L);
状态转换
托管 --> 持久
update()、saveOrUpdate();
托管 --> 瞬时
customer.setCust_id(null);
4、持久态对象的特性
- 持久态对象可以自动更新数据库
@Test
public void test2(){
Session session = HibernateUtils.openSession();
Transaction transaction = session.beginTransaction();
//获得持久态对象 get load
Customer customer = session.get(Customer.class, 1L);
customer.setCust_name("王娜");
// session.update(customer);
transaction.commit();
session.close();
}
四、Hibernate 的一级缓存
1、Hibernate 的一级缓存
Hibernate 的一级缓存就是指 Session 缓存，Session 缓存是一块内存空间，用来存放相互管理的Java 对象，在使用 Hibernate 查询对象的时候，首先会使用对象属性的 OID 值在 Hibernate 的一级缓存中进行查找，如果找到匹配的 OID 值的对象，就直接将该对象从一级缓存中取出使用，不会再查询数据库，如果没有找到相同 OID 值的对象，则会去数据库中查找响应数据。当从数据库中查询到所需数据时，该数据信息也会放置到一级缓存中。Hibernate 的一级缓存的作用就是减少对数据库访问的次数。
在 Session 接口的实现中包含一系列的 Java 集合，这些 Java 集合构成了 Session 缓存。只要Session 实例没有结束生命周期，存放在它缓存中的对象也不会结束生命周期。固一级缓存也被称为Session 级别的缓存。
Hibernate 的一级缓存有如下特点：当应用程序调用 Session 接口的 sava()、update、saveOrUpdate
2、证明 Hibernate 的一级缓存存在
package com.qidishixun.Hibernate;
import com.qidishixun.Hibernate.domain.Customer;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;
/**
* Hibernate 的一级缓存
* @ClassName: HibernateDemo3
* @Author Gui
* @Date 2021/6/28
* @Version 1.0
*/
public class HibernateDemo3 {
@Test
public void test1(){
Session session = HibernateUtils.openSession();
Transaction transaction = session.beginTransaction();
Customer customer1 = session.get(Customer.class, 1L);
System.out.println(customer1);
Customer customer2 = session.get(Customer.class, 1L);
System.out.println(customer2);
System.out.println(customer1 == customer2);
transaction.commit();
session.close();
}
}
五、Hibernate 事务管理
1、绑定线程的 Session
Hibernate5 中自身提供了三种管理 Session 对象的方法
- Session 对象的生命周期与本地线程绑定
- Session 对象的生命周期与 JTA 事务绑定
- Hibernate 委托程序管理 Session 对象的声明周期
在 Hibernate 配置文件中,hibernate.current_session_context_class 属性用于指定 Session 管理方式,可选值包括
- thread: Session 对象的生命周期与本地线程绑定
- jta: Session 对象的生命周期与 JTA 事务绑定
- managed: Hibernate 委托程序管理 Session 对象的声明周期
在 hibernate.cfg.xml 配置文件中进行如下配置:
<!-- 配置 Session 绑定本地线程 -->
<property name="hibernate.current_session_context_class">thread</property>
2、修改 HibernateUtils 工具类
/**
* 提供获得 Session方法
* @return
*/
public static Session getCurrentSession(){
return sessionFaction.getCurrentSession();
}
测试
@Test
public void test3(){
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
Customer customer = new Customer();
customer.setCust_name("大哥哥");
session.save(customer);
transaction.commit();
//这里不需要关闭session，因为线程结束Session自动销毁
}
六、Hibernate 的其他 API
1、Query
Query 代表面向对象的一个 Hibernate 操作. 在 Hibernate 中通常使用 session.createQuery() 方法接收一个 HQL 语句,然后使用 query 的 list() 或 uniqueResult() 方法执行查询. 所谓的 HQL 是Hibernate Query Language 的缩写,其语法很像 SQL 但是它是完全面向对象的.在 Hibernate 中使用 Query 的步骤：
1. 获得 Hibernate 的 Session 对象
2. 编写 HQL 语句
3. 调用 session.createQuery() 创建查询对象
4. 如果 HQL 语句包含参数,则调用 Query 的 setXXX 方法设置参数
5. 调用 Query 的 list() 或 uniqueResult() 方法执行查询
- 查询所有
package com.qidishixun.Hibernate;
import com.qidishixun.Hibernate.domain.Customer;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;
import java.util.List;
/**
* 利用Hibernate API 查询数据库表
* @ClassName: HibernateDemo4
* @Author Gui
* @Date 2021/6/28
* @Version 1.0
*/
public class HibernateDemo4 {
@Test
public void test1(){
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
String hql = "from Customer";
Query query = session.createQuery(hql);
List<com.qidishixun.Hibernate.domain.Customer> customers = query.list();
for (com.qidishixun.Hibernate.domain.Customer customer :customers){
System.out.println(customer);
}
transaction.commit();
}
}
- 条件查询
/**
* 模糊查询
*/
@Test
public void test2(){
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
String hql = "from Customer where cust_name like ?";
Query query = session.createQuery(hql);
query.setParameter(0, "大%");
List<com.qidishixun.Hibernate.domain.Customer> customers = query.list();
for (com.qidishixun.Hibernate.domain.Customer customer : customers){
System.out.println(customer);
}
transaction.commit();
}
- 分页查询
/**
* 分页查询
*/
@Test
public void test3(){
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
String hql = "from Customer";
Query query = session.createQuery(hql);
//设置分页查询的条件
query.setFirstResult(3); //从几开始
query.setMaxResults(3); //每页显示几条
List<com.qidishixun.Hibernate.domain.Customer> customers = query.list();
for (Customer customer : customers){
System.out.println(customer);
}
transaction.commit();
}
2、Criteria
Criteria:QBC查询(Query By Criteria) ，更加面向对象的一种查询方式
- 查询所有
package com.qidishixun.Hibernate;
import com.qidishixun.Hibernate.domain.Customer;
import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.Restrictions;
import org.junit.Test;
import java.util.List;
/**
* 更加面向对象的一种查询
* @ClassName: HibernateDemo5
* @Author Gui
* @Date 2021/6/28
* @Version 1.0
*/
public class HibernateDemo5 {
@Test
public void test1(){
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
//通过 Session 获取 criteria
Criteria criteria = session.createCriteria(com.qidishixun.Hibernate.domain.Customer.class);
List<com.qidishixun.Hibernate.domain.Customer> customers = criteria.list();
for (com.qidishixun.Hibernate.domain.Customer customer : customers){
System.out.println(customer);
}
transaction.commit();
}
}
- 条件查询
@Test
public void test2(){
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
//通过Session 获取 criteria
Criteria criteria = session.createCriteria(com.qidishixun.Hibernate.domain.Customer.class);
//设置条件
criteria.add(Restrictions.ilike("cust_name","小%"));
List<com.qidishixun.Hibernate.domain.Customer> list = criteria.list();
for (com.qidishixun.Hibernate.domain.Customer customer : list){
System.out.println(customer);
}
transaction.commit();
}
- 分页查询
/**
* 分页查询
*/
@Test
public void test3(){
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
//通过 Session 获取 criteria
Criteria criteria = session.createCriteria(com.qidishixun.Hibernate.domain.Customer.class);
//设置分页
criteria.setFirstResult(1); //跳过几个开始查询
criteria.setMaxResults(3);
List<com.qidishixun.Hibernate.domain.Customer> list = criteria.list();
for (Customer customer : list){
System.out.println(customer);
}
transaction.commit();
}
3、SQLQuery
/**
* HQL 和 SQL 的写法
*/
@Test
public void test4(){
Session session = HibernateUtils.openSession();
Transaction transaction = session.beginTransaction();
SQLQuery sqlQuery = session.createSQLQuery("select * from cst_customer");
List<Object[]> list1 = sqlQuery.list();
for (Object[] object : list1){
System.out.println(object.toString());
}
transaction.commit();
session.close();
}
