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

admin

Session Clear（）与 Flush（） 解释
0 B& y7 D0 U9 e( ]3 S! n2 D1.Clear 方法
  无论是Load 还是 Get 都会首先查找缓存（一级缓存） 如果没有，才会去数据库查找，调用Clear() 方法，可以强制清除Session缓存。
例：

1. public void testClear(){
   7 s' |* [: [; W4 _( B& u- q  d% B
2.                 Session session =  hibernateUitl.getSessionFactory().getCurrentSession();
   0 g/ q8 i# f, g$ H$ w2 E
3.                 session.beginTransaction();
   . O4 Z, Z9 i$ p5 ^2 `
4.                 Teacher t = (Teacher) session.get(Teacher.class, 3);
   5 K, {7 k/ x0 e$ [% u/ @
5.                 System.out.println(t.getName());
   
6.                 Teacher t2 = (Teacher) session.get(Teacher.class, 3);
   1 O: k/ ?$ b8 t5 c  B6 {% Y, }
7.                 System.out.println(t2.getName());
   , c+ b5 Y% v* E* b- h
8.                 session.getTransaction().commit();
   
9.         }
   , ~  b% W, U, ]

复制代码

这里虽然用了2个get方法（get方法会立即执行sql语句），但因为第一次执行了会缓存一个ID为3的实体，所以虽然有2个get方法只执行一次SQL语句。
' @0 a+ m$ G; D

1. public void testClear(){
   
2.                 Session session =  HibernateUitl.getSessionFactory().getCurrentSession();
   
3.                 session.beginTransaction();
   ; F# E/ W  ^: M! H* j
4.                 Teacher t = (Teacher) session.get(Teacher.class, 3);
   1 W6 h9 e+ U7 n
5.                 System.out.println(t.getName());
   % I( {' V7 X+ D" z. G; m7 U3 h
6.                 session.clear();//这里不clear只会执行一次sql语句，有clear会执行2次
   
7.                 Teacher t2 = (Teacher) session.get(Teacher.class, 3);
   
8.                 System.out.println(t2.getName());
   ( v& b+ y/ v5 D! S' K+ T1 n4 D3 l
9.                 session.getTransaction().commit();
   * V5 z6 O: x! @/ I6 O
10.         }
    ( Z. j& W9 ^: ]. G4 P

复制代码

! E6 ?/ T3 q2 b  M7 w* \3 y3 m这里在第2次get前执行session.clear(),我们把hibernate show_sql 出来，它就会执行2次sql语句了。
0 @: ^9 M: w$ i4 q9 G所以session.clear()会清除缓存。
2.Flush方法
. l* C7 S' q! Z" j  r  可以强制进行从内存到数据库的同步。
例：
7 k+ h9 |; E$ t! E

1. @Test
   
2.         /**
   
3.          * flush 强制与数据库同步
   
4.          */
   
5.         public void testFlush(){
   
6.                 Session session =  HibernateUitl.getSessionFactory().getCurrentSession();
   
7.                 session.beginTransaction();
   
8.                 Teacher t = (Teacher) session.get(Teacher.class, 3);
   2 e: M; v1 ^+ M. ~8 Y. y1 O
9.                 t.setName("yyy");
   " @; P; E! ^) b+ U& ]+ ^5 P) l
10. 
    4 r- ?+ e5 f5 c" O8 o% f7 m
11.                 t.setName("yyyyy");
    1 G" x7 m: o3 |' d& q4 V- Y
12.                 session.getTransaction().commit();
    + B2 q3 o6 \) c" c
13.         }
    
14. 
    , i0 v; B7 S# k% Z. P. V% t5 N
15. 
    

复制代码

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

1. @Test
   1 H' C# v3 k& A* q/ h1 o' u& L
2.         /**
   " h; a) w! B. k) O( `3 _
3.          * flush 强制与数据库同步
   
4.          */
   - C$ I' j; P9 e$ _0 v6 _0 x4 N
5.         public void testFlush(){
   7 y3 I, |5 L# D, z
6.                 Session session =  HibernateUitl.getSessionFactory().getCurrentSession();
   0 Q; _) m) B, l  n. H
7.                 session.beginTransaction();
   
8.                 Teacher t = (Teacher) session.get(Teacher.class, 3);
   
9.                 t.setName("yyy");
   
10.                 session.flush();//有flush会执行2次UPDAE,没有会只执行一次
    
11.                 t.setName("yyyyy");
    
12.                 session.getTransaction().commit();
    ; k% p0 j& j7 A9 u
