spring batch(一)：基础部分

转自：http://kanpiaoxue.iteye.com/blog/1768887

spring batch

官网：

http://www.springsource.org/spring-batch

下载页面：

http://static.springsource.org/spring-batch/downloads.html

文档：

http://static.springsource.org/spring-batch/reference/index.html

数据库表格创建连接：DDL

http://static.springsource.org/spring-batch/reference/html/metaDataSchema.html#exampleDDLScripts

 

chapter 1、Introducing Spring Batch

spring batch需要依赖关系型数据库才能运行，在它的官方文档中的附录中，有创建它依赖的数据库表结构。

spring batch设计的目标：

1、大数据处理

2、自动化的

3、健壮的

4、可信赖的

5、高性能的

配置文件中 chunk  里面的 commit-interval="100"的大小，就是chunk块的大小。它们是一回事。

chunk 里面有 ItemReader ItemProcessor ItemWriter , ItemReader一次读取一条记录，ItemProcessor一次处理一条记录，ItemWriter一次输入commit-interval="100"指定事物大小的记录数（也就是chunk块的大小）。

推荐的commit-interval的大小是 10 至 200。 如果这个数值太大，如果是输出数据到数据库，会造成数据库的事物数据太大，影响数据库的性能，数据库会记录很多回滚数据的事物内容，造成性能低下。这个值太小，又会造成很多事务的产生，造成spring batch运行缓慢。

可以用SpEL动态配置程序运行的参数，例如：

<property name="resource"value="file:#{jobParameters['inputResource']}" />

这里需要注意一点，bean的scope必须为 “step”。在spring 3.×中支持 SPEL表达式。

<bean id="reader" class="org.springframework.batch.item.file.FlatFileItemReader" scope="step">

 

下面是spring batch的元数据表，oracle数据库的DDL

 

Sql代码  

1. CREATE TABLE BATCH_JOB_INSTANCE  (  
2.     JOB_INSTANCE_ID NUMBER(19,0)  NOT NULL PRIMARY KEY ,    
3.     VERSION NUMBER(19,0) ,    
4.     JOB_NAME VARCHAR2(100) NOT NULL,   
5.     JOB_KEY VARCHAR2(32) NOT NULL,  
6.     constraint JOB_INST_UN unique (JOB_NAME, JOB_KEY)  
7. ) ;  
8.   
9. CREATE TABLE BATCH_JOB_EXECUTION  (  
10.     JOB_EXECUTION_ID NUMBER(19,0)  NOT NULL PRIMARY KEY ,  
11.     VERSION NUMBER(19,0)  ,    
12.     JOB_INSTANCE_ID NUMBER(19,0) NOT NULL,  
13.     CREATE_TIME TIMESTAMP NOT NULL,  
14.     START_TIME TIMESTAMP DEFAULT NULL ,   
15.     END_TIME TIMESTAMP DEFAULT NULL ,  
16.     STATUS VARCHAR2(10) ,  
17.     EXIT_CODE VARCHAR2(100) ,  
18.     EXIT_MESSAGE VARCHAR2(2500) ,  
19.     LAST_UPDATED TIMESTAMP,  
20.     constraint JOB_INST_EXEC_FK foreign key (JOB_INSTANCE_ID)  
21.     references BATCH_JOB_INSTANCE(JOB_INSTANCE_ID)  
22. ) ;  
23.       
24. CREATE TABLE BATCH_JOB_PARAMS  (  
25.     JOB_INSTANCE_ID NUMBER(19,0) NOT NULL ,  
26.     TYPE_CD VARCHAR2(6) NOT NULL ,  
27.     KEY_NAME VARCHAR2(100) NOT NULL ,   
28.     STRING_VAL VARCHAR2(250) ,   
29.     DATE_VAL TIMESTAMP DEFAULT NULL ,  
30.     LONG_VAL NUMBER(19,0) ,  
31.     DOUBLE_VAL NUMBER ,  
32.     constraint JOB_INST_PARAMS_FK foreign key (JOB_INSTANCE_ID)  
33.     references BATCH_JOB_INSTANCE(JOB_INSTANCE_ID)  
34. ) ;  
35.       
36. CREATE TABLE BATCH_STEP_EXECUTION  (  
37.     STEP_EXECUTION_ID NUMBER(19,0)  NOT NULL PRIMARY KEY ,  
38.     VERSION NUMBER(19,0) NOT NULL,    
39.     STEP_NAME VARCHAR2(100) NOT NULL,  
40.     JOB_EXECUTION_ID NUMBER(19,0) NOT NULL,  
41.     START_TIME TIMESTAMP NOT NULL ,   
42.     END_TIME TIMESTAMP DEFAULT NULL ,    
43.     STATUS VARCHAR2(10) ,  
44.     COMMIT_COUNT NUMBER(19,0) ,   
45.     READ_COUNT NUMBER(19,0) ,  
46.     FILTER_COUNT NUMBER(19,0) ,  
47.     WRITE_COUNT NUMBER(19,0) ,  
48.     READ_SKIP_COUNT NUMBER(19,0) ,  
49.     WRITE_SKIP_COUNT NUMBER(19,0) ,  
50.     PROCESS_SKIP_COUNT NUMBER(19,0) ,  
51.     ROLLBACK_COUNT NUMBER(19,0) ,   
52.     EXIT_CODE VARCHAR2(100) ,  
53.     EXIT_MESSAGE VARCHAR2(2500) ,  
54.     LAST_UPDATED TIMESTAMP,  
55.     constraint JOB_EXEC_STEP_FK foreign key (JOB_EXECUTION_ID)  
56.     references BATCH_JOB_EXECUTION(JOB_EXECUTION_ID)  
57. ) ;  
58.   
59. CREATE TABLE BATCH_STEP_EXECUTION_CONTEXT  (  
60.     STEP_EXECUTION_ID NUMBER(19,0) NOT NULL PRIMARY KEY,  
61.     SHORT_CONTEXT VARCHAR2(2500) NOT NULL,  
62.     SERIALIZED_CONTEXT CLOB ,   
63.     constraint STEP_EXEC_CTX_FK foreign key (STEP_EXECUTION_ID)  
64.     references BATCH_STEP_EXECUTION(STEP_EXECUTION_ID)  
65. ) ;  
66.   
67. CREATE TABLE BATCH_JOB_EXECUTION_CONTEXT  (  
68.     JOB_EXECUTION_ID NUMBER(19,0) NOT NULL PRIMARY KEY,  
69.     SHORT_CONTEXT VARCHAR2(2500) NOT NULL,  
70.     SERIALIZED_CONTEXT CLOB ,   
71.     constraint JOB_EXEC_CTX_FK foreign key (JOB_EXECUTION_ID)  
72.     references BATCH_JOB_EXECUTION(JOB_EXECUTION_ID)  
73. ) ;  
74.   
75. CREATE SEQUENCE BATCH_STEP_EXECUTION_SEQ START WITH 0 MINVALUE 0 MAXVALUE 9223372036854775807 NOCYCLE;  
76. CREATE SEQUENCE BATCH_JOB_EXECUTION_SEQ START WITH 0 MINVALUE 0 MAXVALUE 9223372036854775807 NOCYCLE;  
77. CREATE SEQUENCE BATCH_JOB_SEQ START WITH 0 MINVALUE 0 MAXVALUE 9223372036854775807 NOCYCLE;  

 

 

