hibernate04--三种状态之间的转换
public class StudentTest {
Session session=null;
Transaction transaction=null;
//在执行测试方法之前 先执行before
@Before
public void before(){
/**
* 01.读取核心的配置文件 在src的根目录下面！ 底层规定位置！
* 在实例化Configuration对象的时候通过configure()
* 去src根目录下面，寻找hibernate.cfg.xml文件
*/
Configuration configuration=new Configuration().configure();
//02.创建sessionFactory
SessionFactory sessionFactory = configuration.buildSessionFactory();
//03.打开session
session = sessionFactory.openSession();
//04.开启事务
transaction= session.beginTransaction();
}
//在执行测试方法之后
@After
public void after(){
//07.提交事务 sql语句 整体的执行！
transaction.commit();
//08.关闭session
session.close();
//sessionFactory.close(); 验证hbm2ddl中的create-drop
}
/**
* hibernate对象的三种状态！
* 01.瞬时状态（临时状态/自由状态）
* 我们通过new关键字 创建出的一个实体对象！和hibernate没有半毛钱关系！
*
* 02.持久状态
* 对象正在被session管理，数据库中有对象 对应的数据！
* 如果对象是持久状态！ 那么对它的修改操作 不需要再使用其他的方法（update）
* 在commit的时候，会执行flush()，
* flush()的时候会进行缓存清理！
* 缓存清理的时候会进行脏检查！
* 如果对象的属性和之前的对象属性不一致！
* 那么当前的对象就是脏对象！
* 就会把脏对象同步到数据库！
*
* 03.游离状态（脱管状态）
* 曾经被session管理过！和瞬时状态的区别就是 是否存在OID（主键标识符）！
*
*/
@Test
public void testSave1(){
//创建一个对象
Student stu=new Student(100, 50, "老白"); //瞬时状态
session.save(stu); //持久化状态
stu.setName("老白干");
/**
改变了对象的属性 这时候的stu就是脏对象 不需要执行update（）
commit的时候会产生两条sql语句！
01.insert
02.update
*/
}
@Test
public void testSave02(){
//创建一个对象
Student stu=new Student(666, 50, "老白"); //瞬时状态
stu.setName("老白干"); //瞬时状态
session.save(stu); //持久化状态 从这里开始 才被 session管理！
}
@Test
public void testSave03(){
//创建一个对象
Student stu=new Student(555, 50, "老白"); //瞬时状态
stu.setName("老白干"); //瞬时状态
session.save(stu); //持久化状态 从这里开始 才被 session管理！
stu.setName("老白干1");
stu.setName("老白干2");
stu.setName("老白干3");
/**
* 还是两条sql语句
*commit的时候会产生两条sql语句！
01.insert
02.update
*/
}
/**
* 测试方法的前提环境三种情况
* 01.stu对象在数据库中没有对应的数据
* 02.stu对象在数据库中有对应的数据,但是我们没有修改属性
* 03.stu对象在数据库中有对应的数据,我们修改了属性
* 产生的结果都是一致的！
* 根据id 产生update语句
*/
@Test
public void testUpdate(){
//创建一个对象
Student stu=new Student(1, 50, "老白"); //瞬时状态
session.update(stu);
}
/**
* 测试方法的前提环境
* stu对象在数据库中没有对应的数据
* 产生的结果：
* 01.根据id 产生 select
* 02.发现数据库中没有对应的数据 产生 insert
*/
@Test
public void testSaveOrUpdate(){
//创建一个对象
Student stu=new Student(1, 50, "老白"); //瞬时状态
session.saveOrUpdate(stu);
}
/**
* 测试方法的前提环境
* 01.stu对象在数据库有对应的数据
* 02.没有改变stu对象的属性值
* 产生的结果：
* 根据id 产生 select语句
*/
@Test
public void testSaveOrUpdate2(){
//创建一个对象
Student stu=new Student(1, 50, "老白"); //瞬时状态
session.saveOrUpdate(stu);
}
/**
* 测试方法的前提环境
* 01.stu对象在数据库有对应的数据
* 02.改变了stu对象的属性值
* 产生的结果：
* 01.根据id 产生 select
* 02.因为修改了对象的属性 所以 执行update
*/
@Test
public void testSaveOrUpdate3(){
//创建一个对象
Student stu=new Student(1, 50, "老白"); //瞬时状态
stu.setName("老白干");
session.saveOrUpdate(stu);
}
}
package cn.bdqn.test;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import cn.bdqn.bean.Student;
public class StudentTest {
Session session=null;
Transaction transaction=null;
//在执行测试方法之前 先执行before
@Before
public void before(){
/**
* 01.读取核心的配置文件 在src的根目录下面！ 底层规定位置！
* 在实例化Configuration对象的时候通过configure()
* 去src根目录下面，寻找hibernate.cfg.xml文件
*/
Configuration configuration=new Configuration().configure();
//02.创建sessionFactory
SessionFactory sessionFactory = configuration.buildSessionFactory();
//03.打开session
session = sessionFactory.openSession();
//04.开启事务
transaction= session.beginTransaction();
}
//在执行测试方法之后
@After
public void after(){
//07.提交事务 sql语句 整体的执行！
transaction.commit();
//08.关闭session
session.close();
//sessionFactory.close(); 验证hbm2ddl中的create-drop
}
/**
* hibernate对象的三种状态！
* 01.瞬时状态（临时状态/自由状态）
* 我们通过new关键字 创建出的一个实体对象！和hibernate没有半毛钱关系！
*
* 02.持久状态
* 对象正在被session管理，数据库中有对象 对应的数据！
* 如果对象是持久状态！ 那么对它的修改操作 不需要再使用其他的方法（update）
* 在commit的时候，会执行flush()，
* flush()的时候会进行缓存清理！
* 缓存清理的时候会进行脏检查！
* 如果对象的属性和之前的对象属性不一致！
* 那么当前的对象就是脏对象！
* 就会把脏对象同步到数据库！
*
* 03.游离状态（脱管状态）
* 曾经被session管理过！和瞬时状态的区别就是 是否存在OID（主键标识符）！
*
*/
@Test
public void testSave1(){
//创建一个对象
Student stu=new Student(100, 50, "老白"); //瞬时状态
session.save(stu); //持久化状态
stu.setName("老白干");
/**
改变了对象的属性 这时候的stu就是脏对象 不需要执行update（）
commit的时候会产生两条sql语句！
01.insert
02.update
*/
}
@Test
public void testSave02(){
//创建一个对象
Student stu=new Student(666, 50, "老白"); //瞬时状态
stu.setName("老白干"); //瞬时状态
session.save(stu); //持久化状态 从这里开始 才被 session管理！
}
@Test
public void testSave03(){
//创建一个对象
Student stu=new Student(555, 50, "老白"); //瞬时状态
stu.setName("老白干"); //瞬时状态
session.save(stu); //持久化状态 从这里开始 才被 session管理！
stu.setName("老白干1");
stu.setName("老白干2");
stu.setName("老白干3");
/**
* 还是两条sql语句
*commit的时候会产生两条sql语句！
01.insert
02.update
*/
}
/**
* 测试方法的前提环境三种情况
* 01.stu对象在数据库中没有对应的数据
* 02.stu对象在数据库中有对应的数据,但是我们没有修改属性
* 03.stu对象在数据库中有对应的数据,我们修改了属性
* 产生的结果都是一致的！
* 根据id 产生update语句 ！ 只能是从游离变持久！
*/
@Test
public void testUpdate(){
//创建一个对象
Student stu=new Student(1, 50, "老白"); //瞬时状态
session.update(stu);
}
/**
* 测试方法的前提环境
* stu对象在数据库中没有对应的数据
* 产生的结果：
* 01.根据id 产生 select
* 02.发现数据库中没有对应的数据 产生 insert
*/
@Test
public void testSaveOrUpdate(){
//创建一个对象
Student stu=new Student(1, 50, "老白"); //瞬时状态
session.saveOrUpdate(stu);
}
/**
* 测试方法的前提环境
* 01.stu对象在数据库有对应的数据
* 02.没有改变stu对象的属性值
* 产生的结果：
* 根据id 产生 select语句
*/
@Test
public void testSaveOrUpdate2(){
//创建一个对象
Student stu=new Student(1, 50, "老白"); //瞬时状态
session.saveOrUpdate(stu);
}
/**
* 测试方法的前提环境
* 01.stu对象在数据库有对应的数据
* 02.改变了stu对象的属性值
* 产生的结果：
* 01.根据id 产生 select
* 02.因为修改了对象的属性 所以 执行update
*/
@Test
public void testSaveOrUpdate3(){
//创建一个对象
Student stu=new Student(1, 50, "老白"); //瞬时状态
stu.setName("老白干");
session.saveOrUpdate(stu);
}
/**
* 测试方法的前提环境
* stu对象在数据库没有对应的数据
* 产生的结果：
* 两条sql
* 01.select 先去数据库中查询有没有id对应的数据
* 02.执行 insert
*/
@Test
public void testMerge01(){
Student stu=new Student(1, 50, "老白"); //瞬时状态
session.merge(stu);
}
/**
* 测试方法的前提环境
* stu对象在数据库有对应的数据 ，我们没有修改对象的属性
* 产生的结果：
* 只有select语句
*/
@Test
public void testMerge02(){
Student stu=new Student(1, 50, "老白"); //瞬时状态
session.merge(stu);
}
/**
* 测试方法的前提环境
* stu对象在数据库有对应的数据 ，我们修改了对象的属性
* 产生的结果：
* 01.select
* 02.update
*/
@Test
public void testMerge03(){
Student stu=new Student(1, 50, "老白"); //瞬时状态
stu.setName("老白干");
session.merge(stu);
}
/**
* 测试方法的前提环境
* stu对象在数据库有对应的数据 ，我们修改了对象的属性
* 产生的结果：
* 报错
*/
@Test
public void testMerge04(){
Student stu=new Student(1, 50, "老白干"); //瞬时状态
session.merge(stu); //不会改变对象的状态
stu.setName("老白11111"); //瞬时状态
session.update(stu); //报错
}
/**
* save(): 把瞬时状态转换成 持久状态
* update():把游离状态转换成 持久状态
* saveOrUpdate():
* 会根据持久化对象的主键标识符来判断是执行save()还是update()
* 如果没有oid，证明是瞬时状态，就执行save();
* 如果有oid，证明是游离状态，就执行update();
* merge: 虽然和saveOrUpdate（）产生的sql结果一致！
* 但是：
* 01.merge不会改变对象的状态！
* 02.当对象处于瞬时状态的时候，会将对象赋值一份到session的缓存中，执行save() ,产生insert语句！
* 我们认为 产生了 insert语句，stu就变成了持久化对象！其实不是！
* 只不过是session缓存中的对象发生了变化！
*/
}
/**
* 第一步：
*01.读取配置文件 hibernate.cfg.xml
*02.创建会话工厂---》确保工厂是单例模式
*03.提供对外访问的接口
*第二步：
* 在核心配置文件中 管理我们的currentSession
*/
public class HibernateSessionUtil {
private static Configuration configuration;
private static SessionFactory sessionFactory;
private HibernateSessionUtil(){}//私有化构造
//在类被加载的时候 执行静态代码块
static{
configuration=new Configuration().configure();
sessionFactory=configuration.buildSessionFactory();//获取会话工厂
}
//获取session的方法
public static Session getCurrentSession(){
return sessionFactory.getCurrentSession();
}
}
hibernate.cfg.xml文件中新增
<!-- 配置我们的currentSession -->
<property name="current_session_context_class">thread</property>
测试代码
public class SessionTest {
public static void main(String[] args) {
/**Configuration configuration=new Configuration().configure();
SessionFactory sessionFactory = configuration.buildSessionFactory();
Session session = sessionFactory.openSession(); //第一次
System.out.println(session.hashCode());
session = sessionFactory.openSession(); //第二次
System.out.println(session.hashCode()); hashCode不一致
*/
//通过我们自己创建的回话工厂来创建currentSession
Session session = HibernateSessionUtil.getCurrentSession(); //第一次
System.out.println(session.hashCode());
session = HibernateSessionUtil.getCurrentSession(); //第二次
System.out.println(session.hashCode()); //hashCode一致
}
}
/**
* flush和commit的区别！
*
* 相同点：
* 两者都会同步到数据库！
*
* 不同点：
* commit：永久保存！ commit--->flush()-->缓存清理--->脏检查
*
* flush： 不会永久保存！
* 01.是执行缓存清理工作！
* 02.会把缓存中的对象同步到数据库中！但是不会保存！
* 03.确保缓存中的数据 和数据库中的数据一致！
*
* 缓存清理机制：
* 在我们执行flush()的时候，会清理session中的数据！
* 在清理缓存的的时候，会执行脏检查！
* 脏检查：
* 在对象被session管理的时候!
* 01.session会在缓存中创建出 对象的快照保存现在对象的一个状态以及属性！ （a对象）
* 02.在清理缓存的时候会把现在对象的属性和（a对象）进行比对！
* 03.发现现在的对象和（a对象不一致！那么现在的对象就称之为 脏对象！
* 04.flush()会把这个脏对象 同步到 数据库！ 但是不会保存！只是暂时的！
* 05.之后commit的时候 才能永久保存数据！
*
*/
@Test
public void test01(){
//通过工具类获取session
Session session = HibernateSessionUtil.getCurrentSession();
//获取事务
Transaction transaction = session.beginTransaction();
Student stu=(Student) session.get(Student.class, 1);//持久化对象
stu.setName("能改变吗？");
/**
* 清理缓存
* 按照我们的理解，没有commit是不可能提交事务的！言外之意！数据库中的数据不会改变！
*/
System.out.println("*****************");
session.flush();
stu.setName("能改变吗2？");
System.out.println("*****************");
Student stu2=(Student) session.get(Student.class, 1);
System.out.println(stu2.getName()); //已经改变了！
}
@Test
public void test02(){
//通过工具类获取session
Session session = HibernateSessionUtil.getCurrentSession();
//获取事务
Transaction transaction = session.beginTransaction();
Student stu=(Student) session.get(Student.class, 1);//持久化对象
stu.setName("能改变吗？");
System.out.println("*****************");
session.flush(); //执行 sql
stu.setName("能改变吗2？"); //之后又改变了 值
System.out.println("*****************");
/**
* 缓存中的OID是一致的！
* get（）
* 01.查询session缓存
* 02.发现缓存中有数据 直接使用
* 03.所以说 stu2的name必须是 “ 能改变吗2？”
*/
Student stu2=(Student) session.get(Student.class, 1);
System.out.println(stu2.getName()); //改变了第2次！！ ！
}
