原文： https://howtodoinjava.com/spring-batch/batch-quartz-java-config-example/

学习配置Quartz调度程序以运行使用 Spring Boot Java 配置配置的 Spring Batch 作业。 尽管 Spring 的默认调度程序也不错，但是 Quartz 可以更好地并且以更可配置的方式更好地调度和调用任务。 这使 Spring Batch 仅专注于创建批处理作业，而让 Quartz 执行它们。

项目概述和结构

在此带有 Quartz 示例的 SpringBatch 中，我们将创建两个具有不同步骤数的不同批处理作业。 然后，我们将使用夸脱作业数据映射和触发器安排作业执行时间，并在控制台中观察输出。

Spring Batch Quartz Java 配置示例 - 图1

Spring Batch Quartz Java 配置示例

Maven 依赖

Spring Boot 具有对 Quartz 的内置支持，因此您所需要做的就是导入依赖项，例如spring-boot-starter-quartz和spring-boot-starter-batch。

请注意，quartz 需要至少一个数据库来存储作业执行详细信息。 在这个例子中，我使用的是 Spring Boot 支持的H2数据库。 因此也包括'h2'依赖项。

pom.xml

  1. <project xmlns="http://maven.apache.org/POM/4.0.0"
  2.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd;
  4.     <modelVersion>4.0.0</modelVersion>
  6.     <groupId>com.howtodoinjava</groupId>
  7.     <artifactId>App</artifactId>
  8.     <version>0.0.1-SNAPSHOT</version>
  9.     <packaging>jar</packaging>
  11.     <name>App</name>
  12.     <url>http://maven.apache.org</url>
  14.     <parent>
  15.         <groupId>org.springframework.boot</groupId>
  16.         <artifactId>spring-boot-starter-parent</artifactId>
  17.         <version>2.0.3.RELEASE</version>
  18.     </parent>
  20.     <properties>
  21.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  22.     </properties>
  24.     <dependencies>
  25.         <dependency>
  26.             <groupId>org.springframework.boot</groupId>
  27.             <artifactId>spring-boot-starter-batch</artifactId>
  28.         </dependency>
  29.         <dependency>
  30.             <groupId>org.springframework.boot</groupId>
  31.             <artifactId>spring-boot-starter-quartz</artifactId>
  32.         </dependency>
  33.         <dependency>
  34.             <groupId>com.h2database</groupId>
  35.             <artifactId>h2</artifactId>
  36.             <scope>runtime</scope>
  37.         </dependency>
  38.     </dependencies>
  40.     <build>
  41.         <plugins>
  42.             <plugin>
  43.                 <groupId>org.springframework.boot</groupId>
  44.                 <artifactId>spring-boot-maven-plugin</artifactId>
  45.             </plugin>
  46.         </plugins>
  47.     </build>
  49.     <repositories>
  50.         <repository>
  51.             <id>repository.spring.release</id>
  52.             <name>Spring GA Repository</name>
  53.             <url>http://repo.spring.io/release</url>
  54.         </repository>
  55.     </repositories>
  56. </project>

创建具有多个任务的批处理作业

  1. 创建任务


首先创建几个小任务。 这些是在单个批处理作业中一步处理的策略。
MyTaskOne.java

  1. import org.springframework.batch.core.StepContribution;
  2. import org.springframework.batch.core.scope.context.ChunkContext;
  3. import org.springframework.batch.core.step.tasklet.Tasklet;
  4. import org.springframework.batch.repeat.RepeatStatus;
  6. public class MyTaskOne implements Tasklet {
  8.     public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {
  9.         System.out.println("MyTaskOne start..");
  11.         // ... your code
  13.         System.out.println("MyTaskOne done..");
  14.         return RepeatStatus.FINISHED;
  15.     }    
  16. }


MyTaskTwo.java

  1. public class MyTaskTwo implements Tasklet {
  3.     public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {
  4.         System.out.println("MyTaskTwo start..");
  6.         // ... your code
  8.         System.out.println("MyTaskTwo done..");
  9.         return RepeatStatus.FINISHED;
  10.     }    
  11. }

  1. 创建批处理作业


