hibernate-3态

一、概况

       （一）瞬时状态（临时态）

        在对象中如果对象刚被创建但没有被持久化的话就是瞬时态

特点：

   (1) 不和 Session 实例关联

   (2)在数据库中没有和瞬时对象关联的记录

       （二）持久状态

   持久化对象就是已经被保存进数据库的实体对象，并且这个实体对象现在还处于Hibernate的Session缓存管理之中。这时对该实体对象的任何修改，都会在清理缓存时同步到数据库中。

特点：

   （1）持久的实例在数据库中有对应的记录，并拥有一个持久化标识(identifier).

   （2）和session相关联的对象

       （三）游离状态（托管状态、离线状态）

       当一个持久化对象，脱离开Hibernate的缓存管理后，它就处于游离状态，游离对象和自由对象的最大区别在于，游离对象在数据库中可能还存在一条与它对应的记录，只是现在这个游离对象脱离了Hibernate的缓存管理，而自由对象不会在数据库中出现与它对应的数据记录。

特点：

   (1) 本质上和瞬时对象相同

   (2)只是比瞬时对象多了一个数据库记录标识值id。

二、转化图

         通过以下的转换图就可以明白三态之间是如何转换的，如果将这幅图印在自己的脑子里，三态就没什么神圣的啦！

    

三、实战

       以上是对三态理论知识上的讲解，那么接下来就从实际代码中体验一下它们的奥妙吧！

1.TestTransient　　

[java] view plaincopyprint?

1. session = HibernateUtil.openSession();  
2.        session.beginTransaction();  
3.        User user = new User();  
4.        user.setUsername("aaa");  
5.        user.setPassword("aaa");  
6.        user.setBorn(new Date());  
7.        /* 
8.         * 以上user就是一个Transient(瞬时状态),此时user并没有被session进行托管，即在session的 
9.         * 缓存中还不存在user这个对象，当执行完save方法后，此时user被session托管，并且数据库中存在了该对象 
10.         * user就变成了一个Persistent(持久化对象) 
11.         */  
12.        session.save(user);  
13.        session.getTransaction().commit();  

       此时我们知道hibernate会发出一条insert的语句，执行完save方法后，该user对象就变成了持久化的对象了

[java] view plaincopyprint?

1. Hibernate: insertinto t_user (born, password, username) values (?, ?, ?)  

2.TestPersistent01

　　　　　

[java] view plaincopyprint?

1. session = HibernateUtil.openSession();  
2.            session.beginTransaction();  
3.            User user = new User();  
4.            user.setUsername("aaa");  
5.            user.setPassword("aaa");  
6.            user.setBorn(new Date());  
7.            //以上u就是Transient（瞬时状态），表示没有被session管理并且数据库中没有  
8.            //执行save之后，被session所管理，而且，数据库中已经存在，此时就是Persistent状态  
9.            session.save(user);  
10.            //此时u是持久化状态，已经被session所管理，当在提交时，会把session中的对象和目前的对象进行比较  
11.            //如果两个对象中的值不一致就会继续发出相应的sql语句  
12.            user.setPassword("bbb");  
13.            //此时会发出2条sql，一条用户做插入，一条用来做更新  
14.            session.getTransaction().commit();  

       在调用了save方法后，此时user已经是持久化对象了，被保存在了session缓存当中，这时user又重新修改了属性值，那么在提交事务时，此时hibernate对象就会拿当前这个user对象和保存在session缓存中的user对象进行比较，如果两个对象相同，则不会发送update语句，否则，如果两个对象不同，则会发出update语句。

 

[java] view plaincopyprint?

1. Hibernate: insertinto t_user (born, password, username) values (?, ?, ?)  
2. Hibernate: updatet_user set born=?, password=?, username=? where id=?  

3.TestPersistent02

　　　　　

[java] view plaincopyprint?

1. SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");  
2.            session =HibernateUtil.openSession();  
3.            session.beginTransaction();  
4.            User u = new User();  
5.            u.setBorn(new Date());  
6.           u.setUsername("zhangsan");  
7.           u.setPassword("zhangsan");  
8.            session.save(u);  
9.            u.setPassword("222");  
10.            //该条语句没有意义  
11.            session.save(u);  
12.           u.setPassword("zhangsan111");  
13.            //没有意义  
14.            session.update(u);  
15.           u.setBorn(sdf.parse("1988-12-22"));  
16.            //没有意义  
17.            session.update(u);  
18.            session.getTransaction().commit();  

        这个时候会发出多少sql语句呢？还是同样的道理，在调用save方法后，u此时已经是持久化对象了，记住一点：如果一个对象以及是持久化状态了，那么此时对该对象进行各种修改，或者调用多次update、save方法时，hibernate都不会发送sql语句，只有当事物提交的时候，此时hibernate才会拿当前这个对象与之前保存在session中的持久化对象进行比较，如果不相同就发送一条update的sql语句，否则就不会发送update语句

 

[java] view plaincopyprint?

1. Hibernate: insertinto t_user (born, password, username) values (?, ?, ?)  
2. Hibernate: updatet_user set born=?, password=?, username=? where id=?  

4.TestPersistent03

　　　　　　

[java] view plaincopyprint?

1. SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");  
2.             session =HibernateUtil.openSession();  
3.             session.beginTransaction();  
4.             User u = new User();  
5.            u.setBorn(sdf.parse("1976-2-3"));  
6.            u.setUsername("zhangsan2");  
7.            u.setPassword("zhangsan2");  
8.             session.save(u);  
9.             /* 
10.              * 以下三条语句没有任何意义 
11.              */  
12.             session.save(u);  
13.             session.update(u);  
14.             session.update(u);  
15.            u.setUsername("zhangsan3");  
16.             session.getTransaction().commit();  

       相信这个测试用例，大家应该都知道结果了，没错，此时hibernate也会发出两条sql语句，原理一样的

 

[java] view plaincopyprint?

1. Hibernate: insertinto t_user (born, password, username) values (?, ?, ?)  
2. Hibernate: updatet_user set born=?, password=?, username=? where id=?  

5.TestPersistent04

　　　　　

[java] view plaincopyprint?

1. session = HibernateUtil.openSession();  
2.            session.beginTransaction();  
3.            //此时u是Persistent  
4.            User u =(User)session.load(User.class, 4);  
5.            //由于u这个对象和session中的对象不一致，所以会发出sql完成更新  
6.            u.setUsername("bbb");  
7.            session.getTransaction().commit();  

       我们来看看此时会发出多少sql语句呢？同样记住一点：当session调用load、get方法时，此时如果数据库中有该对象，则该对象也变成了一个持久化对象，被session所托管。因此，这个时候如果对对象进行操作，在提交事务时同样会去与session中的持久化对象进行比较，因此这里会发送两条sql语句

 

[java] view plaincopyprint?

1. 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=?  
2. Hibernate: updatet_user set born=?, password=?, username=? where id=?  

6.TestPersistent05

　　　　　

[java] view plaincopyprint?

1. session = HibernateUtil.openSession();  
2.            session.beginTransaction();  
3.            //此时u是Persistent  
4.            User u =(User)session.load(User.class, 4);  
5.            u.setUsername("123");  
6.            //清空session  
7.            session.clear();  
8.            session.getTransaction().commit();  

       再看这个例子，当我们load出user对象时，此时user是持久化的对象，在session缓存中存在该对象，此时我们在对user进行修改后，然后调用session.clear()方法，这个时候就会将session的缓存对象清空，那么session中就没有了user这个对象，这个时候在提交事务的时候，发现已经session中已经没有该对象了，所以就不会进行任何操作，因此这里只会发送一条select语句

 

[java] view plaincopyprint?

1. 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

　　　　　　

[java] view plaincopyprint?

