spring batch 学习笔记（3）

• 决策器的使用：

接口：JobExecutionDecider

决策器：

// 创建决策器
@Bean 
public class JobExecutionDecider myDecider{
    return myDecider();
}


// 创建决策器的类
public class myDecider implements JobExecutionDecider {
    
    public FlowExecutionStatus decide(JobExecution arg0,stepExecution arg1){
        return null;
    }
}



// 创建任务，使用决策器
@Bean 
public Job deciderDemoJob(){
    return jobBuilderFactory.get("deciderDemoJob")
            .start(step1())
            .next(myDecider())
             // 如果决策器返回值为 even ,则执行 step2
            .from(myDecider()).on("even").to(step2())
             // 如果决策器返回值为 ood,则执行 step3
            .from(myDecider()).on("ood").to(step3())
              // 不论step3 返回什么结果，再返回到决策器。执行一次step ,然后end() ,结束
            .from(step3()).on("*").to(myDecider())
            .end()
            .build();
            
}

• Job的嵌套

一个Job可以嵌套在另一个Job中，被嵌套的Job称为子Job,外部Job称为父Job,子Job不能单独执行，需要父Job来启动。

// 父Job

public class NestedDemo{
    
    private JobBuilderFactory jobBuilderFactory;

    private StepBuilderFactory stepBuilderFactory;

    public Job parentJob(){
                
        return jobBuilderFactory.get("parentJob")
                .start(childJob1())
                .next(childJob2())
                .build();
    }


    @Autowired
    private Job childJobone;

    @Autowired
    private Job childJobTwo;


    @Autowired
    private JobLauncher jobLauncher;

    // 子Job1 
    // 返回的是Job类型的step, 即特殊的step
    private Step childJob1(JobRepository repository,PlatformTransactionManager platformTransactionManager ){
        
        // 将Job类型转换为Step 类型

        return new JobStepBuiler(new StepBuilder("childJob1"))
                   // 指明要转换的Job对象
                .job(childJobone())
                    // 获取job的启动对象,使用父Job的启动对象
                .launcher(jobLauncher())
                    // 指明持久化存储的对象
                .repository(repository)
                    // 事务管理器
                .platformTransactionManager(platformTransactionManager )
                .build();
    }
    
    //  子Job2 
    // 返回的是Job类型的step, 即特殊的step
    private Step childJob2(){

        // 将Job类型转换为Step 类型

        return new JobStepBuiler(new StepBuilder("childJob2"))
                   // 指明要转换的Job对象
                .job(childJobone())
                    // 获取job的启动对象,使用父Job的启动对象
                .launcher(jobLauncher())
                    // 指明持久化存储的对象
                .repository(repository)
                    // 事务管理器
                .platformTransactionManager(platformTransactionManager )
                .build();
    }
}

在 application.properties 配置文件中，指明需要启动的Job名称：

spring.batch.job.names=parentJob

 

• Job参数

Job运行时可以以 键值对的形式 （key = value） 形式传递参数

下面例子，使用监听给Job传递参数：

public class ParamterDemo implement StepExecutonListener{
    
    private JobBuilderFactory jobBuilderFactory;

    private StepBuilderFactory stepBuilderFactory;
    

    private Map<String,JobParamter> parameters;
    
    @bean
    public Job paramterJob(){
        
        return jobBuilderFactory.get("paramterJob")
                .start(paramterStep())
                .build();
    }
    
    // Job执行的是step,Job使用的数据肯定是在step中使用
    // 那只需要给step传递参数即可
    // 使用监听，使用step 级别的监听传递数据
    public Step paramterStep(){

        return stepBuilderFactory.get("paramterStep")
                // 当前类已经创建了监听,所以使用当前类来监听
                .listener(this)
                .tasklet(new Tasklet(){
                 
                public RepeatStatus execute(arg0,arg1){
                    
                    sout(parameters.get("info"));
                    return RepeatStatus.Finsish;
            }
        }).build();
    }
    
    @override
    public void beforeStep(StepExecution stepExecution ){
           paramters = stepExecution. getJobParameters().getParmeters()
    }
    
    @override
    public void beforeStep(StepExecution arg0){

    }
}