Hibernate的三种状态

hibernate中的对象有三种状态： 瞬时状态 (Transient)，持久状态 (Persistent)，脱管状态 (Detached)

package itat.zttc.hibernate.test;

import java.text.SimpleDateFormat;

import org.hibernate.Session;
import org.junit.Test;

import itat.zttc.hibernate.model.User;
import itat.zttc.hibernate.util.HibernateUtil;

public class TestStatus {
	private SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
	@Test
	public void testTransient() {
		Session session = null;
		try {
			session = HibernateUtil.openSession();
			session.beginTransaction();
			User u = new User();
			u.setBorn(sdf.parse("1986-3-27"));
			u.setNickname("凤鹏");
			u.setUsername("fengpeng");
			u.setPassword("000000");
			//以上u是Transient(瞬时状态),数据库中没有且没有被session管理就是瞬时状态；
			/**
			 * 执行session.save(u)之后，u被session管理(即在session的缓存中存在u这个对象)，而且数据库中已经存在，此时转换为
			 * Persistent(持久化状态)，数据库有且被session所管理就是持久化状态
			 */
			session.save(u);
			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			if(session!=null) session.getTransaction().rollback();
		} finally {
			HibernateUtil.close(session);
		}
	}

	@Test
	public void testPersistent01() {
		Session session = null;
		try {
			session = HibernateUtil.openSession();
			session.beginTransaction();
			User u = new User();
			u.setBorn(sdf.parse("1985-1-1"));
			u.setNickname("杨杰伦");
			u.setUsername("yangjielong");
			u.setPassword("000000");
			session.save(u);
			//此时u是持久化状态，已经被session所管理，当在提交时，会把session中的对象和目前的对象进行比较
            //如果两个对象中的值不一致就会继续发出相应的sql语句
			u.setNickname("杨杰龙");
			//此时会发出2条sql，一条用来做插入，一条用来做更新
			session.getTransaction().commit();
			/**
			 * 在调用了save方法后，此时user已经是持久化对象了，被保存在了session缓存当中，
			 * 这时user又重新修改了属性值，那么在提交事务时，此时hibernate对象就会拿当前
			 * 这个user对象和保存在session缓存中的user对象进行比较，如果两个对象相同，则
			 * 不会发送update语句，否则，如果两个对象不同，则会发出update语句。
			 */
		} catch (Exception e) {
			e.printStackTrace();
			if(session!=null) session.getTransaction().rollback();
		} finally {
			HibernateUtil.close(session);
		}
	}
	
	@Test
	public void testPersistent02() {
		Session session = null;
		try {
			session = HibernateUtil.openSession();
			session.beginTransaction();
			User u = new User();
			u.setBorn(sdf.parse("1985-1-1"));
			u.setNickname("焦凯");
			u.setUsername("jiaokaikai");
			u.setPassword("000000");
			session.save(u);
			u.setPassword("111111");
			//该句没有意义
			session.save(u);
			u.setUsername("jiaokai");
			//该句没有意义
			session.update(u);
			u.setBorn(sdf.parse("1988-3-3"));
			//该句没有意义
			session.update(u);
			/**
			 * 还是同样的道理，在调用save方法后，u此时已经是持久化对象了，记住一点：如果一个对象以及是持久化状态了，
			 * 那么此时对该对象进行各种修改，或者调用多次update、save方法时，hibernate都不会发送sql语句，只有当事物
			 * 提交的时候，此时hibernate才会拿当前这个对象与之前保存在session中的持久化对象进行比较，如果不相同就发
			 * 送一条update的sql语句，否则就不会发送update语句
			 */
			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			if(session!=null) session.getTransaction().rollback();
		} finally {
			HibernateUtil.close(session);
		}
	}
	
