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

admin

Session Clear（）与 Flush（） 解释
1.Clear 方法
6 ?* t2 [  R% z; p' N  无论是Load 还是 Get 都会首先查找缓存（一级缓存） 如果没有，才会去数据库查找，调用Clear() 方法，可以强制清除Session缓存。
, F; s* L9 N5 \7 b/ j2 m, v例：

1. public void testClear(){
   6 X8 ~6 O5 F4 C* ^+ ]
2.                 Session session =  hibernateUitl.getSessionFactory().getCurrentSession();
   * L5 K$ O% p1 T# B  X$ X! D) r
3.                 session.beginTransaction();
   . `# D/ h) X) N8 C* |
4.                 Teacher t = (Teacher) session.get(Teacher.class, 3);
   , V# S" w/ s; Z6 l+ O6 j6 U
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();
   ; `) U7 Y  N! d* i$ ]1 o: V
9.         }
   

复制代码

这里虽然用了2个get方法（get方法会立即执行sql语句），但因为第一次执行了会缓存一个ID为3的实体，所以虽然有2个get方法只执行一次SQL语句。
3 u/ h; O* R, G$ S$ _( i! ^

1. public void testClear(){
   
2.                 Session session =  HibernateUitl.getSessionFactory().getCurrentSession();
   / I. D" x6 D9 i% O" e
3.                 session.beginTransaction();
   + u7 I: a: Y% A9 N1 \8 n$ g
4.                 Teacher t = (Teacher) session.get(Teacher.class, 3);
   & i8 R8 Z% t5 S: ?, F* H
5.                 System.out.println(t.getName());
   
6.                 session.clear();//这里不clear只会执行一次sql语句，有clear会执行2次
   
7.                 Teacher t2 = (Teacher) session.get(Teacher.class, 3);
   & u' q4 V  U0 b# \1 Y3 y' O
8.                 System.out.println(t2.getName());
   
9.                 session.getTransaction().commit();
   
10.         }
    

复制代码

% ]+ Y8 B6 Z, L/ ]0 c4 Z  ^! F这里在第2次get前执行session.clear(),我们把hibernate show_sql 出来，它就会执行2次sql语句了。
/ t! a. {5 g1 ]- c7 G- n所以session.clear()会清除缓存。
2.Flush方法
  可以强制进行从内存到数据库的同步。
7 V; D$ `$ h. S+ N2 g例：
$ T/ W3 e" |! ~0 ^5 I* B' h

1. @Test
   
2.         /**
   2 [, g9 n" J8 t/ I6 G
3.          * flush 强制与数据库同步
   
4.          */
   ! D8 p" n  N# O+ W: B% G& {+ P) x
5.         public void testFlush(){
   - ^% c- _  k) N8 M5 `# Y
6.                 Session session =  HibernateUitl.getSessionFactory().getCurrentSession();
   
7.                 session.beginTransaction();
   ( A8 X' l3 Q" j- h! N
8.                 Teacher t = (Teacher) session.get(Teacher.class, 3);
   ' g$ v. {' W" f- [$ e
9.                 t.setName("yyy");
   
10. 
    
11.                 t.setName("yyyyy");
    
12.                 session.getTransaction().commit();
    
13.         }
    
14. 
    * Z& x9 m1 l: z; }
15. 
    

复制代码

看这段代码，我们setName() 2次， 但程序只会更改数据库一次，在commit时。
" C. Z( [0 s& Z0 M- g% m

1. @Test
   
2.         /**
   
3.          * flush 强制与数据库同步
   
4.          */
   
5.         public void testFlush(){
   
6.                 Session session =  HibernateUitl.getSessionFactory().getCurrentSession();
   7 }- ^6 h. ]* o
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");
    3 k) G0 f+ Q6 I3 A
12.                 session.getTransaction().commit();
    
13.         }
    1 J  h% f6 j5 F8 }
14. 
    $ X; h$ @; T; ~; q4 d& C
15. 
    

复制代码

' L, I5 [8 D" [" m4 W
' p1 \! |+ s2 t1 C我们在第2次setName（）时 执行session.flush().
再看hibernate 执行的sql 语句