现在创建 SpringBatch，并在其中配置步骤。 我正在创建两个批处理作业。

  • demoJobOne具有 2 个步骤，即stepOne和stepTwo。
  • demoJobTwo和一个步骤，即stepOne。

`BatchConfig.java````java import org.springframework.batch.core.Job; import org.springframework.batch.core.Step; import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing; import org.springframework.batch.core.configuration.annotation.JobBuilderFactory; import org.springframework.batch.core.configuration.annotation.StepBuilderFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration;

import com.howtodoinjava.demo.tasks.MyTaskOne; import com.howtodoinjava.demo.tasks.MyTaskTwo;

@Configuration @EnableBatchProcessing public class BatchConfig {

  1. @Autowired
  2. private JobBuilderFactory jobs;
  4. @Autowired
  5. private StepBuilderFactory steps;
  7. @Bean
  8. public Step stepOne(){
  9.     return steps.get("stepOne")
  10.             .tasklet(new MyTaskOne())
  11.             .build();
  12. }
  14. @Bean
  15. public Step stepTwo(){
  16.     return steps.get("stepTwo")
  17.             .tasklet(new MyTaskTwo())
  18.             .build();
  19. }   
  21. @Bean(name="demoJobOne")
  22. public Job demoJobOne(){
  23.     return jobs.get("demoJobOne")
  24.             .start(stepOne())
  25.             .next(stepTwo())
  26.             .build();
  27. }
  29. @Bean(name="demoJobTwo")
  30. public Job demoJobTwo(){
  31.     return jobs.get("demoJobTwo")
  32.             .flow(stepOne())
  33.             .build()
  34.             .build();
  35. }

}

  2. <a name="4e6ff5de"></a>
  3. ## 使用`QuartzJobBean`创建 Quartz 作业运行器
  5. 现在我们需要创建标准的`QuartzJobBean`实例，该实例将用于执行批处理作业。
  7. `CustomQuartzJob.java`
  9. ```java
  10. import org.quartz.JobExecutionContext;
  11. import org.quartz.JobExecutionException;
  12. import org.springframework.batch.core.Job;
  13. import org.springframework.batch.core.JobParameters;
  14. import org.springframework.batch.core.JobParametersBuilder;
  15. import org.springframework.batch.core.configuration.JobLocator;
  16. import org.springframework.batch.core.launch.JobLauncher;
  17. import org.springframework.scheduling.quartz.QuartzJobBean;
  19. public class CustomQuartzJob extends QuartzJobBean {
  21.     private String jobName;
  22.     private JobLauncher jobLauncher;
  23.     private JobLocator jobLocator;
  25.     public String getJobName() {
  26.         return jobName;
  27.     }
  29.     public void setJobName(String jobName) {
  30.         this.jobName = jobName;
  31.     }
  33.     public JobLauncher getJobLauncher() {
  34.         return jobLauncher;
  35.     }
  37.     public void setJobLauncher(JobLauncher jobLauncher) {
  38.         this.jobLauncher = jobLauncher;
  39.     }
  41.     public JobLocator getJobLocator() {
  42.         return jobLocator;
  43.     }
  45.     public void setJobLocator(JobLocator jobLocator) {
  46.         this.jobLocator = jobLocator;
  47.     }
  49.     @Override
  50.     protected void executeInternal(JobExecutionContext context) throws JobExecutionException 
  51.     {
  52.         try 
  53.         {
  54.             Job job = jobLocator.getJob(jobName);
  55.             JobParameters params = new JobParametersBuilder()
  56.                     .addString("JobID", String.valueOf(System.currentTimeMillis()))
  57.                     .toJobParameters();
  59.             jobLauncher.run(job, params);
  60.         } 
  61.         catch (Exception e) 
  62.         {
  63.             e.printStackTrace();
  64.         }
  65.     }
  66. }

在SchedulerFactoryBean中配置 Quartz 作业详细信息和触发器

  1. 现在可以配置 QuartzJobDetail和triggers，并将它们注册到 spring 的上下文中。
  2. JobDetail实例包含有关QuartzJobBean的信息和要使用JobDataMap注入的信息。
  3. 还创建Trigger实例以配置批处理作业的执行时间和频率。
  4. 最后，在SchedulerFactoryBean中添加作业详细信息和触发器，以配置 Spring 并管理其生命周期（作为 Spring 应用程序上下文的一部分）。 它会在初始化时自动启动调度程序，并在销毁时将其关闭。

