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

admin

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

1. public void testClear(){
   
2.                 Session session =  hibernateUitl.getSessionFactory().getCurrentSession();
   + ?, B3 v0 k/ I
3.                 session.beginTransaction();
   
4.                 Teacher t = (Teacher) session.get(Teacher.class, 3);
   + \) w- [: Y1 Y% p5 r
5.                 System.out.println(t.getName());
   ! o4 |8 R' }3 z7 F4 w
6.                 Teacher t2 = (Teacher) session.get(Teacher.class, 3);
   / n" f: r0 \$ o8 E" b
7.                 System.out.println(t2.getName());
   2 \5 h& C. H3 @+ N, K* [8 D+ O
8.                 session.getTransaction().commit();
   9 G( K' f1 x& E1 |, e
9.         }
   

复制代码

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

1. public void testClear(){
   
2.                 Session session =  HibernateUitl.getSessionFactory().getCurrentSession();
   * b# g* D7 Z3 [4 X& O
3.                 session.beginTransaction();
   $ {: h' g# _8 W) W, V6 ^- O
4.                 Teacher t = (Teacher) session.get(Teacher.class, 3);
   4 V  {, Q4 V* ~2 R' A  e
5.                 System.out.println(t.getName());
   0 i# s5 [: v& |' r7 O9 y" [& q
6.                 session.clear();//这里不clear只会执行一次sql语句，有clear会执行2次
   
7.                 Teacher t2 = (Teacher) session.get(Teacher.class, 3);
   
8.                 System.out.println(t2.getName());
   5 K8 p  {' `7 @  m' E
9.                 session.getTransaction().commit();
   
10.         }
    

复制代码

这里在第2次get前执行session.clear(),我们把hibernate show_sql 出来，它就会执行2次sql语句了。
所以session.clear()会清除缓存。
2.Flush方法
  可以强制进行从内存到数据库的同步。
2 y1 i; M$ C& f- [4 b. B! N例：

1. @Test
   
2.         /**
   : A; h5 c9 ]) ]( s$ C# @% w+ n: v
3.          * flush 强制与数据库同步
   ; r- t: ]: \7 K4 {& E3 B) y& t
4.          */
   
5.         public void testFlush(){
   . k% u' i6 D/ ~+ c% y7 S2 M% u
6.                 Session session =  HibernateUitl.getSessionFactory().getCurrentSession();
   
7.                 session.beginTransaction();
   
8.                 Teacher t = (Teacher) session.get(Teacher.class, 3);
   # G0 Z4 o, \7 ^$ t* ~
9.                 t.setName("yyy");
   
10. 
    ) i1 {4 z  {  `' T) d
11.                 t.setName("yyyyy");
    
12.                 session.getTransaction().commit();
    
13.         }
    
14. 
    
15. 
    # \4 K7 B- v6 @

复制代码

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

1. @Test
   & ~; M7 P: }( }; Z" B! ?& x
2.         /**
   ' h8 Z" }' n" \- {% _
3.          * flush 强制与数据库同步
   4 ?) c+ }$ V& v: W, |6 j
4.          */
   9 |3 j/ u( Q% U* m& d
5.         public void testFlush(){
   
6.                 Session session =  HibernateUitl.getSessionFactory().getCurrentSession();
   & D' h1 a) g) z- m6 C* [
7.                 session.beginTransaction();
   8 _% t: @1 J! \: Q
8.                 Teacher t = (Teacher) session.get(Teacher.class, 3);
   4 h" v% G6 |" G, u1 I, O
9.                 t.setName("yyy");
   % \* R( m0 w( J4 `# d( {8 I" p
10.                 session.flush();//有flush会执行2次UPDAE,没有会只执行一次
      g) g# u- V+ }# N* B) Z% Y
11.                 t.setName("yyyyy");
    
12.                 session.getTransaction().commit();
    
13.         }
    # m. C6 g# f8 Q
14. 
    
15. 
    

复制代码

  @. E' X- f# p8 d9 S" j* c我们在第2次setName（）时 执行session.flush().
再看hibernate 执行的sql 语句

1. Hibernate:
   
2.     update
   
3.         Teacher
   / u3 u& r  k  h! e! }
4.     set
   
5.         birthday=?,
   
6.         name=?,
   ( b, o, X3 Q8 H
7.         title=?
   
8.     where
   9 R9 Y$ ~  Q# P
9.         id=?
   
10. Hibernate:
    
11.     update
    
12.         Teacher
    
13.     set
    
14.         birthday=?,
    5 l. D) H  ^/ Y" Q
15.         name=?,
    
16.         title=?
    ! Q+ l4 ~; q7 m' g  l
17.     where
    2 m8 O9 `0 N+ {
18.         id=?
    
19. 
      r8 I6 ^9 T7 T
20. 
    $ r' P4 y( h( B# D3 m: d5 [. {4 i- f

复制代码

  y3 A$ g( N% c: {+ J: q" `执行了2次Update
. K, j( J  O4 ]$ x/ Z1 Z% s
7 i: _2 Z" N) d3 X4 I所以看出来flush方法会强制与数据库同步。


& u3 ~8 d# x! H% L- FFlush方法是可以设置的，也就是fulsh什么时候执行是可以设置的

在session.beginTransaction前设置FlushMode

2 [0 M' V; o9 v9 s8 jsession.setFlushMode(FlushMode.Always|AUTO|COMMIT|NEVER|MANUAL)

' n3 H1 s( w( @FlushMode有5个值可选
8 G4 \" m, a! W1 S6 M! D  c
0 X* L: T% g5 ]$ N) E  G6 h! g+ Y2 uAlways:任何代码都会Flush
  {! ^5 |  G: ^) b1 C- D5 u% u7 b, lAUTO:默认方式–自动
Commit:COMMIT时
# `  W$ U- G- s/ j6 b, YNever:始终不
MANUAL:手动方式

设置FlushMode 有个好处是可以节省开销，比如默认session只做查询时，就可以不让他与数据库同步了。
9 C) t* H0 ?; b! O9 |6 N) ?& v================================================================
; u# s. D# \+ D  }& f' ~我说一下一些需要注意的信息：

6 a) A( ~0 t4 F1 session.clear()的作用是只清除session中的缓存数据，但不管缓存与数据库的同步。

比如，你执行了

! E# Y  z( d3 {5 K- {& |Po po = new Po();
session.save(po),

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

2 当更新或者保存大批量数据的时候，可以每固定数量的时候，进行清理缓存，同时清除缓存：

for (int i = 0; i < 1000;i ++){

& S& I( a/ Y4 W! m& q0 Eif (i /20 == 0) {

  session.flush();
' B  q4 }0 l9 w& k
  session.clear();
$ W& S7 X7 q% Q2 f. g! ~}
# P5 F$ N" c' ^1 ^- R}
4 J0 `' P* }9 p4 ~! q! k
, K' b2 T5 Z: M7 U因为把大量的对象放到session缓存中会浪费大量的内容空间。

) i6 c4 z) \' j- @  l4 `6 x
3 执行完session.flush()时，并不意味着数据就肯定持久化到数据库中的，因为事务控制着数据库，如果事务提交失败了，缓存中的数据还是照样会被回滚的。
: G/ |8 f  ?* o( t/ p& B0 s

! ^" o6 w$ P5 o, T2 b