1. Hibernate:
   * I- E8 Q$ @; t" o7 O
2.     update
   
3.         Teacher
   ) p* f5 ~9 P# K, m
4.     set
   ! b/ f" g4 A/ D2 q
5.         birthday=?,
   
6.         name=?,
   " e& n# P8 z. q7 z0 k
7.         title=?
   
8.     where
   # n( V2 i/ W* {, ]' A
9.         id=?
   # G. T" g) S6 e6 G; ]: s
10. Hibernate:
    
11.     update
    / x( A) w& a8 _* C' T, I  I7 }% i
12.         Teacher
    & D5 _" s5 v9 K3 U# g8 R" g
13.     set
    
14.         birthday=?,
    2 ~; f; p+ B* q4 k9 F) C
15.         name=?,
    . z. Q0 z+ P* Z' B% G7 V" z* i' N; T
16.         title=?
    4 n! n* G3 w9 u! Y' ]) K8 U
17.     where
    " D* F& o. [3 B' ~- e
18.         id=?
    & X" i% U6 ]- N! q4 Q0 T
19. 
    
20. 
    

复制代码

% ~/ y- Q) R" X, g7 ~, W9 M+ d
执行了2次Update
) t/ G; j7 f! U6 S
所以看出来flush方法会强制与数据库同步。


Flush方法是可以设置的，也就是fulsh什么时候执行是可以设置的

5 A4 E3 R/ G7 w/ K' d1 m/ j 在session.beginTransaction前设置FlushMode
* e+ T1 e- [% \. t
8 Z& Q7 r7 h7 j3 u& `* F2 E2 xsession.setFlushMode(FlushMode.Always|AUTO|COMMIT|NEVER|MANUAL)

' k' L, ~. y9 b- w7 IFlushMode有5个值可选
4 i) F3 d" Y. L% [( X& s0 m* }
( S' _: A- B# Y. M. uAlways:任何代码都会Flush
3 u3 _( y* u7 i  S# k6 sAUTO:默认方式–自动
0 C& }5 e, y8 A: P5 ]; Q$ F  I( x6 uCommit:COMMIT时
9 l; P( y" k2 G8 A9 SNever:始终不
MANUAL:手动方式
- Z* H5 `: u! }4 m8 T# T
6 [! T  C8 w; i设置FlushMode 有个好处是可以节省开销，比如默认session只做查询时，就可以不让他与数据库同步了。
================================================================
我说一下一些需要注意的信息：

" o5 \! N/ m7 n9 \$ ]1 session.clear()的作用是只清除session中的缓存数据，但不管缓存与数据库的同步。

比如，你执行了

. s  D: d" {' e0 D& U6 h4 Y4 Y3 @Po po = new Po();
session.save(po),
; U" a/ d: T% T* e$ X# e) E
/ }* I  P# t: k$ W/ h2 [2 `之后马上执行session.clear()，在事务结束的时候，这条数据是不会被持久化到数据库中的，因为一般缓存是在事务提交的时候进行清理的，当在清理缓存前就把缓存给清除了，自然就不会同步到数据库了。不过这个也有例外的情况，就是当对象使用native生成器来生成主键id时，当执行session.save()方法时,就会立马往数据库插入一条数据，这时候执行session.clear()也不会影响了。

2 当更新或者保存大批量数据的时候，可以每固定数量的时候，进行清理缓存，同时清除缓存：
, p6 O& T7 L+ Y3 E0 _3 c, H
for (int i = 0; i < 1000;i ++){
: ]5 {0 N3 f2 Y
if (i /20 == 0) {

  session.flush();

, g! J6 k) a/ t$ i; o6 F  session.clear();
}
  l- {& M, o9 t}

因为把大量的对象放到session缓存中会浪费大量的内容空间。

+ S3 ]$ P  ^; z& v' P
3 执行完session.flush()时，并不意味着数据就肯定持久化到数据库中的，因为事务控制着数据库，如果事务提交失败了，缓存中的数据还是照样会被回滚的。
* U6 Q3 f; F. l/ C7 }4 J2 j

0 d" y( n; ^7 }/ P