[备注]  SQL 脚本在spring batch的核心jar包中有提供。例如： spring-batch-core-2.1.9.RELEASE.jar的核心包org.springframework.batch.core中，schema-drop-[database].sql 的形式提供了各种主流关系型数据库的sql脚本。

spring batch支持的数据库有：Derby, H2, HSQLDB,MySQL, Oracle, PostgreSQL, SQLServer, and Sybase.

 

chapter 2、Spring Batch concepts

1、spring batch 的主要组件：

Job Repository持久化job执行元数据的基础组件

Job launcher引导job执行的基础组件

Jobbatch处理的应用组件

Stepjob内部的一个词语，一个job由一系列的step组成
Tasklet在step里面应用事务的，可重复执行的处理步骤

Item从数据源输入或者输出的一条记录

Chunk指定大小的item的列表。

Item reader负责从数据源读取item记录的组件

Item Processor负责处理(转换、验证、过滤等动作)item记录的组件

Item writer负责向数据源输出一个chunk的items，即：向数据源输出指定大小的item的列表的组件

 

 

2、spring batch如何和外部交互的

外部的cron，quartz等调度，或者web等，可以调用launch，触发spring batch的运行。

 

3、spring batch的基础组件包括：job launch和job repository。 它们不需要开发人员进行开发，只需要在配置文件中进行配置。

spring batch 的job是一系列在spring batch XML中的step组成。

4、Tasklet的使用

创建一个步骤(step)，包括写一个tasklet执行或使用一个Spring Batch提供的tasklet。

当需要解压文件、调用存储过程、或者删除文件、调用sh脚本的时候，需要自己创建Tasklet的实现。

当实现tasklet的时候，这些需求可以划分为batch的read-process-write模式，那么就应该使用chunk元素配置tasklet，作为chunk processing处理步骤。chunk元素使得你的程序更加有效地读取，处理和写入数据。

小结：工作（job）是一系列的步骤（step），这些内容你可以轻易的在spring batch的xml里面进行定义。而步骤（step）由tasklet组成。tasklet可以由“面向模块”编程的chunk组成，或者tasklet完全来由开发者进行定制。

5、Job的相关概念

a、Job工作

b、Job instance工作实例

c、Job execution执行工作

一个工作（job）可以拥有很多工作实例(job instance)，每个工作实例(job instance)可以拥有很多工作执行(job execution)。

 

在Spring Batch中，工作实例（job instance）包括工作（job）和工作参数（job parameter）。

 

Java代码  

1. jobLauncher.run(job, new JobParametersBuilder()  
2. .addString("date", "2010-06-27")  
3. .toJobParameters()  
4. );  

工作实例等式：

 

JobInstance = Job + Job-Parameters.

Job instance和Job execution的生命周期的一些规则：

a、当你第一次运行job的时候，spring batch创建job instance和第一个job execution。

b、当前面的同一个job instance被成功的执行完成之后，你不能再次运行这个job instance。

c、你不能同时执行多个相同的实例。

 

 ================ 基础部分结束 ============================