1. session = HibernateUtil.openSession();  
2.             session.beginTransaction();  
3.             //此时u是一个离线对象，没有被session托管  
4.             User u = new User();  
5.             u.setId(4);  
6.            u.setPassword("hahahaha");  
7.             //当执行save的时候总是会添加一条数据，此时id就会根据Hibernate所定义的规则来生成  
8.             session.save(u);  
9.             session.getTransaction().commit();  

       我们看到，当调用了u.setId(4)时，此时u是一个离线的对象，因为数据库中存在id=4的这个对象，但是该对象又没有被session所托管，所以这个对象就是离线的对象，要使离线对象变成一个持久化的对象，应该调用什么方法呢？我们知道调用save方法，可以将一个对象变成一个持久化对象，但是，当save一执行的时候，此时hibernate会根据id的生成策略往数据库中再插入一条数据，所以如果调用save方法，此时数据库会发送一条插入的语句：

 

[java] view plaincopyprint?

1. Hibernate: insertinto t_user (born, password, username) values (?, ?, ?)  

所以对于离线对象，如果要使其变成持久化对象的话，我们不能使用save方法，而应该使用update方法

 

8.TestDetached02

　　　　　

[java] view plaincopyprint?

1. SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");  
2.            session =HibernateUtil.openSession();  
3.            session.beginTransaction();  
4.            User u = new User();  
5.            u.setId(5);  
6.            //完成update之后也会变成持久化状态  
7.            session.update(u);  
8.           u.setBorn(sdf.parse("1998-12-22"));  
9.            u.setPassword("world");  
10.            u.setUsername("world");  
11.            //会发出一条sql  
12.            session.update(u);  
13.            session.getTransaction().commit();  

       此时我们看到，当调用了update方法以后，此时u已经变成了一个持久化的对象，那么如果此时对u对象进行修改操作后，在事务提交的时候，则会拿该对象和session中刚保存的持久化对象进行比较，如果不同就发一条sql语句

 

[java] view plaincopyprint?

1. Hibernate: updatet_user set born=?, password=?, username=? where id=?  

9.TestDetached03

　　　　　　

[java] view plaincopyprint?

1. SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");  
2.             session =HibernateUtil.openSession();  
3.             session.beginTransaction();  
4.             User u = new User();  
5.             u.setId(5);  
6.             //完成update之后也会变成持久化状态  
7.             session.update(u);  
8.            u.setBorn(sdf.parse("1998-12-22"));  
9.             u.setPassword("lisi");  
10.             u.setUsername("lisi");  
11.             //会抛出异常  
12.             u.setId(333);  
13.             session.getTransaction().commit();  

       我们看这个例子，前面的操作一样，调用update方法后，user变成了一个持久化对象，在对user进行一些修改后，此时又通过u.setId(333)方法设置了u的ID，那么这个时候，hibernate会报错，因为我们的u当前已经是一个持久化对象，如果试图修改一个持久化对象的ID的值的话，就会抛出异常，这点要特别注意

 

[java] view plaincopyprint?

1. org.hibernate.HibernateException:identifier of an instance of com.xiaoluo.bean.User was altered from 5 to 333  

10.TestDetached04

　　　　　

[java] view plaincopyprint?

1. session = HibernateUtil.openSession();  
2.            session.beginTransaction();  
3.            User u = new User();  
4.            u.setId(5);  
5.            //现在u就是transient对象  
6.            session.delete(u);  
7.            //此时u已经是瞬时对象，不会被session和数据库所管理  
8.            u.setPassword("wangwu");  
9.            session.getTransaction().commit();  

       接着我们来看这个例子，这里在调用了session.delete()方法以后，此时后u就会变成一个瞬时对象，因为此时数据库中已经不存在该对象了，既然u已经是一个瞬时对象了，那么对u再进行各种修改操作的话，hibernate也不会发送任何的修改语句，因此这里只会有一条 delete的语句发生：

 

[java] view plaincopyprint?

1. Hibernate: deletefrom t_user where id=?  

