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

admin

Session Clear（）与 Flush（） 解释
1.Clear 方法
7 e  P9 Z8 N# Y: j. N4 c  无论是Load 还是 Get 都会首先查找缓存（一级缓存） 如果没有，才会去数据库查找，调用Clear() 方法，可以强制清除Session缓存。
例：

1. public void testClear(){
   5 W1 w% [, @; b& J: a2 S8 q
2.                 Session session =  hibernateUitl.getSessionFactory().getCurrentSession();
   3 @( B( b; d! p
3.                 session.beginTransaction();
   
4.                 Teacher t = (Teacher) session.get(Teacher.class, 3);
   
5.                 System.out.println(t.getName());
   
6.                 Teacher t2 = (Teacher) session.get(Teacher.class, 3);
   
7.                 System.out.println(t2.getName());
   / Q+ z7 D; ^  o1 S. Z3 L
8.                 session.getTransaction().commit();
   - w  i0 t6 i1 ?; l! |, u
9.         }
   ' x& `5 W3 Q/ [2 @& [

复制代码

这里虽然用了2个get方法（get方法会立即执行sql语句），但因为第一次执行了会缓存一个ID为3的实体，所以虽然有2个get方法只执行一次SQL语句。
% I, x9 G5 b! l, w5 y& i  g  G

1. public void testClear(){
     S" h  a' [' v
2.                 Session session =  HibernateUitl.getSessionFactory().getCurrentSession();
   
3.                 session.beginTransaction();
   
4.                 Teacher t = (Teacher) session.get(Teacher.class, 3);
   
5.                 System.out.println(t.getName());
   4 y6 x$ }/ y9 _" z
6.                 session.clear();//这里不clear只会执行一次sql语句，有clear会执行2次
   # A, I/ [) W* j5 _' |2 a( R9 X
7.                 Teacher t2 = (Teacher) session.get(Teacher.class, 3);
   
8.                 System.out.println(t2.getName());
   
9.                 session.getTransaction().commit();
   ' x( T2 e4 Y# Y+ v
10.         }
    8 f0 P- q8 G# X: N% C) I- S& h

复制代码

. v8 `, ^# i) C0 G# g这里在第2次get前执行session.clear(),我们把hibernate show_sql 出来，它就会执行2次sql语句了。
所以session.clear()会清除缓存。
( H- Y' _# W- I; U2 K& |1 Q- N/ {2.Flush方法
* _1 ?3 V7 j3 `9 N( k  可以强制进行从内存到数据库的同步。
例：
5 ?8 X0 e' L4 ~) V

1. @Test
   
2.         /**
   * ^( \7 y3 V, b& g4 T2 t8 I
3.          * flush 强制与数据库同步
   1 U2 x: g0 d* [+ v
4.          */
   ) u' z4 J0 i) i9 B1 x4 j2 t0 g  \
5.         public void testFlush(){
   ' P: @4 ~6 k0 C) M1 J
6.                 Session session =  HibernateUitl.getSessionFactory().getCurrentSession();
   
7.                 session.beginTransaction();
   % L& ~+ Q, M, X' A3 e: k! h
8.                 Teacher t = (Teacher) session.get(Teacher.class, 3);
   
9.                 t.setName("yyy");
   $ V2 x2 C9 g: R" y! v7 [. R/ d
10. 
    
11.                 t.setName("yyyyy");
    ( \5 q+ Q- E- B
12.                 session.getTransaction().commit();
    
13.         }
    2 b6 h2 |) C3 C( ]. _8 Y( ]
14. 
    
15. 
    

复制代码

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

1. @Test
   
2.         /**
   
3.          * flush 强制与数据库同步
   
4.          */
   ) e2 t; ~5 t' B/ R: c( x
5.         public void testFlush(){
   7 }, p" G7 G( w& J- `- n
6.                 Session session =  HibernateUitl.getSessionFactory().getCurrentSession();
   & m+ d9 m1 |2 Q  ~: {
7.                 session.beginTransaction();
   
8.                 Teacher t = (Teacher) session.get(Teacher.class, 3);
   2 M4 o1 j$ R, Y3 c# x8 l
9.                 t.setName("yyy");
   1 J( x4 ~% W) P, S& g* F  x! O
10.                 session.flush();//有flush会执行2次UPDAE,没有会只执行一次
    5 v' @/ |7 |3 e2 l) C8 C2 G
11.                 t.setName("yyyyy");
    % }0 Y" u; G9 J& d8 d. _
12.                 session.getTransaction().commit();
    9 b& D: W) }2 J: A! O) f& R2 M
