首页 > 代码库 > hibernate04--三种状态之间的转换

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次!!  !
    }

hibernate04--三种状态之间的转换