Hibernate进阶：理解Hibernate中的四种状态（临时状态，持久状态，游离状态，删除状态）

首先来理解一下四种状态的相关区别以及必要的知识点：

（1）什么是OID
OID的中文名叫对象标识符，是hibernate框架为每个进入session一级缓存中的对象设置的一个唯一性标识，
将来对应表中的主健，是决不能重复的。
session对象的四种状态转换：
   （2）对象在整个hibernate框架中运行，一共有四种不同的状态产生：
我们从三个方面进行比较：（1）OID是否为NULL；（2）位于session缓存内或外；（2）是否有与数据库交互能力；
       （A）临时状态
   能过new关健字创建的对象
   无OID
   在session缓存外
   无数据库交互能力    

       （B）持久状态【重点】
   能过save关健字操作的对象
   有OID
   在session缓存内
   有数据库交互能力    
       （C）游离状态
   能过evict关健字操作的对象
   有OID
   在session缓存外
   无数据库交互能力 

       （D）删除状态【隐操作】
   能过delete关健字操作的对象
   有OID
   在session缓存外
   无数据库交互能力 

四种状态转换关系图：

 （3）测试以下几种不同的状态变化
       （A）开始-->持久状态-->结束
       （B）开始-->持久状态-->游离状态-->结束
       （C）开始-->临时状态-->持久状态-->删除状态-->结束
       （D）开始-->临时状态-->持久状态-->游离状态-->删除状态-->结束
       （E）开始-->临时状态-->持久状态-->游离状态-->持久状态-->删除状态-->结束

以下的程序是根据（3）来深入理解每种状态的变化：

准备一个工具类HibernateUtils ：

package example.utils;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtils {
	private static  SessionFactory sessionFactory;
	private static ThreadLocal<Session> threadLocal;
	static{
		//创建configure配置文件hibernate.properties
		Configuration cfg=new Configuration();
		//加载映射文件hibernate.cfg.xml
		cfg.configure();
		//创建sessionFactory工厂对象
		sessionFactory=cfg.buildSessionFactory();
		threadLocal=new ThreadLocal<Session>();
	}
	
	//获取session对象
	public static Session getSession(){
		/*
		 * 从当前线程中获取Session对象
		 */
		Session session=threadLocal.get();
		if(session==null || !session.isOpen()){
			/*
			 * 找SessionFactory获取Session对象
			 */
			session=sessionFactory.openSession();
			/*
			 * 将Session对象和当前线程绑定在一起
			 */
			threadLocal.set(session);
		}
		return session;
	}
	//关闭的session对象必须是上面已经获取的session对象
	public static void closeSession(){
		//获取当前线程session对象
		Session session =threadLocal.get();
		if(session!=null&& session.isOpen()){
			session.close();
			//将线程与session对象分离
			threadLocal.remove();
		}
	}
}

package example.dao;

import java.util.Date;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test;

import example.domain.Person;
import example.utils.HibernateUtils;
//测试以下几种不同的状态变化
public class PersonDao5 {

	/**
	 *  （A）开始-->持久状态-->结束
	 */
	@Test
	public void test1(){
		Session session=null;
		Transaction ts=null;
		try{
			//创建session对象
			//session= sessionFactory.openSession();
			session=HibernateUtils.getSession();
			//开启事务
			ts= session.getTransaction();
			//开始事务
			ts.begin();
			// 持久对象
			Person person= (Person) session.get(Person.class, 1);
			System.out.println(person.getId());
			ts.commit();
		}catch (Exception e) {
			// TODO: handle exception
			ts.rollback();
			e.printStackTrace();
		}finally{
			//session.close();
			HibernateUtils.closeSession();
		}
	}
	/**
	 * 开始-->持久状态-->游离状态-->结束
	 */
	
	@Test
	public void test2(){ 
		Session session=HibernateUtils.getSession();
		Transaction ts= session.getTransaction();
		try{
			ts.begin();
			Person person= (Person) session.get(Person.class, 1);
			session.evict(person);
			System.out.println(person.getId());
			ts.commit();
		}catch (Exception e) {
			// TODO: handle exception
			ts.rollback();
			e.printStackTrace();
		}finally{
			//session.close();
			HibernateUtils.closeSession();
		}
	}
	/**
	 * 开始-->临时状态-->持久状态-->删除状态-->结束
	 */
	@Test
	public void test3(){//更新必须要事务
		Session session=HibernateUtils.getSession();
		Transaction ts= session.getTransaction();
		try{
			ts.begin();
			//临时状态对象
			Person person=new Person(200, "小牛", "男", new Date());
			//持久状态对象
			session.save(person);
			//删除状态对象
			session.delete(person);
			ts.commit();
		}catch (Exception e) {
			// TODO: handle exception
			ts.rollback();
			e.printStackTrace();
		}finally{
			//session.close();
			HibernateUtils.closeSession();
		}
	}
	/**
	 * 开始-->临时状态-->持久状态-->游离状态-->删除状态-->结束
	 */
	@Test
	public void test4(){//
		Session session=HibernateUtils.getSession();
		Transaction ts= session.getTransaction();
		try{
			ts.begin();
			//临时状态对象
			Person person=new Person(201, "小长", "男", new Date());
			//持久状态对象
			session.save(person);
			//游离状态对象
			session.evict(person);
			//删除状态对象
			session.delete(person);
			System.out.println(person.getId());
			ts.commit();
		}catch (Exception e) {
			// TODO: handle exception
			ts.rollback();
			e.printStackTrace();
		}finally{
			//session.close();
			HibernateUtils.closeSession();
		}
	}
	/**
	 * 开始-->临时状态-->持久状态-->游离状态-->持久状态-->删除状态-->结束
	 */
	@Test
	public void test5(){//批量增加
		Session session=HibernateUtils.getSession();
		Transaction ts= session.getTransaction();
		try{
			ts.begin();
			//临时状态对象
			Person person=new Person(201, "小长", "男", new Date());
			//持久状态对象
			session.save(person);
			//游离状态对象
			session.evict(person);
			//持久状态对象
			session.update(person);
			//删除状态对象
			session.delete(person);
			System.out.println(person.getId());
			ts.commit();
		}catch (Exception e) {
			// TODO: handle exception
			ts.rollback();
			e.printStackTrace();
		}finally{
			//session.close();
			HibernateUtils.closeSession();
		}
	}
}