Hibernate的持久化对象

    关于持久化对象的生命周期： 
    Persistent Object：持久化对象可以是普通的Javabeans,惟一特殊的是它们与（仅一个）Session相关联。JavaBeans在Hibernate中存在三种状态：
     1.瞬时状态(transient):当一个JavaBean对象在内存中孤立存在，不与数据库中的数据有任何关联关系时，那么这个JavaBean对象就称为瞬时对象(Transient Object)。一个很重要的特点：没有被Session管理，数据库没有这个JavaBean。
     2.持久化状态(persistent):当一个JavaBean对象与一个Session相关联时，就变成持久化对象(Persistent Object)。它们的状态在事务结束时同数据库进行同步。
     3.脱管状态(detached):在这个Session被关闭的同时，这个对象也会脱离持久化状态，就变成脱管状态(Detached Object)，可以被应用程序的任何层自由使用。没有被Session管理，但数据库有这个JavaBean。

下面就各种状态介绍下示例：
HibernateUtil类：

public class HibernateUtil {
	private static SessionFactory factory = null;

	static {
		try {
			Configuration cfg = new Configuration().configure();
			ServiceRegistry serviceRegistry = new ServiceRegistryBuilder()
					.applySettings(cfg.getProperties()).buildServiceRegistry();
			factory = cfg.buildSessionFactory(serviceRegistry);
		} catch (HibernateException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public static Session getSession() {
		return factory.openSession();
	}

	public static void close(Session session) {
		if (session != null) {
			if (session.isOpen()) {
				session.close();
			}
		}
	}

	public static SessionFactory getSessionFactory() {
		return factory;
	}

	public static void createTable() {
		// 默认读取hibernate.cfg.xml
		Configuration cfg = new Configuration().configure();

		// 将hbm生成ddl
		SchemaExport export = new SchemaExport(cfg);
		export.create(true, true);
	}
}

添加测试：

	@Test
	public void testSave() {
		Session session = null;
		Transaction transaction = null;
		User user = null;
		try {
			session = HibernateUtil.getSession();
			transaction = session.beginTransaction();
			user = new User("aaa", "123", new Date());// 此时是瞬时状态
			System.out.println(user);
			System.out.println("----****** 调用save() **********----");
			session.save(user);// 被纳入Session管理，此时是持久状态
			System.out.println(user);
			user.setName("bbb");
			System.out.println("----*******调用setName()**********----");
			System.out.println(user);
			// 提交事务
			System.out.println("----*******调用commit()**********----");
			session.getTransaction().commit();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			if (transaction != null) {
				transaction.rollback();
			}
		} finally {
			HibernateUtil.close(session);
		}
		user.setName("ccc");// Session已经关闭，此时是托管状态
		System.out.println("----*******调用setName()**********----");
		System.out.println(user);
	}

运行结果：

User [id=0, name=aaa, password=123, birthday=Sat May 23 21:54:08 CST 2015]
----****** 调用save() **********----
Hibernate: insert into t_user (name, password, birthday) values (?, ?, ?)
User [id=15, name=aaa, password=123, birthday=Sat May 23 21:54:08 CST 2015]
----*******调用setName()**********----
User [id=15, name=bbb, password=123, birthday=Sat May 23 21:54:08 CST 2015]
----*******调用commit()**********----
Hibernate: update t_user set name=?, password=?, birthday=? where userID=?
----*******调用setName()**********----
User [id=15, name=ccc, password=123, birthday=Sat May 23 21:54:08 CST 2015]

查询测试：

	@Test
	public void testGet() {
		Session session = null;
		Transaction transaction = null;
		User user = null;
		try {
			session = HibernateUtil.getSession();
			transaction = session.beginTransaction();
			user = (User) session.get(User.class, 1);// 此时是持久状态，<span style="font-size: 11.8181819915771px; font-family: Arial, Helvetica, sans-serif;">get(User.class, 1)中的二个参数是主键</span>
			System.out.println("----------------------------");
			System.out.println(user);
			user = (User) session.get(User.class, 0);// 如果不存在，返回null
			System.out.println("----------------------------");
			System.out.println(user);
			transaction.commit();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			if (transaction != null) {
				transaction.rollback();
			}
		} finally {
			HibernateUtil.close(session);
		}
	}

运行结果：

Hibernate: select user0_.userID as userID1_0_0_, user0_.name as name2_0_0_, user0_.password as passw
ord3_0_0_, user0_.birthday as birthday4_0_0_ from t_user user0_ where user0_.userID=?
----------------------------
User [id=1, name=zero, password=123456, birthday=2015-05-23 13:08:12.0]
Hibernate: select user0_.userID as userID1_0_0_, user0_.name as name2_0_0_, user0_.password as passw
ord3_0_0_, user0_.birthday as birthday4_0_0_ from t_user user0_ where user0_.userID=?
----------------------------
null

或则采用另种方式：

	@Test
	public void testLoad() {
		Session session = null;
		Transaction transaction = null;
		User user = null;
		try {
			session = HibernateUtil.getSession();
			transaction = session.beginTransaction();
			// 不会马上发出查询语句，因为load支持lazy（延迟加载/懒加载）
			// 只有真正使用这个对象的时候，再创建,即才真正的发出查询语句，主要是为了提高性能
			// load（）返回会的是代理类，代理对象主要采用的是CGLIB库生成的
			user = (User) session.load(User.class, 1);// 此时是持久状态
			System.out.println("----------------------------");
			System.out.println(user);

			// user = (User) session.load(User.class, 0);//
			// 如果不存在，抛org.hibernate.ObjectNotFoundException

			transaction.commit();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			if (transaction != null) {
				transaction.rollback();
			}
		} finally {
			HibernateUtil.close(session);
		}
	}

运行结果：

----------------------------
Hibernate: select user0_.userID as userID1_0_0_, user0_.name as name2_0_0_, user0_.password as passw
ord3_0_0_, user0_.birthday as birthday4_0_0_ from t_user user0_ where user0_.userID=?
User [id=1, name=zero, password=123456, birthday=2015-05-23 13:08:12.0]

删除测试：

	@Test
	public void testDel() {
		Session session = null;
		Transaction transaction = null;
		User user = null;
		try {
			session = HibernateUtil.getSession();
			transaction = session.beginTransaction();
			// 推荐使用此方式
			user = (User) session.load(User.class, 1);// 此时是持久状态
			session.delete(user);

			// 或则采用这种方式
			user = new User();// 托管状态
			user.setId(2);
			session.delete(user);
			transaction.commit();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			if (transaction != null) {
				transaction.rollback();
			}
		} finally {
			HibernateUtil.close(session);
		}
	}

更新测试：

	@Test
	public void testUpdate() {
		Session session = null;
		Transaction transaction = null;
		User user = null;
		try {
			session = HibernateUtil.getSession();
			transaction = session.beginTransaction();
			// 推荐使用此方式
			user = (User) session.load(User.class, 1);// 此时是持久状态
			user.setName("update");
			// 可以显示update，实际上user已是持久状态，可以不用调用update也可更新到数据库
			session.update(user);
			transaction.commit();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			if (transaction != null) {
				transaction.rollback();
			}
		} finally {
			HibernateUtil.close(session);
		}
	}