11.TestDetached05

　　　　　

[java] view plaincopyprint?

1. session = HibernateUtil.openSession();  
2.            session.beginTransaction();  
3.            User u = new User();  
4.            u.setId(4);  
5.            u.setPassword("zhaoliu");  
6.            //如果u是离线状态就执行update操作，如果是瞬时状态就执行Save操作  
7.            //但是注意：该方法并不常用  
8.            session.saveOrUpdate(u);  
9.            session.getTransaction().commit();  

       这里我们来看看saveOrUpdate这个方法，这个方法其实是一个"偷懒"的方法，如果对象是一个离线对象，那么在执行这个方法后，其实是调用了update方法，如果对象是一个瞬时对象，则会调用save方法，记住：如果对象设置了ID值，例如u.setId(4)，那么该对象会被假设当作一个离线对象，此时就会执行update操作。

 

[java] view plaincopyprint?

1. <span style="font-size:24px;">Hibernate: updatet_user set born=?, password=?, username=? where id=?</span>  

如果此时我将u.setId(4)这句话注释掉，那么此时u就是一个瞬时的对象，那么此时就会执行save操作，就会发送一条insert语句

 

[java] view plaincopyprint?

1. Hibernate: insertinto t_user (born, password, username) values (?, ?, ?)  

12.TestDetached06

　　　　　

[java] view plaincopyprint?

1. session = HibernateUtil.openSession();  
2.            session.beginTransaction();  
3.            //u1已经是持久化状态  
4.            User u1 =(User)session.load(User.class, 3);  
5.           System.out.println(u1.getUsername());  
6.            //u2是离线状态  
7.            User u2 = new User();  
8.            u2.setId(3);  
9.           u2.setPassword("123456789");  
10.            //此时u2将会变成持久化状态，在session的缓存中就存在了两份同样的对象,在session中不能存在两份拷贝，否则会抛出异常  
11.            session.saveOrUpdate(u2);  

        我们再来看一下这个例子，此时我们的u1已经是持久化的对象了，保存在session缓存中，u2通过调用saveOrUpdate方法后也变成了一个持久化的对象，此时也会保存在session缓存中，这个时候session缓存中就存在了一个持久化对象有两个引用拷贝了，这个时候hibernate就会报错

 

[java] view plaincopyprint?

1. <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>  

一个session中不能存在对一个持久化对象的双重copy的，要解决这个方法，我们这里又要介绍session的另一个方法 merge方法，这个方法的作用就是解决一个持久化对象两分拷贝的问题，这个方法会将两个对象合并在一起成为一个对象。

　　　　　　

[java] view plaincopyprint?

1. session = HibernateUtil.openSession();  
2.             session.beginTransaction();  
3.             //u1已经是持久化状态  
4.             User u1 =(User)session.load(User.class, 3);  
5.            System.out.println(u1.getUsername());  
6.             //u2是离线状态  
7.             User u2 = new User();  
8.             u2.setId(3);  
9.            u2.setPassword("123456789");  
10.             //此时u2将会变成持久化状态，在session的缓存中就存在了两份同样的对象,在session中不能存在两份拷贝，否则会抛出异常  
11. //            session.saveOrUpdate(u2);  
12.             //merge方法会判断session中是否已经存在同一个对象，如果存在就将两个对象合并  
13.             session.merge(u2);  
14.             //最佳实践：merge一般不用  
15.             session.getTransaction().commit();  

       我们看到通过调用了merge方法以后，此时会将session中的两个持久化对象合并为一个对象，但是merge方法不建议被使用

[java] view plaincopyprint?

1. <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=?  
2. zhangsan  
3. Hibernate: updatet_user set born=?, password=?, username=? where id=? </span>  

四、总结

         Hibernate三态瞬时态、持久态、游离态可谓是学习Hibernate的入门基础，只有对它们之间的转换理出头绪，才能在实战中发挥其最大优势。这才是刚刚开始，期待下一出好戏吧！