session.flush()的使用

原文链接：http://blog.csdn.net/zhikun518/article/details/7705594

session flush在commit之前默认都会执行他。也可以手动执行它，他主要做了两件事：
1） 清理缓存。
2） 执行SQL。

session在什么情况下执行flush
* 默认在事务提交时
* 显示的调用flush
* 在执行查询前，如：iterate
hibernate按照save(insert),update、delete顺序提交相关操作

**********************************************************************
在下面的情况下，Hibernate会调用Session.flush()以清理缓存：
1)事务提交时如果flush模式不为FlushMode.NEVER,commit()将调用flush().
2)在某些查询语句之前（此查询语句之前的语句已经改变了数据库状态，所以需要调用flush（）以同步数据库是查出来的数据是经过更改的）。在调用Session.flush()时，涉及的SQL语句会按照下面的顺序执行。
（1所有的实体进行插入的语句，其顺序按照对象执行Session.save()的时间顺序。
（2）所有对实体进行更新的语句
（3）所有进行集合的删除语句
（4）所有对集合元素进行删除，更新或者插入的语句
（5）所有进行集合插入的语句
（6）所有对实体进行删除的语句，其顺序按照对象执行Session.delete()的时间顺序。（7）有一个例外是，如果对象使用native方式生成的ID（持久化标识），则他们一执行save就会被插入。除非明确地指定了flush（）命令，否则关于Session何时会执行这些JDBC调用完全是无法保证的，只能保证他们执行的前后顺序。

通过设置session.setFlushMode(),可以精确控制Hibernate的FlushMode.
(1)FlushMode.AUTO:Hibernate判断对象属性有没有改变，如果被更改成为脏数据，则在一个查询语句钱将更新此改动以保证数据库的同步。这也是Hibernate的默认清理模式。(2)FlushMode.COMMIT:在事务结束之前清理session的缓存.这样有可能导致查出脏数据
(3)FlushMode.NEVER：除非强制调用Session.flush(),否则永远不清理Session。想当于将数据库设置为一个只读的数据库。
(4) FlushMode.ALWAYS：在每一个查询数据之前都调用Session.flush()。很显然这种效率很低。
只用当使用触发器，或把Hibernate和JDBC混合使用，直接调用Session.flush()才是有意义的。


注意：
事物在没commit，即没提交之前是可以回滚的。

隔离级别 脏读 不可重复读 幻读 ReadUncommitted Y Y Y ReadCommitted N Y Y RepeatableRead N N Y Serializable N N N ReadCommited是oracle的默认隔离级别。可以通过悲观锁，消除不可重复读。 RepeatableRead是Mysql的默认级别。 数据库的隔离级别：(设置数据库的隔离级别是为了防止并发访问)这里有几个概念：脏读，不可重复读，幻读没有提交就可以读叫脏读。不可重复读是指第一次读的时候是张三，接着再读一次变为李四了，当重复读的时候出现了错误，叫不可重复读。可以使用悲观锁来锁住，别人修改不了
就可以避免不可重复读。幻读是指例如当查询年龄时查18到20，出现5条记录，当刷新一下就变成10条了，这叫幻读。
1》未提交读（Read uncommit）：即假如当在发出insert，但是还没执行commit就可以读，数据库中就已经存在，外部已经可以访问这个数据，这样是不安全的。这种使用的少。他存在脏读。也存在不可重复读和幻读。2》提交读（read commit）：即在提交之后（commit）才可以读。大部分数据库都是采用这种。oracle默认就是这个。这种情况下避免了脏读。存在不可重复读。也存在幻读。3》可重复读（repeatable read）：这个是Myswl的默认级别，只有提交了才可以读，即执行了commit之后才会在数据库中存在。他不存在不可重复读，因为当读一条记录的时候相当于加了悲观锁把锁，别人就读不到，故避免了不可重复读。但是幻读无法避免。4》序列化读（serialiaizble read）：这是最高隔离级别，这个是串行的，只有你执行完之后别人才可以执行，这个是用的很少。他没有脏读，没有不可重复读也没有幻读。从1到4是从低到高的。测试：

[java] view plain copy print ?

