session.flush()与session.clear()有什么区别

admin

Session Clear（）与 Flush（） 解释
0 B! H) c8 N! M/ U- N1.Clear 方法
+ s6 v5 M( t. m# W3 s! [/ q; T7 ^  无论是Load 还是 Get 都会首先查找缓存（一级缓存） 如果没有，才会去数据库查找，调用Clear() 方法，可以强制清除Session缓存。
- R: g7 U3 b' R: ?) A& u例：

1. public void testClear(){
   1 S$ f& M. d7 U2 ?. C  N2 A
2.                 Session session =  hibernateUitl.getSessionFactory().getCurrentSession();
   
3.                 session.beginTransaction();
   + U; X8 x) r. d7 ?3 z
4.                 Teacher t = (Teacher) session.get(Teacher.class, 3);
   3 x0 }9 t' {, a; L% `8 g' V" U& O2 q% a
5.                 System.out.println(t.getName());
   
6.                 Teacher t2 = (Teacher) session.get(Teacher.class, 3);
   
7.                 System.out.println(t2.getName());
   
8.                 session.getTransaction().commit();
   0 H' L/ }7 F6 B8 ]# s' j
9.         }
   ; h" h/ c% p; ~& A! |

复制代码

这里虽然用了2个get方法（get方法会立即执行sql语句），但因为第一次执行了会缓存一个ID为3的实体，所以虽然有2个get方法只执行一次SQL语句。
$ K) r6 Q' o' D; j. ?6 C

1. public void testClear(){
   
2.                 Session session =  HibernateUitl.getSessionFactory().getCurrentSession();
   
3.                 session.beginTransaction();
   1 Y; o  |5 P) B5 b8 Z
4.                 Teacher t = (Teacher) session.get(Teacher.class, 3);
   0 E+ F. A- A6 K& T
5.                 System.out.println(t.getName());
   . u. |/ o8 S) [' q9 s
6.                 session.clear();//这里不clear只会执行一次sql语句，有clear会执行2次
   ' V3 c. O. B- D' w
7.                 Teacher t2 = (Teacher) session.get(Teacher.class, 3);
   
8.                 System.out.println(t2.getName());
   
9.                 session.getTransaction().commit();
   
10.         }
    ( U! X" y' S2 `/ c+ b' b

复制代码

# u' W* K  Q6 v+ E: V! v& M, N& A/ I这里在第2次get前执行session.clear(),我们把hibernate show_sql 出来，它就会执行2次sql语句了。
所以session.clear()会清除缓存。
8 T" f: |3 |5 b. r4 v& B2.Flush方法
# `6 `) x  L3 ?# c; H; x; L: X  可以强制进行从内存到数据库的同步。
例：
9 N4 ^* ^! P) V% H# f

1. @Test
   
2.         /**
   ) K/ l8 B6 W+ u! _7 a, u
3.          * flush 强制与数据库同步
   7 ]' i) l4 t1 g! w
4.          */
   
5.         public void testFlush(){
   / B2 o- y7 [# H) I; P$ \
6.                 Session session =  HibernateUitl.getSessionFactory().getCurrentSession();
   
7.                 session.beginTransaction();
   3 ]7 a7 ?4 N0 L* V2 B1 v# D
8.                 Teacher t = (Teacher) session.get(Teacher.class, 3);
   ; Q% q) ]+ |; |3 p
9.                 t.setName("yyy");
   
10. 
    
11.                 t.setName("yyyyy");
    
12.                 session.getTransaction().commit();
    * _5 F+ [( A( x  E5 G" }- P
13.         }
    
14. 
    
15. 
    * a" {( X$ L# C" t$ ?; u

复制代码

看这段代码，我们setName() 2次， 但程序只会更改数据库一次，在commit时。
2 z# y5 A5 \9 D$ j$ a

1. @Test
   ; N0 J, P, T6 \+ @2 l. E- _1 k- T
2.         /**
   / z) Y# ^* ?4 w4 O; X6 `
3.          * flush 强制与数据库同步
   
4.          */
   
5.         public void testFlush(){
   
6.                 Session session =  HibernateUitl.getSessionFactory().getCurrentSession();
   ) y" G; S* p2 y5 E& u% A
7.                 session.beginTransaction();
   
8.                 Teacher t = (Teacher) session.get(Teacher.class, 3);
   + h' l$ [1 _% J4 r: l
9.                 t.setName("yyy");
   
10.                 session.flush();//有flush会执行2次UPDAE,没有会只执行一次
    
11.                 t.setName("yyyyy");
    
12.                 session.getTransaction().commit();
    & K& N% p7 E- a
13.         }
    
14. 
    ' V9 Y  P, a& M/ `& ?" ?% n# I2 V
15. 
    % p1 C; v( Z. h# f7 o# B0 a# x

复制代码

1 x4 s# `" p6 r6 g- ]* h% D
; E5 j) z* s6 i# p. f我们在第2次setName（）时 执行session.flush().
8 x) C9 i/ P% s: K/ O再看hibernate 执行的sql 语句

