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

admin

Session Clear（）与 Flush（） 解释
6 G# w- l- c: W& N& P- y* H! a1.Clear 方法
  无论是Load 还是 Get 都会首先查找缓存（一级缓存） 如果没有，才会去数据库查找，调用Clear() 方法，可以强制清除Session缓存。
例：

1. public void testClear(){
   8 }. X- S9 \) t; m& `
2.                 Session session =  hibernateUitl.getSessionFactory().getCurrentSession();
   / o9 ^# I/ a2 e- u  A+ `- M/ l
3.                 session.beginTransaction();
   
4.                 Teacher t = (Teacher) session.get(Teacher.class, 3);
   , z3 r, i- j- s( W. ^( Y
5.                 System.out.println(t.getName());
   
6.                 Teacher t2 = (Teacher) session.get(Teacher.class, 3);
   ( w, J& M' x$ q& H+ v9 U
7.                 System.out.println(t2.getName());
   0 i) d4 c5 d) E7 _( S
8.                 session.getTransaction().commit();
   + S; g& e. ?9 E
9.         }
   

复制代码

这里虽然用了2个get方法（get方法会立即执行sql语句），但因为第一次执行了会缓存一个ID为3的实体，所以虽然有2个get方法只执行一次SQL语句。
0 W+ K$ b0 k$ P

1. public void testClear(){
   
2.                 Session session =  HibernateUitl.getSessionFactory().getCurrentSession();
   
3.                 session.beginTransaction();
   
4.                 Teacher t = (Teacher) session.get(Teacher.class, 3);
   ! s( w/ M5 O6 V  |7 B
5.                 System.out.println(t.getName());
   
6.                 session.clear();//这里不clear只会执行一次sql语句，有clear会执行2次
   3 M1 `: E" A0 V
7.                 Teacher t2 = (Teacher) session.get(Teacher.class, 3);
   
8.                 System.out.println(t2.getName());
   7 G0 H' l8 G6 e! ]% ~
9.                 session.getTransaction().commit();
   
10.         }
    $ u+ h; J2 A  h0 G5 t

复制代码

5 O, P1 |0 j' a1 N这里在第2次get前执行session.clear(),我们把hibernate show_sql 出来，它就会执行2次sql语句了。
. l/ O2 `5 O% \所以session.clear()会清除缓存。
2.Flush方法
  可以强制进行从内存到数据库的同步。
例：
/ b) y0 ]- f' q& k3 w

1. @Test
   ' B0 L+ g5 s* o+ e* H
2.         /**
   % B: D( {! h' P
3.          * flush 强制与数据库同步
   - y  v: B* }9 ?
4.          */
   
5.         public void testFlush(){
   8 `' n) [+ c6 E0 x. x$ {2 c: F
6.                 Session session =  HibernateUitl.getSessionFactory().getCurrentSession();
   $ q$ q  i/ O( P. O+ n
7.                 session.beginTransaction();
   1 X1 \2 A: L: Z1 I1 C1 F
8.                 Teacher t = (Teacher) session.get(Teacher.class, 3);
   
9.                 t.setName("yyy");
   7 W# l$ L! b! s3 A! r5 q
10. 
    
11.                 t.setName("yyyyy");
    # h' ^' }0 G+ S. ]& q6 c! T  Z% H; j
12.                 session.getTransaction().commit();
    % }* E& u" g" f& `6 P# k# X% G
13.         }
    
14. 
    * h" H$ h. ~  J; |0 \  E% f+ N
15. 
    

复制代码

看这段代码，我们setName() 2次， 但程序只会更改数据库一次，在commit时。

1. @Test
   
2.         /**
   
3.          * flush 强制与数据库同步
   . n8 B- U; A4 l; t8 v
4.          */
   
5.         public void testFlush(){
   $ t* C! W& x( s+ C- c0 S2 [
6.                 Session session =  HibernateUitl.getSessionFactory().getCurrentSession();
   , R" ?. v# K/ U1 R
7.                 session.beginTransaction();
   
8.                 Teacher t = (Teacher) session.get(Teacher.class, 3);
   , y5 X2 o, l3 p9 u7 H! c
9.                 t.setName("yyy");
   1 E$ E$ H# H) }& T
10.                 session.flush();//有flush会执行2次UPDAE,没有会只执行一次
    
11.                 t.setName("yyyyy");
    
12.                 session.getTransaction().commit();
    5 l# \* r6 F( j2 P0 ^! e  A7 ^# i
13.         }
    9 p% x: U) w3 E' w) |; F
14. 
    
15. 
    

复制代码

% p: h0 U5 A( G+ g& U  u
我们在第2次setName（）时 执行session.flush().
- R* b2 {& j2 O6 Z( c; `再看hibernate 执行的sql 语句
) q, ^+ d5 M( A. z9 I; l

1. Hibernate:
   
2.     update
   
3.         Teacher
   
4.     set
   
5.         birthday=?,
   ; U2 N: A* h' t
6.         name=?,
   
7.         title=?
   
8.     where
   0 A( K1 r, w" g3 x
9.         id=?
   - `( ]0 H, ^6 b
10. Hibernate:
    5 z5 ^2 j. t- C! r4 ~
11.     update
    & m# E. H2 |! x, k
12.         Teacher
    
13.     set
    
14.         birthday=?,
    
15.         name=?,
    9 d, u5 K; k3 f6 q& z5 E
16.         title=?
      T; g- h& `4 w- E2 x6 i
17.     where
    
18.         id=?
    
19. 
      j% e* Y7 m2 f( j9 T$ D' i
20. 
    1 y; [) ~9 r3 X8 o/ x! n: B

复制代码

  y6 L) D% ^. E& n6 f
5 V0 q% T: b' n0 G9 C3 ~7 U执行了2次Update
) X# f" b4 o, |# m& J) x* Z
- N- F) p" k" O' Q! W( ~所以看出来flush方法会强制与数据库同步。
( |9 P$ h% O% `% }6 {
" ?% Z$ Y) x( O7 B0 l, \) I. P6 C
Flush方法是可以设置的，也就是fulsh什么时候执行是可以设置的

在session.beginTransaction前设置FlushMode
, P8 }0 P$ H* E$ [9 t8 J2 X. w  M
session.setFlushMode(FlushMode.Always|AUTO|COMMIT|NEVER|MANUAL)

. D8 k2 Q* ^1 ]8 GFlushMode有5个值可选

$ `+ c  {8 |7 T2 ]$ \1 tAlways:任何代码都会Flush
  E9 N: t" C( u! X, \9 W5 bAUTO:默认方式–自动
Commit:COMMIT时
Never:始终不
: z; @9 n, j* R. E- q" k, R2 JMANUAL:手动方式
7 T5 p' Y: v4 D. f+ r
1 M* c# [( X5 X  E; F设置FlushMode 有个好处是可以节省开销，比如默认session只做查询时，就可以不让他与数据库同步了。
================================================================
我说一下一些需要注意的信息：

1 session.clear()的作用是只清除session中的缓存数据，但不管缓存与数据库的同步。
4 z, A- ?/ b8 Z+ y8 F4 e
2 J; `2 B& s! ?4 p比如，你执行了
% R8 [! n  ^- Y+ u
Po po = new Po();
  {8 |% W# f! C; esession.save(po),

之后马上执行session.clear()，在事务结束的时候，这条数据是不会被持久化到数据库中的，因为一般缓存是在事务提交的时候进行清理的，当在清理缓存前就把缓存给清除了，自然就不会同步到数据库了。不过这个也有例外的情况，就是当对象使用native生成器来生成主键id时，当执行session.save()方法时,就会立马往数据库插入一条数据，这时候执行session.clear()也不会影响了。
. l) C; U# m# Y. H: ^2 t8 M+ M: T
' `9 M* z+ p4 l+ Z( v2 当更新或者保存大批量数据的时候，可以每固定数量的时候，进行清理缓存，同时清除缓存：
. ], \# w+ k4 ]( x2 @6 k
for (int i = 0; i < 1000;i ++){

: S: `' p0 X: _if (i /20 == 0) {
5 y: e+ S$ r8 N) U
  session.flush();
( [% P% g" J1 P  W# z; @" N
  session.clear();
  y* J& B; u' H7 S2 |3 D/ K. ?}
- u- J1 q  h0 l9 I$ }' S0 H}
2 C+ ^- Q4 I7 e: {3 n7 d6 d2 \
因为把大量的对象放到session缓存中会浪费大量的内容空间。

" y5 ]8 K0 z3 V8 x2 L# D
3 执行完session.flush()时，并不意味着数据就肯定持久化到数据库中的，因为事务控制着数据库，如果事务提交失败了，缓存中的数据还是照样会被回滚的。
9 O: w0 C0 s2 G" q
; Z5 F3 D# R* V, _; b! Y4 ]3 c