	@Test
	public void testPersistent03() {
		Session session = null;
		try {
			session = HibernateUtil.openSession();
			session.beginTransaction();
			User u = new User();
			u.setBorn(sdf.parse("1988-7-1"));
			u.setNickname("王龙芳");
			u.setUsername("wanglongfang");
			u.setPassword("000000");
			session.save(u);
			/**
			 * 以下三条语句没有意义
			 */
			session.save(u);
			session.update(u);
			session.update(u);
			u.setPassword("111111");
			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			if(session!=null) session.getTransaction().rollback();
		} finally {
			HibernateUtil.close(session);
		}
	}
	
	@Test
	public void testPersistent04() {
		Session session = null;
		try {
			session = HibernateUtil.openSession();
			session.beginTransaction();
			//此时u是Persistent
			User u = session.load(User.class, 13);
			//由于u这个对象和session中的对象不一致，所以会发出sql完成更新
			u.setUsername("wangfang");
			/**
			 * 当session调用load、get方法时，此时如果数据库中有该对象，则该对象
			 * 也变成了一个持久化对象，被session所托管。因此，这个时候如果对对象
			 * 进行操作，在提交事务时同样会去与session中的持久化对象进行比较，因
			 * 此这里会发送两条sql语句
			 */
			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			if(session!=null) session.getTransaction().rollback();
		} finally {
			HibernateUtil.close(session);
		}
	}
	
	@Test
	public void testPersistent05() {
		Session session = null;
		try {
			session = HibernateUtil.openSession();
			session.beginTransaction();
			//此时u是Persistent
			User u = session.load(User.class, 13);
			u.setNickname("王芳芳");
			//清空session
			session.clear();
			/**
			 * 当我们load出user对象时，此时user是持久化的对象，在session缓存中
			 * 存在该对象，此时我们在对user进行修改后，然后调用session.clear()
			 * 方法，这个时候就会将session的缓存对象清空，那么session中就没有了
			 * user这个对象，这个时候在提交事务的时候，发现已经session中已经没
			 * 有该对象了，所以就不会进行任何操作，因此这里只会发送一条select语句
			 */
			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			if(session!=null) session.getTransaction().rollback();
		} finally {
			HibernateUtil.close(session);
		}
	}
	
	@Test
	public void testDetach01() {
		Session session = null;
		try {
			session = HibernateUtil.openSession();
			session.beginTransaction();
			//此时u是一个离线对象，没有被session托管
			User u = new User();
			u.setId(13);
			u.setPassword("222222");
			//当执行save的时候总是会添加一条数据，此时id就会根据Hibernate所定义的规则来生成
			session.save(u);
			/**
			 * 当调用了u.setId(13)时，此时u是一个离线的对象，因为数据库中存在id=13的这个对象，但是该对象又没有被session所托管，
			 * 所以这个对象就是离线的对象，要使离线对象变成一个持久化的对象，应该调用什么方法呢？我们知道调用save方法，可以将
			 * 一个对象变成一个持久化对象，但是，当save一执行的时候，此时hibernate会根据id的生成策略往数据库中再插入一条数据，
			 * 所以如果调用save方法，此时数据库会发送一条插入的语句，所以对于离线对象，如果要使其变成持久化对象的话，我们不能
			 * 使用save方法，而应该使用update方法
			 */
			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			if(session!=null) session.getTransaction().rollback();
		} finally {
			HibernateUtil.close(session);
		}
	}
	
	@Test
	public void testDetach02() {
		Session session = null;
		try {
			session = HibernateUtil.openSession();
			session.beginTransaction();
			User u = new User();
			u.setId(13);
			u.setPassword("222222");
            //完成update之后也会变成持久化状态
			session.update(u);
			u.setBorn(sdf.parse("1990-2-3"));
			u.setNickname("常建江");
			u.setUsername("changjianjiang");
			//只会发出一条sql
			session.update(u);
			/**
			 * 当调用了update方法以后，此时u已经变成了一个持久化的对象，那么如果此时对u对象进行
			 * 修改操作后，在事务提交的时候，则会拿该对象和session中刚保存的持久化对象进行比较，
			 * 如果不同就发一条sql语句
			 */
			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			if(session!=null) session.getTransaction().rollback();
		} finally {
			HibernateUtil.close(session);
		}
	}
	