1. Hibernate:
   
2.     update
   0 }! ~! }( u5 C3 l
3.         Teacher
   
4.     set
   
5.         birthday=?,
   
6.         name=?,
   9 r+ P' _6 @; _% G4 m" F
7.         title=?
   
8.     where
   
9.         id=?
   
10. Hibernate:
    
11.     update
    & _& t0 H2 z. }7 G, l0 P+ I
12.         Teacher
    
13.     set
    
14.         birthday=?,
    5 t1 q/ q" Y. b0 n
15.         name=?,
      C0 h) X9 D! E( h
16.         title=?
    
17.     where
    . n' I2 U' r" d* A7 a2 B
18.         id=?
    " ]2 j3 ~4 V  H# j1 X" T; ^( w
19. 
    * O, ]6 E1 K$ ?' t3 E0 d
20. 
    : x" c9 |9 r& y! c6 O5 G2 H- P

复制代码

3 P$ G( L7 z% L+ M/ p执行了2次Update

所以看出来flush方法会强制与数据库同步。

( {6 E4 ~+ V  z
Flush方法是可以设置的，也就是fulsh什么时候执行是可以设置的
: @7 p! r, l+ L, }
在session.beginTransaction前设置FlushMode

, D' B' k' _8 @" ?& C$ Ksession.setFlushMode(FlushMode.Always|AUTO|COMMIT|NEVER|MANUAL)

$ e8 f8 j/ }2 D1 G- kFlushMode有5个值可选

Always:任何代码都会Flush
AUTO:默认方式–自动
Commit:COMMIT时
! K! d6 y) X. k% A& R; ZNever:始终不
/ B, _5 y4 T! Y" O2 M2 g4 \: l8 J  EMANUAL:手动方式
; E- x8 C: k" I$ s' O
, _0 t& }, g7 l$ U0 |设置FlushMode 有个好处是可以节省开销，比如默认session只做查询时，就可以不让他与数据库同步了。
4 p/ i5 \9 Z9 j; u+ W================================================================
我说一下一些需要注意的信息：
7 P9 c4 r: |, s0 \9 W
4 g6 v- M  Y! M2 ^' |- t# _1 session.clear()的作用是只清除session中的缓存数据，但不管缓存与数据库的同步。
, O7 l" S! a$ p* Y  K8 X% l
比如，你执行了
* M9 c* h/ L' z4 E. i
+ i1 q* z7 g6 R& s3 [' f- d! sPo po = new Po();
) s6 P7 a7 S0 osession.save(po),

之后马上执行session.clear()，在事务结束的时候，这条数据是不会被持久化到数据库中的，因为一般缓存是在事务提交的时候进行清理的，当在清理缓存前就把缓存给清除了，自然就不会同步到数据库了。不过这个也有例外的情况，就是当对象使用native生成器来生成主键id时，当执行session.save()方法时,就会立马往数据库插入一条数据，这时候执行session.clear()也不会影响了。
0 s' I6 e- R1 R7 Z6 \6 Y( x  a
* g& N  \3 z) j% k- o, ~2 当更新或者保存大批量数据的时候，可以每固定数量的时候，进行清理缓存，同时清除缓存：
' S% Y$ N4 ]) r( m/ [- K
for (int i = 0; i < 1000;i ++){
2 R7 V! d+ d8 j. M6 Q) v
if (i /20 == 0) {

  session.flush();

  session.clear();
% F" y4 g# b2 f9 h& m8 {" f. d}
}
  |& @/ T5 F6 P
因为把大量的对象放到session缓存中会浪费大量的内容空间。


3 执行完session.flush()时，并不意味着数据就肯定持久化到数据库中的，因为事务控制着数据库，如果事务提交失败了，缓存中的数据还是照样会被回滚的。
+ H5 Z' n; f/ j& w

$ L. e7 A1 d, A1 O7 ?. N$ |