hibernate中对象状态

对象的状态

临时状态

new出的对象

持久化状态

get,save,update

脱管状态

clear  close  evict

session.get方法取出一个持久化对象，同时产生这个对象的快照，如何判断何时对该对象进行update操作？将快照和该对象进行对比，当快照值和对象值不一致的时候，发出update语句，否则不发。

主键生成器改为identity

session.save(person);

session.evict(person);

transaction.commit();

session执行save操作时候，就发出了insert语句。执行evict操作时候，person对象转为为托管状态。事务提交，因为已经发出过了insert语句了，person虽然为托管状态，但是不影响事务的提交，所有和数据库发生了交互。

import org.hibernate.Session;    
    import org.hibernate.Transaction;
    import org.junit.Test;
     
    import cn.itcat.domain.ConfigUtil;
    import cn.itcat.domain.Person;
     
    public class StateTest extends ConfigUtil{
    /**
     * session.save方法把一个临时状态的对象转化成持久化状态的对象
     */
    @Test
    public void testSavePerson(){
    Session session = sessionFactory.openSession();
    Transaction transaction = session.beginTransaction();
    Person person = new Person();
    person.setPname("afds");
    person.setPsex("af");
    session.save(person);
    transaction.commit();
    session.close();
    }
    /**
     * session.update方法可以把一个对象的状态变成持久化状态
     */
    @Test
    public void testUpdate(){
    Session session = sessionFactory.openSession();
    Transaction transaction = session.beginTransaction();
    Person person2 = new Person();//临时状态
    person2.setPid(1L);//临时状态
    session.update(person2);//updat方法是将一个临时状态的对象转化为持久化状态对象
    transaction.commit();//发出sql语句
    session.close();
    }
    /**
     * 当session.get方法得到一个对象的时候，是不需要再执行 update语句，因为已经是持久化状态
     * 当一个对象是一个持久化对象的时候,当进行提交的时候,hibernate内部会让该对象和快照进行对比,如果一样,则不发出update语句
     * 如果不一样，则发出update语句
     */
    @Test
    public void testGet(){
    Session session = sessionFactory.openSession();
    //Transaction transaction = session.beginTransaction();
    Person person = (Person)session.get(Person.class, 1L);//get取出的对象就是一个持久化对象
    person.setPname("tt");
    //session.update(person); 
    //transaction.commit();
    session.close();
    }
    /**
     * session.clear方法把所有的对象从session中清空
     */
    @Test
    public void testClear(){
    Session session = sessionFactory.openSession();
    Transaction transaction = session.beginTransaction();
    Person person = (Person)session.get(Person.class, 1L);
    person.setPname("asd");
    session.clear();//把session中所有的对象清空
    session.update(person);//把对象从脱管状态转化成持久化状态
    transaction.commit();
    session.close();
    }
    /**
     * session.evict把一个对象从session中清空
     */
    @Test
    public void testEvict(){
    Session session = sessionFactory.openSession();
    Transaction transaction = session.beginTransaction();
    Person person = (Person)session.get(Person.class, 1L);
    person.setPname("asdsss");
    session.evict(person);//脱管状态
    session.update(person);//把对象的状态转化成持久化状态
    transaction.commit();
    session.close();
    }
    /**
     * 一个对象是否是持久化对象是针对某一个session而言的
     */
    @Test
    public void testSession(){
    Session session = sessionFactory.openSession();
    Transaction transaction = session.beginTransaction();
    Person person = (Person)session.get(Person.class, 1L);
    person.setPname("asfd");
    transaction.commit();
    session.close();
    session =  sessionFactory.openSession();
    transaction =  session.beginTransaction();
    person.setPname("aaaaaaa");//person对象对于94的session来说是一个临时状态的对象
    //session.update(person);
    transaction.commit();
    session.close();
    }
    /**
     * 当执行transaction.commit的时候，hibernate内部会检查session
     *    1、如果一个对象为临时状态的对象，则session不会管
     *    2、如果一个对象是持久化状态的对象，如果有ID值，并且和数据库对应，那么先把该对象与快照进行对比，如果一致，则什么都不做，如果不一致，则发出update语句
     *    3、如果一个对象是持久化状态的对象，如果没有ID值，则会发出save语句
     */
    @Test
    public void testMuplyOption(){
    Session session = sessionFactory.openSession();
    Transaction transaction = session.beginTransaction();
    Person person = new Person();
    person.setPname("rrr");
    person.setPsex("asdfasdf");
    Person person3 = new Person();
    person3.setPname("rrr");
    person3.setPsex("asdfasdf");
    session.save(person);
    Person person2 = (Person)session.get(Person.class, 1L);
    person2.setPname("afds45");
    transaction.commit();
    session.close();
    }
    @Test
    public void testMutiplyOption2(){
    Session session = sessionFactory.openSession();
    Transaction transaction = session.beginTransaction();
    Person person = new Person();
    person.setPname("asdfads");
    person.setPsex("er");
    session.save(person);
    transaction.commit();
    session.evict(person);
    session.close();
    session = sessionFactory.openSession();
    transaction = session.beginTransaction();
    session.update(person);
    session.clear();
    transaction.commit();
    session.close();
    }
    @Test
    public void testTransaction(){
    Session session = sessionFactory.openSession();
    Transaction transaction = session.beginTransaction();
    Person person = (Person) session.get(Person.class, 1L);//这个person在 第一个事务之中
    person.setPname("11"); //person在第一个session的事务中
    session =sessionFactory.openSession();//这是第二个session，如果把这个session给注释了，那么第一个session开启了两个事务，即使第一个事务不提交，第二个事务提交，仍然可以和数据库发生交互，因为这两个事务都在同一个session中
    Transaction transaction2 = session.beginTransaction();
    person.setPname("22"); //person在第一个session的事务中
    transaction2.commit();
    //transaction.commit();//第一个session的事务不提交，不会和数据库发生交互
    session.close();
           }
    ｝