Java Spring Boot如何运行批处理作业

我用靴子跟着春天的一批

当运行main方法时，将执行作业。 这样一来，我就不知道如何控制作业的执行。例如，如何安排作业，如何访问作业执行，如何设置作业参数

我试着注册我自己的JobLauncher

@Bean
public JobLauncher jobLauncher(JobRepository jobRepo){
    SimpleJobLauncher simpleJobLauncher = new SimpleJobLauncher();
    simpleJobLauncher.setJobRepository(jobRepo);
    return simpleJobLauncher;
}

但当我尝试在主要方法中使用它时：

public static void main(String[] args) {
    ConfigurableApplicationContext ctx = SpringApplication.run(Application.class, args);    
    JobLauncher jobLauncher = ctx.getBean(JobLauncher.class);
    //try catch removed for readability
    jobLauncher.run(ctx.getBean(Job.class), new JobParameters());   
}

加载上下文时会再次执行作业，当我尝试手动运行作业时，会得到

JobInstanceAlreadyCompleteException

。

---

有没有办法阻止自动作业执行？

可以通过设置

spring.batch.job.enabled=false

在application.properties中。或者，您可以使用

spring.batch.job.names

它接受将要运行的作业名称的逗号分隔列表

---

从此处开始：

您可以使用rest控制器POST启用作业执行：

@RestController
@RequestMapping(value="/job/")
public class JobLauncherController {

    private static final Log LOG = LogFactory.getLog(JobLauncherController.class);

    @Autowired
    private JobLauncher jobLauncher;

    @Autowired
    private Job job;

    @Autowired
    private JobRepository jobRepository;

    @Autowired
    private JobRegistry jobRegistry;

    @RequestMapping("/launchjob/{jobName}")
    public String handle(@PathVariable("jobName") String jobName, @RequestBody Map<String,Object> request) throws Exception {
        try {           
            request.put("timeJobStarted", DateUtil.getDateFormatted(new Date(), DateUtil.DATE_UUUUMMDDHHMMSS));
            Map<String,Object> mapMessage = this.enrichJobMessage(request);
            Map<String, JobParameter> jobParameters = new HashMap<>();
            mapMessage.forEach((k,v)->{
                MapperUtil.castParameter(jobParameters, k, v);
            });
            jobParameters.put(Field.Batch.JOB_INSTANCE_NAME, new JobParameter(jobName));
            jobLauncher.run(job, new JobParameters(jobParameters));
            assertNotNull(jobRegistry.getJob(job.getName()));
        }catch( NoSuchJobException ex){
            jobRegistry.register(new ReferenceJobFactory(job));
        } catch (Exception e) {
            LOG.error(e.getMessage(),e);
        }

        return "Done";
    }

public static void castParameter(Map<String, JobParameter> jobParameters, String k, Object v){
    if(v instanceof String){
        jobParameters.put(k, new JobParameter((String)v));
    }else if(v instanceof Date){
        jobParameters.put(k, new JobParameter((Date)v));
    }else if(v instanceof Double){
        jobParameters.put(k, new JobParameter((Double)v));
    }else if(v instanceof Long){
        jobParameters.put(k, new JobParameter((Long)v));
    }else{
        DslJson dslJson = new DslJson<>();          
        JsonWriter writer = dslJson.newWriter();
        try {
            dslJson.serialize(writer,v);
            jobParameters.put(k, new JobParameter(writer.toString()));
        } catch (IOException e) {
            LOG.warn(e.getMessage(), e);
        }                       
    }
}

}

@RestController
@请求映射（value=“/job/”）
公共类作业控制器{
私有静态最终日志日志=LogFactory.getLog（JobLauncherController.class）；
@自动连线
私有JobLauncher JobLauncher；
@自动连线
私人工作；
@自动连线
私有作业库作业库；
@自动连线
私人工作登记处；
@请求映射（“/launchjob/{jobName}”）
公共字符串句柄（@PathVariable（“jobName”）字符串jobName，@RequestBody映射请求）引发异常{
试试{
put（“timeJobStarted”，DateUtil.getDateFormatted（new Date（），DateUtil.Date_uuummddhmmss））；
Map mapMessage=this.enrichJobMessage（请求）；
Map jobParameters=new HashMap（）；
mapMessage.forEach（（k，v）->{
MapperUtil.castParameter（作业参数，k，v）；
});
jobParameters.put（Field.Batch.JOB_实例_名称，new JobParameter（jobName））；
运行（作业，新作业参数（作业参数））；
assertNotNull（jobRegistry.getJob（job.getName（））；
}捕获（NoSuchJobException-ex）{
jobRegistry.register（新引用JobFactory（作业））；
}捕获（例外e）{
LOG.error（e.getMessage（），e）；
}
返回“完成”；
}
公共静态参数（映射作业参数、字符串k、对象v）{
if（v instanceof String）{
put（k，newjobParameter（（String）v））；
}else if（v instanceof Date）{
jobParameters.put（k，新的JobParameter（（日期）v））；
}else if（v instanceof Double）{
放置（k，新作业参数（（双）v））；
}else if（v instanceof Long）{
放置（k，新作业参数（（长）v））；
}否则{
DslJson=新的DslJson（）；
JsonWriter=dslJson.newWriter（）；
试一试{
序列化（writer，v）；
jobParameters.put（k，新的JobParameter（writer.toString（））；
}捕获（IOE异常）{
LOG.warn（e.getMessage（），e）；
}                       
}
}
}

我尝试了spring.batch.job.enabled=false，并使用java sys属性-Dspring.batch.job.enabled=false运行jar，但它仍然执行作业。如何调试它，我没有clue@AnujAcharya你可以问一个关于它的问题，在那里你可以提供关于这个问题的更多细节（比如spring版本）并分享一些代码