1. public class SessionFlushTest extends TestCase {   
2. /**  
3. * 测试uuid主键生成策略  
4. */   
5. public void testSave1() {   
6. Session session = null;   
7. Transaction tx = null;   
8. try {   
9. session = HibernateUtils.getSession();   
10. tx = session.beginTransaction();   
11.   
12. User1 user = new User1();   
13. user.setName("李四");   
14. user.setPassword("123");   
15. user.setCreateTime(new Date());   
16. user.setExpireTime(new Date());   
17. //因为user的主键生成侧路采用的是uuid，所以调用完成save后，只是将user纳入到了session的管理   
18. //不会发出insert语句，但是id已经生成，session中existsInDatebase状态为false   
19. session.save(user);   
20. //调用flush，hibernate会清理缓存，执行sql   
21. //如果数据库的隔离级别设置为为提交读，那么我们可以看到flush过的数据   
22. //并且session中existsInDatebase状态为true   
23. session.flush();   
24. //提交事务   
25. //默认情况下commit操作会先执行flush清理缓存，所以不用显示的调用flush   
26. //commit后数据是无法回滚的，没有commit，事物是可以回滚的   
27. tx.commit();   
28. }catch(Exception e) {   
29. e.printStackTrace();   
30. tx.rollback();   
31. }finally {   
32. HibernateUtils.closeSession(session);   
33. }   
34. }   
35. /**  
36. * 测试native主键生成策略  
37. */   
38. public void testSave2() {   
39. Session session = null;   
40. Transaction tx = null;   
41. try {   
42. session = HibernateUtils.getSession();   
43. tx = session.beginTransaction();   
44.   
45. User2 user = new User2();   
46. user.setName("张三1");   
47. user.setPassword("123");   
48. user.setCreateTime(new Date());   
49. user.setExpireTime(new Date());   
50. //因为user的主键生成策略为native,所以调用session.save后，将执行insert语句，返回有数据库生成的id   
51. //纳入了session的管理，修改了session中existsInDatebase状态为true   
52. //如果数据库的隔离级别设置为为提交读，那么我们可以看到save过的数据   
53. session.save(user);   
54. tx.commit();   
55. }catch(Exception e) {   
56. e.printStackTrace();   
57. tx.rollback();   
58. }finally {   
59. HibernateUtils.closeSession(session);   
60. }   
61. }   
62. /**  
63. * 测试uuid主键生成策略  
64. */   
65. public void testSave3() {   
66. Session session = null;   
67. Transaction tx = null;   
68. try {   
69. session = HibernateUtils.getSession();   
70. tx = session.beginTransaction();   
71.   
72. User1 user = new User1();   
73. user.setName("王五");   
74. user.setPassword("123");   
75. user.setCreateTime(new Date());   
76. user.setExpireTime(new Date());   
77. //因为user的主键生成侧路采用的是uuid，所以调用完成save后，只是将user纳入到了session的管理   
78. //不会发出insert语句，但是id已经生成，session中existsInDatebase状态为false   
79. session.save(user);   
80. //将user对象从session中逐出，即session的EntityEntries属性中逐出   
81. session.evict(user);   
82. //无法成功提交，因为hibernate在清理缓存时，在session的insertions集合中取出user对象进行insert操作后   
83. //需要更新entityEntries属性中的existsInDatabase为true，而我们采用evict已经将user从session的entityEntries  
84.  //中逐出了，所以找不到相关数据，无法更新，抛出异常   
85. tx.commit();   
86. }catch(Exception e) {   
87. e.printStackTrace();   
88. tx.rollback();   
89. }finally {   
90. HibernateUtils.closeSession(session);   
91. }   
92. }   
93. /**  
94. * 测试uuid主键生成策略  
95. */   
96. public void testSave4() {   
97. Session session = null;   
98. Transaction tx = null;   
99. try {   
100. session = HibernateUtils.getSession();   
101. tx = session.beginTransaction();   
102.   
103. User1 user = new User1();   
104. user.setName("王五");   
105. user.setPassword("123");   
106. user.setCreateTime(new Date());   
107. user.setExpireTime(new Date());   
108. //因为user的主键生成侧路采用的是uuid，所以调用完成save后，只是将user纳入到了session的管理   
109. //不会发出insert语句，但是id已经生成，session中existsInDatebase状态为false   
110. session.save(user);   
111. //flush后hibernate会清理缓存，会将user对象保存到数据库中，将session中的insertions中的user对象   
112. //清除，并且设置session中existsInDatebase的状态为true   
113. session.flush();   
114. //将user对象从session中逐出，即session的EntityEntries属性中逐出   
115. session.evict(user);   
116. //可以成功提交，因为hibernate在清理缓存时，在session的insertions集合中无法找到user对象   
117. //所以就不会发出insert语句，也不会更新session中的existsInDatabase的状态   
118. tx.commit();   
119. }catch(Exception e) {   
120. e.printStackTrace();   
121. tx.rollback();   
122. }finally {   
123. HibernateUtils.closeSession(session);   
124. }   
125. }   
126. /**  
127. * 测试native主键生成策略  
128. */   
129. public void testSave5() {   
130. Session session = null;   
131. Transaction tx = null;   
132. try {   
133. session = HibernateUtils.getSession();   
134. tx = session.beginTransaction();   
135.   
136. User2 user = new User2();   
137. user.setName("张三11");   
138. user.setPassword("123");   
139. user.setCreateTime(new Date());   
140. user.setExpireTime(new Date());   
141. //因为user的主键生成策略为native,所以调用session.save后，将执行insert语句，返回有数据库生成的id   
142. //纳入了session的管理，修改了session中existsInDatebase状态为true   
143. //如果数据库的隔离级别设置为为提交读，那么我们可以看到save过的数据   
144. session.save(user);   
145. //将user对象从session中逐出，即session的EntityEntries属性中逐出   
146. session.evict(user);   
147. //可以成功提交，因为hibernate在清理缓存时，在session的insertions集合中无法找到user对象   
148. //所以就不会发出insert语句，也不会更新session中的existsInDatabase的状态   
149. tx.commit();   
150. }catch(Exception e) {   
151. e.printStackTrace();   
152. tx.rollback();   
153. }finally {   
154. HibernateUtils.closeSession(session);   
155. }   
156. }   
157. /**  
158. * 测试assigned主键生成策略  
159. *  
160. */   
161. public void testSave6() {   
162. Session session = null;   
163. Transaction tx = null;   
164. try {   
165. session = HibernateUtils.getSession();   
166. tx = session.beginTransaction();   
167.   
168. User3 user = new User3();   
169. user.setId("001");   
170. user.setName("张三");   
171. session.save(user);   
172. user.setName("王五");   
173. session.update(user);   
174. User3 user3 = new User3();   
175. user3.setId("002");   
176. user3.setName("李四");   
177. session.save(user3);   
178. //Hibernate: insert into t_user3 (name, password, create_time, expire_time, user_id) values (?, ?, ?, ?, ?)  
179.  //Hibernate: insert into t_user3 (name, password, create_time, expire_time, user_id) values (?, ?, ?, ?, ?)  
180.  //Hibernate: update t_user3 set name=?, password=?, create_time=?, expire_time=? where user_id=?  
181.  //hibernate按照save(insert),update、delete顺序提交相关操作   
182. tx.commit();   
183. }catch(Exception e) {   
184. e.printStackTrace();   
185. tx.rollback();   
186. }finally {   
187. HibernateUtils.closeSession(session);   
188. }   
189. }   
190.   
191. /**  
192. * 测试assigned主键生成策略  
193. *  
194. */   
195. public void testSave7() {   
196. Session session = null;   
197. Transaction tx = null;   
198. try {   
199. session = HibernateUtils.getSession();   
200. tx = session.beginTransaction();   
201.   
202. User3 user = new User3();   
203. user.setId("003");   
204. user.setName("张三");   
205. session.save(user);   
206. user.setName("王五");   
207. session.update(user);   
208. session.flush();   
209. User3 user3 = new User3();   
210. user3.setId("004");   
211. user3.setName("李四");   
212. session.save(user3);   
213. //Hibernate: insert into t_user3 (name, password, create_time, expire_time, user_id) values (?, ?, ?, ?, ?)  
214.  //Hibernate: update t_user3 set name=?, password=?, create_time=?, expire_time=? where user_id=?  
215.  //Hibernate: insert into t_user3 (name, password, create_time, expire_time, user_id) values (?, ?, ?, ?, ?)  
216.  //因为我们在session.udpate(user)后执行了flush，所以在清理缓存时执行flush前的sql不会生成   
217. //sql会按照我们的意愿执行   
218. tx.commit();   
219. }catch(Exception e) {   
220. e.printStackTrace();   
221. tx.rollback();   
222. }finally {   
223. HibernateUtils.closeSession(session);   
224. }   
225. }   
226.   
227. }