1、概况
（1）瞬时状态（临时态）
在对象中如果对象刚被创建但没有被持久化的话就是瞬时态
特点：
(1) 不和 Session 实例关联
(2)在http://www.wfuyu.com/db/中没有和瞬时对象关联的记录
（2）持久状态
持久化对象就是已被保存进http://www.wfuyu.com/db/的实体对象，并且这个实体对象现在还处于Hibernate的Session缓存管理当中。这时对该实体对象的任何修改，都会在清算缓存时同步到http://www.wfuyu.com/db/中。
特点：
（1）持久的实例在http://www.wfuyu.com/db/中有对应的记录，并具有1个持久化标识(identifier).
（2）和session相干联的对象
（3）游离状态（托管状态、离线状态）
当1个持久化对象，脱离开Hibernate的缓存管理后，它就处于游离状态，游离对象和自由对象的最大区分在于，游离对象在http://www.wfuyu.com/db/中可能还存在1条与它对应的记录，只是现在这个游离对象脱离了Hibernate的缓存管理，而自由对象不会在http://www.wfuyu.com/db/中出现与它对应的数据记录。
特点：
(1) 本质上和瞬时对象相同
(2)只是比瞬时对象多了1个http://www.wfuyu.com/db/记录标识值id。
2、转化图
通过以下的转换图就能够明白3态之间是如何转换的，如果将这幅图印在自己的头脑里，3态就没甚么神圣的啦！
3、实战
以上是对3态理论知识上的讲授，那末接下来就从实际代码中体验1下它们的奥妙吧！
1.TestTransient
session = HibernateUtil.openSession();
session.beginTransaction();
User user = new User();
user.setUsername("aaa");
user.setPassword("aaa");
user.setBorn(new Date());
/*
* 以上user就是1个Transient(瞬时状态),此时user并没有被session进行托管，即在session的
* 缓存中还不存在user这个对象，当履行完save方法后，此时user被session托管，并且http://www.wfuyu.com/db/中存在了该对象
* user就变成了1个Persistent(持久化对象)
*/
session.save(user);
session.getTransaction().commit();
此时我们知道hibernate会发出1条insert的语句，履行完save方法后，该user对象就变成了持久化的对象了
Hibernate: insertinto t_user (born, password, username) values (?, ?, ?)
2.TestPersistent01
session = HibernateUtil.openSession();
session.beginTransaction();
User user = new User();
user.setUsername("aaa");
user.setPassword("aaa");
user.setBorn(new Date());
//以上u就是Transient（瞬时状态），表示没有被session管理并且http://www.wfuyu.com/db/中没有
//履行save以后，被session所管理，而且，http://www.wfuyu.com/db/中已存在，此时就是Persistent状态
session.save(user);
//此时u是持久化状态，已被session所管理，当在提交时，会把session中的对象和目前的对象进行比较
//如果两个对象中的值不1致就会继续发出相应的sql语句
user.setPassword("bbb");
//此时会发出2条sql，1条用户做插入，1条用来做更新
session.getTransaction().commit();
在调用了save方法后，此时user已是持久化对象了，被保存在了session缓存当中，这时候user又重新修改了属性值，那末在提交事务时，此时hibernate对象就会拿当前这个user对象和保存在session缓存中的user对象进行比较，如果两个对象相同，则不会发送update语句，否则，如果两个对象不同，则会发出update语句。
Hibernate: insertinto t_user (born, password, username) values (?, ?, ?)
Hibernate: updatet_user set born=?, password=?, username=? where id=?
3.TestPersistent02
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
session =HibernateUtil.openSession();
session.beginTransaction();
User u = new User();
u.setBorn(new Date());
u.setUsername("zhangsan");
u.setPassword("zhangsan");
session.save(u);
u.setPassword("222");
//该条语句没成心义
session.save(u);
u.setPassword("zhangsan111");
//没成心义
session.update(u);
u.setBorn(sdf.parse("1988⑴2⑵2"));
//没成心义
session.update(u);
session.getTransaction().commit();
这个时候会发出多少sql语句呢？还是一样的道理，在调用save方法后，u此时已是持久化对象了，记住1点：如果1个对象和是持久化状态了，那末此时对该对象进行各种修改，或调用屡次update、save方法时，hibernate都不会发送sql语句，只有当事物提交的时候，此时hibernate才会拿当前这个对象与之前保存在session中的持久化对象进行比较，如果不相同就发送1条update的sql语句，否则就不会发送update语句
Hibernate: insertinto t_user (born, password, username) values (?, ?, ?)
Hibernate: updatet_user set born=?, password=?, username=? where id=?
4.TestPersistent03
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
session =HibernateUtil.openSession();
session.beginTransaction();
User u = new User();
u.setBorn(sdf.parse("1976⑵⑶"));
u.setUsername("zhangsan2");
u.setPassword("zhangsan2");
session.save(u);
/*
* 以下3条语句没有任何意义
*/
session.save(u);
session.update(u);
session.update(u);
u.setUsername("zhangsan3");
session.getTransaction().commit();
相信这个测试用例，大家应当都知道结果了，没错，此时hibernate也会发出两条sql语句，原理1样的
Hibernate: insertinto t_user (born, password, username) values (?, ?, ?)
Hibernate: updatet_user set born=?, password=?, username=? where id=?
5.TestPersistent04
session = HibernateUtil.openSession();
session.beginTransaction();
//此时u是Persistent
User u =(User)session.load(User.class, 4);
//由于u这个对象和session中的对象不1致，所以会发出sql完成更新
u.setUsername("bbb");
session.getTransaction().commit();
我们来看看此时会发出多少sql语句呢？一样记住1点：当session调用load、get方法时，此时如果http://www.wfuyu.com/db/中有该对象，则该对象也变成了1个持久化对象，被session所托管。因此，这个时候如果对对象进行操作，在提交事务时一样会去与session中的持久化对象进行比较，因此这里会发送两条sql语句
Hibernate: selectuser0_.id as id0_0_, user0_.born as born0_0_, user0_.password as password0_0_,user0_.username as username0_0_ from t_user user0_ where user0_.id=?
Hibernate: updatet_user set born=?, password=?, username=? where id=?
6.TestPersistent05
session = HibernateUtil.openSession();
session.beginTransaction();
//此时u是Persistent
User u =(User)session.load(User.class, 4);
u.setUsername("123");
//清空session
session.clear();
session.getTransaction().commit();
再看这个例子，当我们load出user对象时，此时user是持久化的对象，在session缓存中存在该对象，此时我们在对user进行修改后，然后调用session.clear()方法，这个时候就会将session的缓存对象清空，那末session中就没有了user这个对象，这个时候在提交事务的时候，发现已session中已没有该对象了，所以就不会进行任何操作，因此这里只会发送1条select语句
Hibernate: selectuser0_.id as id0_0_, user0_.born as born0_0_, user0_.password as password0_0_,user0_.username as username0_0_ from t_user user0_ where user0_.id=?
7.TestDetached01
session = HibernateUtil.openSession();
session.beginTransaction();
//此时u是1个离线对象，没有被session托管
User u = new User();
u.setId(4);
u.setPassword("hahahaha");
//当履行save的时候总是会添加1条数据，此时id就会根据Hibernate所定义的规则来生成
session.save(u);
session.getTransaction().commit();
我们看到，当调用了u.setId(4)时，此时u是1个离线的对象，由于http://www.wfuyu.com/db/中存在id=4的这个对象，但是该对象又没有被session所托管，所以这个对象就是离线的对象，要使离线对象变成1个持久化的对象，应当调用甚么方法呢？我们知道调用save方法，可以将1个对象变成1个持久化对象，但是，当save1履行的时候，此时hibernate会根据id的生成策略往http://www.wfuyu.com/db/中再插入1条数据，所以如果调用save方法，此时http://www.wfuyu.com/db/会发送1条插入的语句：
Hibernate: insertinto t_user (born, password, username) values (?, ?, ?)
所以对离线对象，如果要使其变成持久化对象的话，我们不能使用save方法，而应当使用update方法
8.TestDetached02
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
session =HibernateUtil.openSession();
session.beginTransaction();
User u = new User();
u.setId(5);
//完成update以后也会变成持久化状态
session.update(u);
u.setBorn(sdf.parse("1998⑴2⑵2"));
u.setPassword("world");
u.setUsername("world");
//会发出1条sql
session.update(u);
session.getTransaction().commit();
此时我们看到，当调用了update方法以后，此时u已变成了1个持久化的对象，那末如果此时对u对象进行修改操作后，在事务提交的时候，则会拿该对象和session中刚保存的持久化对象进行比较，如果不同就发1条sql语句
Hibernate: updatet_user set born=?, password=?, username=? where id=?
9.TestDetached03
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
session =HibernateUtil.openSession();
session.beginTransaction();
User u = new User();
u.setId(5);
//完成update以后也会变成持久化状态
session.update(u);
u.setBorn(sdf.parse("1998⑴2⑵2"));
u.setPassword("lisi");
u.setUsername("lisi");
//会抛出异常
u.setId(333);
session.getTransaction().commit();
我们看这个例子，前面的操作1样，调用update方法后，user变成了1个持久化对象，在对user进行1些修改后，此时又通过u.setId(333)方法设置了u的ID，那末这个时候，hibernate会报错，由于我们的u当前已是1个持久化对象，如果试图修改1个持久化对象的ID的值的话，就会抛出异常，这点要特别注意
org.hibernate.HibernateException:identifier of an instance of com.xiaoluo.bean.User was altered from 5 to 333
10.TestDetached04
session = HibernateUtil.openSession();
session.beginTransaction();
User u = new User();
u.setId(5);
//现在u就是transient对象
session.delete(u);
//此时u已是瞬时对象，不会被session和http://www.wfuyu.com/db/所管理
u.setPassword("wangwu");
session.getTransaction().commit();
接着我们来看这个例子，这里在调用了session.delete()方法以后，此时后u就会变成1个瞬时对象，由于此时http://www.wfuyu.com/db/中已不存在该对象了，既然u已是1个瞬时对象了，那末对u再进行各种修改操作的话，hibernate也不会发送任何的修改语句，因此这里只会有1条
delete的语句产生：
Hibernate: deletefrom t_user where id=?
11.TestDetached05
session = HibernateUtil.openSession();
session.beginTransaction();
User u = new User();
u.setId(4);
u.setPassword("zhaoliu");
//如果u是离线状态就履行update操作，如果是瞬时状态就履行Save操作
//但是注意：该方法其实不经常使用
session.saveOrUpdate(u);
session.getTransaction().commit();
这里我们来看看saveOrUpdate这个方法，这个方法实际上是1个"偷懒"的方法，如果对象是1个离线对象，那末在履行这个方法后，实际上是调用了update方法，如果对象是1个瞬时对象，则会调用save方法，记住：如果对象设置了ID值，例如u.setId(4)，那末该对象会被假定当作1个离线对象，此时就会履行update操作。
<span style="font-size:24px;">Hibernate: updatet_user set born=?, password=?, username=? where id=?</span>
如果此时我将u.setId(4)这句话注释掉，那末此时u就是1个瞬时的对象，那末此时就会履行save操作，就会发送1条insert语句
Hibernate: insertinto t_user (born, password, username) values (?, ?, ?)
12.TestDetached06
session = HibernateUtil.openSession();
session.beginTransaction();
//u1已是持久化状态
User u1 =(User)session.load(User.class, 3);
System.out.println(u1.getUsername());
//u2是离线状态
User u2 = new User();
u2.setId(3);
u2.setPassword("123456789");
//此时u2将会变成持久化状态，在session的缓存中就存在了两份一样的对象,在session中不能存在两份拷贝，否则会抛出异常
session.saveOrUpdate(u2);
我们再来看1下这个例子，此时我们的u1已是持久化的对象了，保存在session缓存中，u2通过调用saveOrUpdate方法后也变成了1个持久化的对象，此时也会保存在session缓存中，这个时候session缓存中就存在了1个持久化对象有两个援用拷贝了，这个时候hibernate就会报错
<span style="font-size:24px;">org.hibernate.NonUniqueObjectException:a different object with the same identifier value was already associated withthe session: [com.xiaoluo.bean.User#3]</span>
1个session中不能存在对1个持久化对象的两重copy的，要解决这个方法，我们这里又要介绍session的另外一个方法 merge方法，这个方法的作用就是解决1个持久化对象两分拷贝的问题，这个方法会将两个对象合并在1起成为1个对象。
session = HibernateUtil.openSession();
session.beginTransaction();
//u1已是持久化状态
User u1 =(User)session.load(User.class, 3);
System.out.println(u1.getUsername());
//u2是离线状态
User u2 = new User();
u2.setId(3);
u2.setPassword("123456789");
//此时u2将会变成持久化状态，在session的缓存中就存在了两份一样的对象,在session中不能存在两份拷贝，否则会抛出异常
// session.saveOrUpdate(u2);
//merge方法会判断session中是不是已存在同1个对象，如果存在就将两个对象合并
session.merge(u2);
//最好实践：merge1般不用
session.getTransaction().commit();
我们看到通过调用了merge方法以后，此时会将session中的两个持久化对象合并为1个对象，但是merge方法不建议被使用
<span style="font-size:24px;">Hibernate: selectuser0_.id as id0_0_, user0_.born as born0_0_, user0_.password as password0_0_,user0_.username as username0_0_ from t_user user0_ where user0_.id=?
zhangsan
Hibernate: updatet_user set born=?, password=?, username=? where id=? </span>
4、总结
Hibernate3态瞬时态、持久态、游离态可谓是学习Hibernate的入门基础，只有对它们之间的转换理出头绪，才能在实战中发挥其最大优势。这才是刚刚开始，期待下1出好戏吧！
