基于xml配置方式整合Spring boot + Spring batch + Quartz

Spring batch提供了强大的批处理功能，比如ItemReader、ItemProcess、ItemWriter，还有Tasklet，但定时功能不够强大；Quartz提供了通过JobDetail、Trigger、SchedulerFactory提供了强大的定时器功能，但批处理功能不够强大，两者一拍即合，Spring做了两者的整合，整合的jar包见：

    <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
        </dependency>

另外还要引入spring batch和quartz的依赖。
具体的Spring batch和quatz的功能请参考其它文档，本章节做基于xml的方式整合Spring boot + Spring batch + Quartz框架。
案例：在距当前时间的3s后每3s的时间执行一次job工作，即读取库表，并打印出来。数据库采用的DB2，库表users，记录为：

pom.xml:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.lzj</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>demo</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.10.RELEASE</version>
        <relativePath /> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-batch</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-oxm</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!-- <dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> 
            <scope>runtime</scope> </dependency> -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.batch</groupId>
            <artifactId>spring-batch-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.3.0</version>
        </dependency>
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <scope>runtime</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

1、首先创建spring batch的job任务，读取库表users
创建库表users对应的java的POJO

package com.lzj.springbatch.model;
public class User {
    private int id;
    private String name;
    private int age;

    public User(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "User [id=" + id + ", name=" + name + ", age=" + age + "]";
    }

}

创建一个MyTaklet的job任务，实现spring batch的Tasklet接口就可以

package com.lzj.springbatch.tasklet;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.batch.core.StepContribution;
import org.springframework.batch.core.scope.context.ChunkContext;
import org.springframework.batch.core.step.tasklet.Tasklet;
import org.springframework.batch.repeat.RepeatStatus;
import org.springframework.jdbc.core.JdbcTemplate;
import com.lzj.springbatch.model.User;

public class MyTasklet implements Tasklet {

    private DataSource dataSource;

    public DataSource getDataSource() {
        return dataSource;
    }

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    @Override
    public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {
        String sql = "select * from SQLJ.users";
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
        List<User> users = jdbcTemplate.query(sql, new UserMapper());
        for(User user : users){
            System.out.println(user);
        }
        return RepeatStatus.FINISHED;
    }

}

创建库表中数据与java中POJO的映射

package com.lzj.springbatch.tasklet;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
import com.lzj.springbatch.model.User;

public class UserMapper implements RowMapper<User> {

    @Override
    public User mapRow(ResultSet rs, int rowNum) throws SQLException {
        return new User(rs.getInt(1), 
                rs.getString(2), 
                rs.getInt(3));
    }

}

2、创建Job任务的启动器，用来启动Job任务
Spring家族中的spring-context-support 的jar包整合了Quartz，只要实现包中的QuartzJobBean，并覆写executeInternal方法，在executeInternal方法中启动job任务即可。

package com.lzj.quartz;

import java.text.SimpleDateFormat;
import java.util.Date;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobParametersBuilder;
import org.springframework.batch.core.configuration.JobLocator;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.scheduling.quartz.QuartzJobBean;

public class QuartzJobLauncher extends QuartzJobBean {
/*-------------方式一：获取jobName、jobLauncher和jobLocator*/
//  private String jobName;
//  private JobLauncher jobLauncher;
//  private JobLocator jobLocator;
//
//  public String getJobName() {
//      return jobName;
//  }
//
//  public void setJobName(String jobName) {
//      this.jobName = jobName;
//  }
//
//  public JobLauncher getJobLauncher() {
//      return jobLauncher;  
//  }
//
//  public void setJobLauncher(JobLauncher jobLauncher) {
//      this.jobLauncher = jobLauncher;
//  }
//
//  public JobLocator getJobLocator() {
//      return jobLocator;
//  }
//
//  public void setJobLocator(JobLocator jobLocator) {
//      this.jobLocator = jobLocator;
//  }
/*------------------------方式一获取结束------------------------------*/

    @Override
    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
/*-------------方式二：获取jobName、jobLauncher和jobLocator-------------------*/
        JobDetail jobDetail = context.getJobDetail();
        JobDataMap jobDataMap = jobDetail.getJobDataMap();
        String jobName = jobDataMap.getString("jobName");
        JobLauncher jobLauncher = (JobLauncher) jobDataMap.get("jobLauncher");
        JobLocator jobLocator = (JobLocator) jobDataMap.get("jobLocator");
        System.out.println("jobName : " + jobName);
        System.out.println("jobLauncher : " + jobLauncher);
        System.out.println("jobLocator : " + jobLocator);
/*-----------------------------方式二获取结束---------------------------------*/
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String date = sf.format(new Date());
        System.out.println("Current Time : " + date);

