Hibernate生命周期

hibernate生命周期有瞬时状态、持久化状态、游离状态三个，下面分别介绍下这三个状态：

1、瞬时状态（Transient）

      使用new操作符初始化的对象就是瞬时状态，它们没有任何跟数据库表相关联的行为，只要应用不再引起这些对象（不再被任何其他对象所引用），它们的状态将会丢失，并由垃圾回收机制回收。

2、持久化状态（Parsistent）

      1)持久化状态的对象是具有数据库标识的实例，它有持久化管理器Session统一管理。

      2)持久化状态的实例在事务中进行操作，它们的状态在事务结束时同数据库进行同步。当事务提交时，通过执行SQL的INSERT、UPDATE和DELETE语句把内存中的状态同步到数据库中。

3、游离状态（Detached）

      Session关闭之后，持久化状态就会变成游离状态。游离状态表示这个对象不能再与数据库保持同步，它们不再受hibernate管理。

hibernate生命周期中三种状态的转化图如下：

Transient：随时可能被垃圾回收器回收（在数据库中没有与之对应的记录，因为是new初始化），而执行save()方法后，就变为Persistent状态，没有纳入session的管理。

Persistent：在数据库有存在的对应的记录，纳入session管理。在清理缓存（脏数据检查）的时候，会和数据库同步。

Detached：也可能被垃圾回收器回收掉（数据库中存在对应放入记录，只是没有任何对象引用它是指session引用），注引状态经过Persistent状态，没有纳入session管理

下面是我写的测试案例。

hibernate获取Session对象和关闭的类HibernateUtil

public class HibernateUtil {
	private static Configuration cfg=null;
	private static SessionFactory factory=null;
	private static Session session=null;
	static{
		cfg=new Configuration().configure();
		factory=cfg.buildSessionFactory(new StandardServiceRegistryBuilder()
		.applySettings(cfg.getProperties()).build());
	}
	public static Session getSession(){
		if(factory!=null)
			return factory.openSession();
		factory=cfg.buildSessionFactory(new StandardServiceRegistryBuilder()
		.applySettings(cfg.getProperties()).build());
		return factory.openSession();
	}
	public static void closeSession(){
		if(session!=null&&session.isOpen()){
			session.close();
		}
	}
}

HibernateTest类是测试类，使用Junit4进行测试，代码如下：

public class HibernateTest {
	/**
	 * session的save方法，保存数据session中状态改变：瞬时-->持久-->游离
	 */
	@Test
	public void testSave(){
		Session session=null;
		Transaction tx=null;
		User user=null;
		try {
			session=HibernateUtil.getSession();
			tx=session.beginTransaction();
			//构造对象--瞬时状态
			user=new User();
			user.setName("admin");
			user.setPwd("12345");
			//持久化状态，user被session管理，并且id有值--oid
			session.save(user);
			//在持久化状态下：hibernate会执行脏数据检查（之前的数据成为脏数据）
			//当提交事务，或清理缓存时，发现session中数据和之前要放入数据库中数据（此时数据任在Session中并未真正在数据库中）不一致时
			//将会把Session中的数据更新到数据库中
			user.setName("zhangsan");
			
			tx.commit();
		} catch (Exception e) {
			e.printStackTrace();
			tx.rollback();
			throw new HibernateException(e.getCause());
		}finally{
			HibernateUtil.closeSession();
		}
		//user处于游离状态，但是在内存中仍然存在
		System.out.println("name="+user.getName());
	}
	
	/**
	 * session.get方法，获取数据
	 */
	@Test
	public void testGet(){
		Session session=null;
		Transaction tx=null;
		try{
			session=HibernateUtil.getSession();
			tx=session.beginTransaction();
			
			//get后变为持久化状态，get方法查询数据的顺序为：session-->sessionFactory-->数据库中
			User user=(User) session.get(User.class,2);
			System.out.println("name="+user.getName());
			tx.commit();
		}catch(Exception e){
			e.printStackTrace();
			tx.rollback();
		}finally{
			HibernateUtil.closeSession();
		}
	}
	@Test
	public void testGet2(){
		Session session=null;
		Transaction tx=null;
		try{
			session=HibernateUtil.getSession();
			tx=session.beginTransaction();
			//get方法如果根据id找不到对象（此时数据库没有id=10的数据），不会抛出异常，返回null
			User user=(User) session.get(User.class, 10);
			System.out.println("name="+user.getName());
			tx.commit();
		}catch(Exception e){
			e.printStackTrace();
			tx.rollback();
		}finally{
			HibernateUtil.closeSession();
		}
	}
	/**
	 * load和get的区别：
	 * load和get都会立即查询对象，get找不到对象时返回null，load找不到对象时，抛出异常
	 */
	@Test
	public void testLoad(){
		Session session=null;
		Transaction tx=null;
		try{
			session=HibernateUtil.getSession();
			tx=session.beginTransaction();
			//load后变为持久化状态，load方法查询数据顺序为：session-->sessionFactory-->数据库中
			//在3.x版本中，load不会立即查询对象，等到使用时才会查询
			//在4.3中立即查询了对象，当对象不存在时，会抛出异常
			User user=(User) session.load(User.class, 2);
			System.out.println("name="+user.getName());
			
			//clear和evict区别：
			//clear清除session缓冲中所有对象，evict清除指定对象
			session.clear();
			tx.commit();
			//user游离状态，不被session管理，数据库中不会被更改
			user.setName("lisi");
			System.out.println("clear后：name="+user.getName());
		}catch(Exception e){
			e.printStackTrace();
			tx.rollback();
		}finally{
			HibernateUtil.closeSession();
		}
	}
	/**
	 * delete方法：持久化状态-->瞬时状态
	 */
	@Test
	public void testDelete(){
		Session session=null;
		Transaction tx=null;
		User user=null;
		try{
			session=HibernateUtil.getSession();
			tx=session.beginTransaction();
			//手动构造一个对象，指定其主键是可以删除该对象的，但不建议这么使用
//			user=new User();
//			user.setId(2);
//			user.setName("wangwu");
			
			//通过从数据库中加载该对象，然后删除，可以进行判断，进而避免异常，提高程序健壮性
			user=(User) session.get(User.class, 2);
			if(user!=null)
				session.delete(user);
			tx.commit();
		}catch(Exception e){
			e.printStackTrace();
			tx.rollback();
		}finally{
			HibernateUtil.closeSession();
		}
	}
	
	@Test
	public void testUpdate(){
		Session session=null;
		Transaction tx=null;
		User user=null;
		try{
			session=HibernateUtil.getSession();
			tx=session.beginTransaction();
			//手动构造的瞬时状态的对象，可以修改，但需要指定所有属性，不建议这么使用
//			user=new User();
//			user.setId(3);
//			user.setName("wing");
			
			user=(User) session.get(User.class, 2);
			user.setName("king");
			session.update(user);
			tx.commit();
		}catch(Exception e){
			e.printStackTrace();
			tx.rollback();
		}finally{
			HibernateUtil.closeSession();
		}
	}

}