org.springframework.batch.core.annotation（基于 java 的监听器配置注解）
org.springframework.batch.core.annotation 基于 java 的监听器配置注解。
4 L- n7 N: J3 d8 I5 k I: [* b9 U! P
! R2 g# p* U: |( K7 b- H$ F注释类型描述
; J8 D& ~+ x8 M4 fAfterChunk
1 w' W6 [4 r3 w' K! Y7 C4 p# g标记在块执行后要调用的方法。: K ?+ q i+ b
预期签名：void afterChunk(ChunkContext context)
/ c0 J0 [) P- x/ L/ x) W0 K$ H; R8 j& z* y+ ^3 {
AfterChunkError' R5 |# W I( e! `, s5 {
标记要在 a 失败并标记为回滚后调用的方法。
; F% R/ o$ x0 {. s预期签名：void afterFailedChunk(ChunkContext context). d+ A- |; `* U' j: l* {; l
5 O+ U9 ~2 s6 Y) J: bAfterJob
% ~9 U' }3 i" |0 s1 r3 }! w+ g标记作业完成后要调用的方法。
) }* P7 W+ ~% P+ I, M* M( K4 Y8 ?3 j0 H$ t% P
8 O* O/ q( j, ^- ^5 Q; l
AfterProcess
0 s- o1 j3 E3 {$ }" B将项目传递给 ItemProcessor 后标记要调用的方法
0 j, j; W: W2 y3 o
8 f5 v+ {$ {/ k# C" K9 C( j预期签名：void afterProcess(T item, S result)
0 G- h8 Z) Q3 Y/ K$ _7 I+ ? dAfterRead9 q# {3 Z4 ?0 J! q( G
标记从 ItemReader 读取项目后要调用的方法5 g3 u% j; Z6 s5 m) y$ n M
( R4 |* u: n+ u# ?: o/ k预期签名：void afterRead(T item)6 Y. J3 W2 |9 ]! R! o9 N2 m8 F& @
AfterStep
- L( M8 @7 c3 O g+ l! ^# ]: H9 s标记在 Step 完成后要调用的方法。
# s2 I7 G7 Q# X/ _# t; ^AfterWrite7 J3 ]7 p: L# U4 f# _" b
标记在将项目传递给 ItemWriter 后要调用的方法
) D( `& L+ E/ _: q4 S) m3 L9 y( W. k1 r9 z+ S0 O
预期签名：void afterWrite(List<? extends S> items)2 L* G. H4 W* D: O
BeforeChunk* z, C. |& R. ~) y4 v1 x
标记在执行块之前要调用的方法。
: b# ^. B0 p# s9 L; a; @BeforeJob
. H5 d6 r0 u* y% k( Q3 i标记要在 Job 执行之前调用的方法，该方法在 JobExecution 创建并持久化之后，但在执行第一个 Step 之前。9 n8 w: B- q$ P7 R
BeforeProcess0 F& o; u5 z0 [8 W( I8 L' l7 N
标记在将项目传递给 ItemProcessor 之前要调用的方法
/ X& C, I: d- J4 x4 p
& V0 b& F/ b8 r- L) F2 {" ^0 I预期签名：void beforeProcess(T item)0 b8 z2 {4 S( E6 X/ p2 Y
BeforeRead
- V6 ?0 y1 y3 C- X, p; c标记从 ItemReader 读取项目之前要调用的方法
/ Z) I r; K5 i0 a( d3 g8 Z' n% e4 H$ N, i. M* t
预期签名：void beforeRead()
& |; @ F$ ?+ [# Z/ J; x* r5 hBeforeStep2 S) B$ C9 Z3 I" G0 ~, Y+ v
标记要在 Step 执行之前调用的方法，该方法在 StepExecution 创建并持久化之后，但在读取第一项之前。
6 y8 Z% G9 I( b) `BeforeWrite
0 l, p8 B1 M- ]( z% z) G8 |1 |- f1 X标记在将项目传递给 ItemWriter 之前要调用的方法
( @4 p; x9 R$ J& q; [& E& e% [" A. A( u' n8 G4 M2 ?: C5 X
预期签名：void beforeWrite(List<? extends S> items)/ X. S- K5 X0 q7 a3 {
OnProcessError
& N* p& ^- @3 ~0 p如果 ItemProcessor 抛出异常，则标记要调用的方法2 m- V S" O* X/ w- W
. _2 }9 u p2 [) q& |0 D
预期签名：void onProcessError(T item, Exception e)
+ z& B( D0 y) YOnReadError
3 M% }! z; c2 @% a2 h如果 ItemReader 抛出异常，则标记要调用的方法; H, p, ^# t% Q! f
, w4 X8 i5 P! C5 D$ `) M* e* t# b$ N预期签名：void onReadError(Exception ex)
' \3 I. N, J/ @3 Q" j: \OnSkipInProcess
# K9 F) q5 u+ w: X7 ]1 E: \标记由于在 ItemProcessor 中引发异常而跳过项目时要调用的方法。
: e9 U( T; e) ?% a& {) d" j
, F& g0 T- A: k0 h! r+ q预期签名： void onSkipInProcess(T item, Throwable t): l) r. W q1 `0 Y8 S$ \
OnSkipInRead5 k8 q1 h. E. g( @9 \/ N
标记由于在 ItemReader 中引发异常而跳过项目时要调用的方法
h Z" ^ g1 Z7 t f9 D; @& e% P0 O8 X9 m$ g
预期签名：void onSkipInRead(Throwable t)/ @8 g/ O8 t* j: Y
OnSkipInWrite& d* ?1 o, c# W1 ?$ B
标记由于在 ItemWriter 中引发异常而跳过项目时要调用的方法。
6 z. {; W; }; {" y
4 _( E: x# Z' Q5 i预期签名： void onSkipInWrite(S item, Throwable t)
, L' v5 _# {; F& E' v: @OnWriteError
0 z7 K- x, ^6 j0 [如果 ItemWriter 抛出异常，则标记要调用的方法5 m5 w' w8 p$ |3 x& S( a+ A
0 g ?4 F9 r' i* f- L. L& n预期签名：void onWriteError(Exception exception, List<? extends S> items)
& B: n: \" o' s' T9 U4 F. J' e9 N
+ \# K I O1 d8 x3 m
2 c$ k: K/ |6 z+ z0 m2 a( a |
|
|
|
|
|
|
|
|