QuartzConfig.java

  1. import java.io.IOException;
  2. import java.util.Properties;
  4. import org.quartz.JobBuilder;
  5. import org.quartz.JobDataMap;
  6. import org.quartz.JobDetail;
  7. import org.quartz.SimpleScheduleBuilder;
  8. import org.quartz.Trigger;
  9. import org.quartz.TriggerBuilder;
  10. import org.springframework.batch.core.configuration.JobLocator;
  11. import org.springframework.batch.core.configuration.JobRegistry;
  12. import org.springframework.batch.core.configuration.support.JobRegistryBeanPostProcessor;
  13. import org.springframework.batch.core.launch.JobLauncher;
  14. import org.springframework.beans.factory.annotation.Autowired;
  15. import org.springframework.beans.factory.config.PropertiesFactoryBean;
  16. import org.springframework.context.annotation.Bean;
  17. import org.springframework.context.annotation.Configuration;
  18. import org.springframework.core.io.ClassPathResource;
  19. import org.springframework.scheduling.quartz.SchedulerFactoryBean;
  21. import com.howtodoinjava.demo.jobs.CustomQuartzJob;
  23. @Configuration
  24. public class QuartzConfig 
  25. {
  26.     @Autowired
  27.     private JobLauncher jobLauncher;
  29.     @Autowired
  30.     private JobLocator jobLocator;
  32.     @Bean
  33.     public JobRegistryBeanPostProcessor jobRegistryBeanPostProcessor(JobRegistry jobRegistry) {
  34.         JobRegistryBeanPostProcessor jobRegistryBeanPostProcessor = new JobRegistryBeanPostProcessor();
  35.         jobRegistryBeanPostProcessor.setJobRegistry(jobRegistry);
  36.         return jobRegistryBeanPostProcessor;
  37.     }
  39.     @Bean
  40.     public JobDetail jobOneDetail() {
  41.         //Set Job data map
  42.         JobDataMap jobDataMap = new JobDataMap();
  43.         jobDataMap.put("jobName", "demoJobOne");
  44.         jobDataMap.put("jobLauncher", jobLauncher);
  45.         jobDataMap.put("jobLocator", jobLocator);
  47.         return JobBuilder.newJob(CustomQuartzJob.class)
  48.                 .withIdentity("demoJobOne")
  49.                 .setJobData(jobDataMap)
  50.                 .storeDurably()
  51.                 .build();
  52.     }
  54.     @Bean
  55.     public JobDetail jobTwoDetail() {
  56.         //Set Job data map
  57.         JobDataMap jobDataMap = new JobDataMap();
  58.         jobDataMap.put("jobName", "demoJobTwo");
  59.         jobDataMap.put("jobLauncher", jobLauncher);
  60.         jobDataMap.put("jobLocator", jobLocator);
  62.         return JobBuilder.newJob(CustomQuartzJob.class)
  63.                 .withIdentity("demoJobTwo")
  64.                 .setJobData(jobDataMap)
  65.                 .storeDurably()
  66.                 .build();
  67.     }
  69.     @Bean
  70.     public Trigger jobOneTrigger() 
  71.     {
  72.         SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder
  73.                 .simpleSchedule()
  74.                 .withIntervalInSeconds(10)
  75.                 .repeatForever();
  77.         return TriggerBuilder
  78.                 .newTrigger()
  79.                 .forJob(jobOneDetail())
  80.                 .withIdentity("jobOneTrigger")
  81.                 .withSchedule(scheduleBuilder)
  82.                 .build();
  83.     }
  85.     @Bean
  86.     public Trigger jobTwoTrigger() 
  87.     {
  88.         SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder
  89.                 .simpleSchedule()
  90.                 .withIntervalInSeconds(20)
  91.                 .repeatForever();
  93.         return TriggerBuilder
  94.                 .newTrigger()
  95.                 .forJob(jobTwoDetail())
  96.                 .withIdentity("jobTwoTrigger")
  97.                 .withSchedule(scheduleBuilder)
  98.                 .build();
  99.     }
  101.     @Bean
  102.     public SchedulerFactoryBean schedulerFactoryBean() throws IOException 
  103.     {
  104.         SchedulerFactoryBean scheduler = new SchedulerFactoryBean();
  105.         scheduler.setTriggers(jobOneTrigger(), jobTwoTrigger());
  106.         scheduler.setQuartzProperties(quartzProperties());
  107.         scheduler.setJobDetails(jobOneDetail(), jobTwoDetail());
  108.         return scheduler;
  109.     }
  111.     @Bean
  112.     public Properties quartzProperties() throws IOException 
  113.     {
  114.         PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
  115.         propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
  116.         propertiesFactoryBean.afterPropertiesSet();
  117.         return propertiesFactoryBean.getObject();
  118.     }
  119. }