	@Test
	public void testDetach03() {
		Session session = null;
		try {
			session = HibernateUtil.openSession();
			session.beginTransaction();
			User u = new User();
			u.setId(13);
			u.setPassword("222222");
            //完成update之后也会变成持久化状态
			session.update(u);
			u.setBorn(sdf.parse("1990-2-3"));
			u.setNickname("常建江");
			u.setUsername("changjianjiang");
			//会抛出异常
			u.setId(14);
			session.update(u);
			/**
			 * 调用update方法后，u变成了一个持久化对象，在对u进行一些修改后，
			 * 此时又通过 u.setId(14)方法设置了u的ID，那么这个时候，hibernate会报
			 * 错，因为u当前已经是一个持久化对象，如果试图修改一个持久化对象
			 * 的ID的值的话，就会抛出异常
			 */
			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			if(session!=null) session.getTransaction().rollback();
		} finally {
			HibernateUtil.close(session);
		}
	}
	
	@Test
	public void testDetach04() {
		Session session = null;
		try {
			session = HibernateUtil.openSession();
			session.beginTransaction();
			//现在u是离线状态
			User u = new User();
			u.setId(14);
			//现在u是瞬时状态
            session.delete(u);
            //此时u已经是瞬时对象，不会被session和数据库所管理
            u.setNickname("rendechang");
            /**
             * 在调用了session.delete()方法以后，u就会变成一个瞬时对象，数据库中不存在也不被session管理，
             * 那么对u再进行各种修改操作的话，hibernate也不会发送任何修改语句，因此这里只会有一条delete的语句发生
             */
			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			if(session!=null) session.getTransaction().rollback();
		} finally {
			HibernateUtil.close(session);
		}
	}
	
	@Test
	public void testDetach05() {
		Session session = null;
		try {
			session = HibernateUtil.openSession();
			session.beginTransaction();
			//现在u是离线状态
			User u = new User();
			u.setId(13);
			u.setNickname("yangchen");
			//saveOrUpdate()如果u是离线状态就执行update操作，如果是瞬时状态就执行save操作
			//如果对象设置了ID值，例如u.setId(13)，那么该对象会被假设当作一个离线对象，就会执行update操作
			//如果将u.setId(13)这句话注释掉，那么此时u就是一个瞬时对象，就会执行save操作，会发送一条insert语句
			//注意：该方法不常用；
			session.saveOrUpdate(u);
			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			if(session!=null) session.getTransaction().rollback();
		} finally {
			HibernateUtil.close(session);
		}
	}
	
	@Test
	public void testDetach06() {
		Session session = null;
		try {
			session = HibernateUtil.openSession();
			session.beginTransaction();
			//u1是持久化状态
			User u1 = session.load(User.class, 13);
			System.out.println(u1.getNickname());
			//u2是离线状态
			User u2 = new User();
			u2.setId(13);
			u2.setNickname("杨辰");
			u2.setUsername("yangchen");
			/**
			 * 此时session.saveOrUpdate(u2)将会使u2变成持久化状态，在session缓存中就存在
			 * 两份同样的拷贝，在session中不允许存在两份同样的拷贝，否则会抛出异常,
			 * a different object with the same identifier value was already associated with the session:
			 * 一个session中不能存在对一个持久化对象的双重copy的，要解决这个问题，要使用另一个方法：
			 * merge方法，这个方法的作用就是解决一个持久化对象两份拷贝的问题，这个方法会将两个对象合并在
			 * 一起成为一个对象
			 */
			//session.saveOrUpdate(u2);
			//merge方法会判断session中是否已经存在同一个对象，如果存在就将两个对象合并
			session.merge(u2);
			//最佳实践：merge一般不用
			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			if(session!=null) session.getTransaction().rollback();
		} finally {
			HibernateUtil.close(session);
		}
	}
}