        try {
            Job job = jobLocator.getJob(jobName);
            JobExecution jobExecution = jobLauncher.run(job, new JobParametersBuilder().addDate("date", new Date()).toJobParameters());
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

}

3、xml中配置job
创建batch-config.xml，配置spring batch的job、job的启动器jobLauncher、数据源等信息

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:batch="http://www.springframework.org/schema/batch"
    xmlns:jdbc="http://www.springframework.org/schema/jdbc"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/batch http://www.springframework.org/schema/batch/spring-batch.xsd
        http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-4.3.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">

   <!-- 引入配置文件 -->
   <bean id="propertyConfigure" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <list>
                <value>classpath:db.properties</value>
            </list>
        </property>
   </bean>

    <!-- 配置数据源 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="url" value="${jdbc.jdbcUrl}" />
        <property name="username" value="${jdbc.user}" />
        <property name="password" value="${jdbc.password}" />
        <property name="driverClassName" value="${jdbc.driverClass}" />
                <property name="initialSize" value="3" />
        <property name="minIdle" value="3" />
        <property name="maxActive" value="3" />
        <!-- 配置获取连接等待超时的时间 -->
        <property name="maxWait" value="60000" />
        <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
        <property name="timeBetweenEvictionRunsMillis" value="60000" />
        <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
        <property name="minEvictableIdleTimeMillis" value="300000" />
        <property name="testWhileIdle" value="true" />
        <property name="testOnBorrow" value="false" />
        <property name="testOnReturn" value="false" />
    </bean>


    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 配置spring batch的jobRepository，负责与数据库打交道 -->
    <bean id="jobRepository" class="org.springframework.batch.core.repository.support.JobRepositoryFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <property name="transactionManager" ref="transactionManager"></property>
    </bean>

    <!-- 配置spring batch的 jobLauncher，用来启动Job-->
    <bean id="jobLauncher" class="org.springframework.batch.core.launch.support.SimpleJobLauncher">
        <property name="jobRepository" ref="jobRepository"></property>
    </bean>
    <!-- 注册job，把job注入到容器中，在jobLauncher启动job时才能从容器中获取要启动的Job -->
    <bean id="jobRegistry" class="org.springframework.batch.core.configuration.support.MapJobRegistry"></bean>
    <bean class="org.springframework.batch.core.configuration.support.JobRegistryBeanPostProcessor">
        <property name="jobRegistry" ref="jobRegistry"></property>
    </bean>

    <!-- 配置job工作 -->
    <batch:job id="myJob" restartable="true">
        <batch:step id="myStep" allow-start-if-complete="true">
            <batch:tasklet ref="myTasklet">
            </batch:tasklet>
        </batch:step>
    </batch:job>

    <bean id="myTasklet" class="com.lzj.springbatch.tasklet.MyTasklet">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

</beans>

4、xml中配置quartz定时
创建quartz-config.xml，通过spring-context-support的jar包中整合的工具类配置定时任务。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 整合spring batch中的job -->
    <bean id="quartzJob" class="com.lzj.quartz.QuartzJobLauncher"></bean>

    <!-- 配置jobDetail，存放job的一些信息 -->
    <!-- jobLauncher和jobRegistry为在batch-config.xml配置好的bean,在此直接引用即可，前提是配置文件在spring boot工程启动时就要加入容器，这个在测试方法中配置 -->
    <bean id="jobDetail" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
        <property name="jobClass" value="com.lzj.quartz.QuartzJobLauncher"></property>
        <property name="jobDataMap">
            <map>
                <entry key="jobName" value="myJob"></entry>
                <entry key="jobLauncher" value-ref="jobLauncher"></entry>
                <entry key="jobLocator" value-ref="jobRegistry"></entry>
            </map>
        </property>
    </bean>

    <!-- 配置定时 -->
    <bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
        <property name="jobDetail" ref="jobDetail"></property>
        <property name="cronExpression" value="0/3 * * * * ?"></property>
        <property name="startDelay" value="3000"></property>
    </bean>

    <!-- 配置任务，绑定jobDetail和cronTrigger，并启动定时 -->
    <bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="triggers" ref="cronTrigger"></property>
    </bean>

</beans>

5、run ，测试

@SpringBootApplication
public class DemoApplication {
        Set<Object> set = new HashSet<>();
        set.add("classpath:batch-config.xml");
        set.add("classpath:quartz-config.xml");
        SpringApplication app = new SpringApplication(DemoApplication.class);
        app.setSources(set);
        app.run(args);
    }
}