使用属性文件自定义 Quartz

在 Quartz 中，您可以从简单的属性文件中控制很多东西。 例如

quartz.properties

  1. #scheduler name will be "MyScheduler"
  2. org.quartz.scheduler.instanceName = MyScheduler
  4. #maximum of 3 jobs can be run simultaneously
  5. org.quartz.threadPool.threadCount = 3
  7. #All of Quartz data is held in memory (rather than in a database). 
  8. org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore

示例

在运行应用程序之前，请确保已在application.properties文件中禁用了批处理作业自动启动功能。

application.properties

  1. #Disable batch job's auto start 
  2. spring.batch.job.enabled=false
  4. #enable h2 databse console
  5. spring.h2.console.enabled=true

现在，将该应用程序作为 Spring Batch 应用程序运行，并检查日志。

App.java

  1. import org.springframework.boot.SpringApplication;
  2. import org.springframework.boot.autoconfigure.SpringBootApplication;
  4. @SpringBootApplication
  5. public class App
  6. {
  7.     public static void main(String[] args) 
  8.     {
  9.         SpringApplication.run(App.class, args);
  10.     }
  11. }

Console

  1.   .   ____          _            __ _ _
  2.  /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
  3. ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
  4.  \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  5.   '  |____| .__|_| |_|_| |_\__, | / / / /
  6.  =========|_|==============|___/=/_/_/_/
  7.  :: Spring Boot ::        (v2.0.3.RELEASE)
  9. 2018-07-05 10:50:53 INFO  - Starting App on FFC15B4E9C5AA with PID 9740 (C:\Users\zkpkhua\DigitalDashboard_Integrated\App\target\classes started by zkpkhua in C:\Users\zkpkhua\DigitalDashboard_Integrated\App)
  10. 2018-07-05 10:50:53 INFO  - No active profile set, falling back to default profiles: default
  11. 2018-07-05 10:50:53 INFO  - Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@78b1cc93: startup date [Thu Jul 05 10:50:53 IST 2018]; root of context hierarchy
  12. 2018-07-05 10:50:54 INFO  - Bean 'org.springframework.boot.autoconfigure.jdbc.DataSourceConfiguration$Hikari' of type [org.springframework.boot.autoconfigure.jdbc.DataSourceConfiguration$Hikari] is not eligible for getting processed by all BeanPostProcessors (for example: not eligible for auto-proxying)
  13. 2018-07-05 10:50:54 INFO  - Bean 'org.springframework.transaction.annotation.ProxyTransactionManagementConfiguration' of type [org.springframework.transaction.annotation.ProxyTransactionManagementConfiguration$EnhancerBySpringCGLIB$169797f6] is not eligible for getting processed by all BeanPostProcessors (for example: not eligible for auto-proxying)
  14. 2018-07-05 10:50:54 INFO  - Bean 'org.springframework.boot.context.properties.ConversionServiceDeducer$Factory' of type [org.springframework.boot.context.properties.ConversionServiceDeducer$Factory] is not eligible for getting processed by all BeanPostProcessors (for example: not eligible for auto-proxying)
  15. 2018-07-05 10:50:54 INFO  - Bean 'spring.datasource-org.springframework.boot.autoconfigure.jdbc.DataSourceProperties' of type [org.springframework.boot.autoconfigure.jdbc.DataSourceProperties] is not eligible for getting processed by all BeanPostProcessors (for example: not eligible for auto-proxying)
  16. 2018-07-05 10:50:54 INFO  - Bean 'dataSource' of type [com.zaxxer.hikari.HikariDataSource] is not eligible for getting processed by all BeanPostProcessors (for example: not eligible for auto-proxying)
  17. 2018-07-05 10:50:54 INFO  - Bean 'org.springframework.boot.autoconfigure.jdbc.DataSourceInitializerInvoker' of type [org.springframework.boot.autoconfigure.jdbc.DataSourceInitializerInvoker] is not eligible for getting processed by all BeanPostProcessors (for example: not eligible for auto-proxying)
  18. 2018-07-05 10:50:54 INFO  - Bean 'org.springframework.batch.core.configuration.annotation.SimpleBatchConfiguration' of type [org.springframework.batch.core.configuration.annotation.SimpleBatchConfiguration$EnhancerBySpringCGLIB$165a725c] is not eligible for getting processed by all BeanPostProcessors (for example: not eligible for auto-proxying)
  19. 2018-07-05 10:50:54 INFO  - Bean 'jobLauncher' of type [com.sun.proxy.$Proxy41] is not eligible for getting processed by all BeanPostProcessors (for example: not eligible for auto-proxying)
  20. 2018-07-05 10:50:54 INFO  - Bean 'jobRegistry' of type [com.sun.proxy.$Proxy43] is not eligible for getting processed by all BeanPostProcessors (for example: not eligible for auto-proxying)
  21. 2018-07-05 10:50:54 INFO  - Bean 'quartzConfig' of type [com.howtodoinjava.demo.config.QuartzConfig$EnhancerBySpringCGLIB$7dc0f057] is not eligible for getting processed by all BeanPostProcessors (for example: not eligible for auto-proxying)
  22. 2018-07-05 10:50:55 INFO  - HikariPool-1 - Starting...
  23. 2018-07-05 10:50:55 INFO  - HikariPool-1 - Start completed.
  24. 2018-07-05 10:50:55 INFO  - No database type set, using meta data indicating: H2
  25. 2018-07-05 10:50:55 INFO  - No TaskExecutor has been set, defaulting to synchronous executor.
  26. 2018-07-05 10:50:56 INFO  - Executing SQL script from class path resource [org/quartz/impl/jdbcjobstore/tables_h2.sql]
  27. 2018-07-05 10:50:56 INFO  - Executed SQL script from class path resource [org/quartz/impl/jdbcjobstore/tables_h2.sql] in 69 ms.
  28. 2018-07-05 10:50:56 INFO  - Using default implementation for ThreadExecutor
  29. 2018-07-05 10:50:56 INFO  - Initialized Scheduler Signaller of type: class org.quartz.core.SchedulerSignalerImpl
  30. 2018-07-05 10:50:56 INFO  - Quartz Scheduler v.2.3.0 created.
  31. 2018-07-05 10:50:56 INFO  - RAMJobStore initialized.
  32. 2018-07-05 10:50:56 INFO  - Scheduler meta-data: Quartz Scheduler (v2.3.0) 'schedulerFactoryBean' with instanceId 'NON_CLUSTERED'
  33.   Scheduler class: 'org.quartz.core.QuartzScheduler' - running locally.
  34.   NOT STARTED.
  35.   Currently in standby mode.
  36.   Number of jobs executed: 0
  37.   Using thread pool 'org.quartz.simpl.SimpleThreadPool' - with 3 threads.
  38.   Using job-store 'org.quartz.simpl.RAMJobStore' - which does not support persistence. and is not clustered.
  40. 2018-07-05 10:50:56 INFO  - Quartz scheduler 'schedulerFactoryBean' initialized from an externally provided properties instance.
  41. 2018-07-05 10:50:56 INFO  - Quartz scheduler version: 2.3.0
  42. 2018-07-05 10:50:56 INFO  - JobFactory set to: org.springframework.scheduling.quartz.AdaptableJobFactory@1e7f2e0f
  43. 2018-07-05 10:50:56 INFO  - Executing SQL script from class path resource [org/springframework/batch/core/schema-h2.sql]
  44. 2018-07-05 10:50:56 INFO  - Executed SQL script from class path resource [org/springframework/batch/core/schema-h2.sql] in 30 ms.
  45. 2018-07-05 10:50:57 INFO  - Registering beans for JMX exposure on startup
  46. 2018-07-05 10:50:57 INFO  - Bean with name 'dataSource' has been autodetected for JMX exposure
  47. 2018-07-05 10:50:57 INFO  - Located MBean 'dataSource': registering with JMX server as MBean [com.zaxxer.hikari:name=dataSource,type=HikariDataSource]
  48. 2018-07-05 10:50:57 INFO  - Starting beans in phase 2147483647
  49. 2018-07-05 10:50:57 INFO  - Starting Quartz Scheduler now
  50. 2018-07-05 10:50:57 INFO  - Scheduler schedulerFactoryBean_$_NON_CLUSTERED started.
  51. 2018-07-05 10:50:57 INFO  - Started App in 4.164 seconds (JVM running for 4.941)
  52. 2018-07-05 10:50:57 INFO  - Job: [SimpleJob: [name=demoJobOne]] launched with the following parameters: [{JobID=1530768057055}]
  53. 2018-07-05 10:50:57 INFO  - Job: [FlowJob: [name=demoJobTwo]] launched with the following parameters: [{JobID=1530768057057}]
  54. 2018-07-05 10:50:57 INFO  - Executing step: [stepOne]
  55. MyTaskOne start..
  56. MyTaskOne done..
  57. 2018-07-05 10:50:57 INFO  - Executing step: [stepTwo]
  58. MyTaskTwo start..
  59. MyTaskTwo done..
  60. 2018-07-05 10:50:57 INFO  - Executing step: [stepOne]
  61. 2018-07-05 10:50:57 INFO  - Job: [SimpleJob: [name=demoJobOne]] completed with the following parameters: [{JobID=1530768057055}] and the following status: [COMPLETED]
  62. MyTaskOne start..
  63. MyTaskOne done..
  64. 2018-07-05 10:50:57 INFO  - Job: [FlowJob: [name=demoJobTwo]] completed with the following parameters: [{JobID=1530768057057}] and the following status: [COMPLETED]
  66. 2018-07-05 10:51:05 INFO  - Job: [SimpleJob: [name=demoJobOne]] launched with the following parameters: [{JobID=1530768065955}]
  67. 2018-07-05 10:51:05 INFO  - Executing step: [stepOne]
  68. MyTaskOne start..
  69. MyTaskOne done..
  70. 2018-07-05 10:51:05 INFO  - Executing step: [stepTwo]
  71. MyTaskTwo start..
  72. MyTaskTwo done..
  73. 2018-07-05 10:51:05 INFO  - Job: [SimpleJob: [name=demoJobOne]] completed with the following parameters: [{JobID=1530768065955}] and the following status: [COMPLETED]
  75. 2018-07-05 10:51:15 INFO  - Job: [SimpleJob: [name=demoJobOne]] launched with the following parameters: [{JobID=1530768075955}]
  76. 2018-07-05 10:51:15 INFO  - Executing step: [stepOne]
  77. MyTaskOne start..
  78. MyTaskOne done..
  79. 2018-07-05 10:51:15 INFO  - Executing step: [stepTwo]
  80. MyTaskTwo start..
  81. MyTaskTwo done..
  82. 2018-07-05 10:51:15 INFO  - Job: [SimpleJob: [name=demoJobOne]] completed with the following parameters: [{JobID=1530768075955}] and the following status: [COMPLETED]
  84. 2018-07-05 10:51:15 INFO  - Job: [FlowJob: [name=demoJobTwo]] launched with the following parameters: [{JobID=1530768075980}]
  85. 2018-07-05 10:51:15 INFO  - Executing step: [stepOne]
  86. MyTaskOne start..
  87. MyTaskOne done..
  88. 2018-07-05 10:51:16 INFO  - Job: [FlowJob: [name=demoJobTwo]] completed with the following parameters: [{JobID=1530768075980}] and the following status: [COMPLETED]

显然，两个 Spring Batch 作业都基于在 Quartz 触发器中配置的调度执行。

将我的问题放在评论部分。

学习愉快！