13.         }
    8 D! t. C, V; V( L7 o& {3 a% h
14. 
    # e$ M3 q) h  I" z
15. 
    

复制代码

) Z* F/ a5 s) j; v6 v
- T2 K/ x1 Z$ j5 T% @  Y我们在第2次setName（）时 执行session.flush().
3 @3 P2 H* x% @3 Q再看hibernate 执行的sql 语句
# B9 o) L% e3 [- ?, s( ^# D

1. Hibernate:
   : E6 t' }& G0 N4 s3 Y
2.     update
   
3.         Teacher
   
4.     set
   ! E- b5 O; V" Q4 ~
5.         birthday=?,
   
6.         name=?,
   6 [" c9 x; ^# E) g! O( v* ^
7.         title=?
   5 ^/ P2 b" d3 y5 V, b1 U6 @2 D
8.     where
   
9.         id=?
   
10. Hibernate:
    8 P7 P- J5 R2 w! O1 t, L
11.     update
    
12.         Teacher
    & |" U" A* C8 h
13.     set
    
14.         birthday=?,
    - H6 n  _. b: W3 e) a
15.         name=?,
    ; Q0 z2 S7 w3 z" J: q7 E
16.         title=?
    
17.     where
    1 X* K$ e. I5 C6 n) h* K! |/ G  h
18.         id=?
    + Z3 w2 ~/ j8 _  ]: L5 B2 D% Q
19. 
    
20. 
    

复制代码

! l; H* e) t) }; u+ r9 w
执行了2次Update

5 S/ `8 k% [1 i2 G" P所以看出来flush方法会强制与数据库同步。


Flush方法是可以设置的，也就是fulsh什么时候执行是可以设置的
7 B! G  ~6 ?6 L, `0 A. x) j. Q! T
* B# M$ x2 l2 Q/ P* f 在session.beginTransaction前设置FlushMode
$ P' l6 |- Z% N
3 l! [* _2 F7 I( U0 D3 N& Nsession.setFlushMode(FlushMode.Always|AUTO|COMMIT|NEVER|MANUAL)

* V1 K1 ?% V7 _. e8 I& HFlushMode有5个值可选

Always:任何代码都会Flush
; b3 [# h5 I; _$ vAUTO:默认方式–自动
' r+ |2 k% s; \0 S8 k" e( [9 aCommit:COMMIT时
Never:始终不
MANUAL:手动方式
$ Z$ o$ J  y2 K1 h
设置FlushMode 有个好处是可以节省开销，比如默认session只做查询时，就可以不让他与数据库同步了。
2 x. v1 @2 y. [8 W, C4 \2 F, v================================================================
9 Y7 c, I5 ~: \我说一下一些需要注意的信息：
+ @' _* M+ E" O
1 session.clear()的作用是只清除session中的缓存数据，但不管缓存与数据库的同步。
8 G; n3 o6 r, d
( P0 {( ^" N. e7 m9 E4 O0 [9 Z比如，你执行了
9 C! l7 n6 h( I" I9 m4 l
Po po = new Po();
7 L" y1 O( ~1 q& l1 usession.save(po),
3 |8 C7 k  _4 w! S# q
之后马上执行session.clear()，在事务结束的时候，这条数据是不会被持久化到数据库中的，因为一般缓存是在事务提交的时候进行清理的，当在清理缓存前就把缓存给清除了，自然就不会同步到数据库了。不过这个也有例外的情况，就是当对象使用native生成器来生成主键id时，当执行session.save()方法时,就会立马往数据库插入一条数据，这时候执行session.clear()也不会影响了。
; U% w8 c, T: M! G/ Y" `
2 当更新或者保存大批量数据的时候，可以每固定数量的时候，进行清理缓存，同时清除缓存：

" @# l$ P5 R; Q" W0 K; v) zfor (int i = 0; i < 1000;i ++){

if (i /20 == 0) {

  session.flush();
8 w* ?' h3 O% f, h, w
  session.clear();
}
- L6 P1 r, A6 |4 y; @) n}
; k, b7 q# _+ [. G7 Z" d
8 F4 \$ A+ @! y0 M4 _7 \- b因为把大量的对象放到session缓存中会浪费大量的内容空间。


' N: X8 S( l7 B7 a( ]9 ]" w3 执行完session.flush()时，并不意味着数据就肯定持久化到数据库中的，因为事务控制着数据库，如果事务提交失败了，缓存中的数据还是照样会被回滚的。
0 y* Y( R; I! Q- K% y0 {
: {( y0 D. b5 @2 t" ]9 z% C