运行该测试方法，输出日志如下：

……
jobName : myJob
jobLauncher : org.springframework.batch.core.launch.support.SimpleJobLauncher@2f67f23b
jobLocator : org.springframework.batch.core.configuration.support.MapJobRegistry@21a009a7
Current Time : 2018-04-12 18:30:33
2018-04-12 18:30:33.731  INFO 24300 --- [           main] s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat started on port(s): 8080 (http)
2018-04-12 18:30:33.741  INFO 24300 --- [           main] com.lzj.DemoApplication                  : Started DemoApplication in 21.408 seconds (JVM running for 22.654)
2018-04-12 18:30:33.746  INFO 24300 --- [eduler_Worker-1] o.s.b.c.l.support.SimpleJobLauncher      : Job: [FlowJob: [name=myJob]] launched with the following parameters: [{date=1523529033562}]
2018-04-12 18:30:33.746  INFO 24300 --- [eduler_Worker-2] o.s.b.c.l.support.SimpleJobLauncher      : Job: [FlowJob: [name=myJob]] launched with the following parameters: [{date=1523529033577}]
2018-04-12 18:30:33.800  INFO 24300 --- [eduler_Worker-2] o.s.batch.core.job.SimpleStepHandler     : Executing step: [myStep]
2018-04-12 18:30:33.801  INFO 24300 --- [eduler_Worker-1] o.s.batch.core.job.SimpleStepHandler     : Executing step: [myStep]
User [id=1, name=lzj, age=27]
User [id=2, name=huwei, age=28]
User [id=3, name=lijie, age=26]
2018-04-12 18:30:33.869  INFO 24300 --- [eduler_Worker-2] o.s.b.c.l.support.SimpleJobLauncher      : Job: [FlowJob: [name=myJob]] completed with the following parameters: [{date=1523529033577}] and the following status: [COMPLETED]
2018-04-12 18:30:33.870  INFO 24300 --- [eduler_Worker-1] o.s.b.c.l.support.SimpleJobLauncher      : Job: [FlowJob: [name=myJob]] completed with the following parameters: [{date=1523529033562}] and the following status: [COMPLETED]
jobName : myJob
jobLauncher : org.springframework.batch.core.launch.support.SimpleJobLauncher@2f67f23b
jobLocator : org.springframework.batch.core.configuration.support.MapJobRegistry@21a009a7
Current Time : 2018-04-12 18:30:36
2018-04-12 18:30:36.027  INFO 24300 --- [eduler_Worker-3] o.s.b.c.l.support.SimpleJobLauncher      : Job: [FlowJob: [name=myJob]] launched with the following parameters: [{date=1523529036006}]
2018-04-12 18:30:36.076  INFO 24300 --- [eduler_Worker-3] o.s.batch.core.job.SimpleStepHandler     : Executing step: [myStep]
User [id=1, name=lzj, age=27]
User [id=2, name=huwei, age=28]
User [id=3, name=lijie, age=26]
2018-04-12 18:30:36.113  INFO 24300 --- [eduler_Worker-3] o.s.b.c.l.support.SimpleJobLauncher      : Job: [FlowJob: [name=myJob]] completed with the following parameters: [{date=1523529036006}] and the following status: [COMPLETED]
jobName : myJob
jobLauncher : org.springframework.batch.core.launch.support.SimpleJobLauncher@2f67f23b
jobLocator : org.springframework.batch.core.configuration.support.MapJobRegistry@21a009a7
Current Time : 2018-04-12 18:30:39
2018-04-12 18:30:39.019  INFO 24300 --- [eduler_Worker-4] o.s.b.c.l.support.SimpleJobLauncher      : Job: [FlowJob: [name=myJob]] launched with the following parameters: [{date=1523529039001}]
2018-04-12 18:30:39.062  INFO 24300 --- [eduler_Worker-4] o.s.batch.core.job.SimpleStepHandler     : Executing step: [myStep]
User [id=1, name=lzj, age=27]
User [id=2, name=huwei, age=28]
User [id=3, name=lijie, age=26]
2018-04-12 18:30:39.103  INFO 24300 --- [eduler_Worker-4] o.s.b.c.l.support.SimpleJobLauncher      : Job: [FlowJob: [name=myJob]] completed with the following parameters: [{date=1523529039001}] and the following status: [COMPLETED]
……

通过日志可以看出，每3s执行一次job任务。

工程目录如下：