13.         }
    " p9 k1 x4 a6 A4 K6 q+ y
14. 
    
15. 
    

复制代码

+ a' ~- D7 h- X1 G7 j' K: m- v我们在第2次setName（）时 执行session.flush().
再看hibernate 执行的sql 语句
' |8 [& o. M5 b# `

1. Hibernate:
   7 M. r  ?" y; I/ z* E2 l
2.     update
   : N  j6 D* e+ M: T$ ~) @3 h; ~
3.         Teacher
   9 ?; m6 Z  J$ @/ g, ]; B* }9 v! m
4.     set
   
5.         birthday=?,
   0 |2 o' D- y7 v) n* L9 q* S
6.         name=?,
   
7.         title=?
   
8.     where
   % |* V$ e" D% N9 X
9.         id=?
   7 H# I9 x! e1 r; i* q
10. Hibernate:
    
11.     update
    
12.         Teacher
    
13.     set
    8 Z$ ~$ i% P1 x
14.         birthday=?,
    
15.         name=?,
    , M) ]# Q  q) J1 L% r' z5 ~! Q
16.         title=?
    
17.     where
    
18.         id=?
    
19. 
    
20. 
      D! ]7 p) O4 u# C6 |" z, W

复制代码

8 m- ]! P4 t# N! H0 T
执行了2次Update

+ z6 P# b1 O# O% y# ~+ ~; `+ }所以看出来flush方法会强制与数据库同步。


Flush方法是可以设置的，也就是fulsh什么时候执行是可以设置的
, o+ u. [: L- k  u
. h. q( j+ q6 r2 `' W! _$ l9 N 在session.beginTransaction前设置FlushMode
; o! v6 M$ z1 \. @; ?
: ?# @2 w: ~; j* Osession.setFlushMode(FlushMode.Always|AUTO|COMMIT|NEVER|MANUAL)
( j* D( ?: T2 E, z
/ K! D7 E0 ~( m" x5 \% H$ aFlushMode有5个值可选
: E+ q: G  L8 |; G; B/ }2 n9 Z
1 u. j/ [2 d8 q1 U' S9 u7 kAlways:任何代码都会Flush
AUTO:默认方式–自动
Commit:COMMIT时
Never:始终不
MANUAL:手动方式
, \( N: i4 O) `, D7 f
设置FlushMode 有个好处是可以节省开销，比如默认session只做查询时，就可以不让他与数据库同步了。
================================================================
$ |' {5 ]% @- P& g$ ^  G6 q* k我说一下一些需要注意的信息：
4 m4 J/ G# m8 M' ]
0 O* e$ c5 |" }8 {2 [  T+ w5 v1 session.clear()的作用是只清除session中的缓存数据，但不管缓存与数据库的同步。
6 b0 l4 q6 f" s' d" v4 }( J0 A
! w' @9 w4 }4 T7 S& V+ X比如，你执行了
1 V. h$ K3 D) ]
Po po = new Po();
session.save(po),

之后马上执行session.clear()，在事务结束的时候，这条数据是不会被持久化到数据库中的，因为一般缓存是在事务提交的时候进行清理的，当在清理缓存前就把缓存给清除了，自然就不会同步到数据库了。不过这个也有例外的情况，就是当对象使用native生成器来生成主键id时，当执行session.save()方法时,就会立马往数据库插入一条数据，这时候执行session.clear()也不会影响了。

- S9 f- e( U. \4 d: T( ?8 M2 当更新或者保存大批量数据的时候，可以每固定数量的时候，进行清理缓存，同时清除缓存：
5 J* l( y2 r, ^, K
2 {+ H( D; I& a1 o6 }for (int i = 0; i < 1000;i ++){

* s5 b. x( h3 y! ]7 y, r" kif (i /20 == 0) {

: N, T; t1 K/ n0 r$ V  session.flush();
& O, _( R5 }7 Q# y1 q/ W; E( }
$ p$ V0 c6 u9 P2 u1 L. M  session.clear();
}
0 ?1 z" q+ Z* R}
& A* ]0 \; b6 W, q  v
, x+ ~( |) v9 g; {因为把大量的对象放到session缓存中会浪费大量的内容空间。
( r9 B* Y' n4 u$ a; Q+ c. |# D, H% G
  J' y/ R- N1 l
3 执行完session.flush()时，并不意味着数据就肯定持久化到数据库中的，因为事务控制着数据库，如果事务提交失败了，缓存中的数据还是照样会被回滚的。