Java Examples for org.springframework.batch.core.step.tasklet.Tasklet

@Test
public void testExecute() throws Exception {
    Tasklet tasklet = new Tasklet() {

        public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {
            return RepeatStatus.FINISHED;
        }
    };
    StepContribution contribution = Mockito.mock(StepContribution.class);
    StepExecution stepExecution = createStepExecution("testExecuteJob", "testExecuteStep");
    StepContext stepContext = Mockito.mock(StepContext.class);
    Mockito.when(stepContext.getStepExecution()).thenReturn(stepExecution);
    ChunkContext chunkContext = Mockito.mock(ChunkContext.class);
    Mockito.when(chunkContext.getStepContext()).thenReturn(stepContext);
    tasklet.execute(contribution, chunkContext);
    Operation op = assertOperationDetails(getFirstEntered(), "execute", stepExecution.getStepName());
    assertOperationPath(op, stepExecution);
}

/**
	 * Create a new chunk oriented tasklet with reader, writer and processor as provided.
	 *
	 * @see org.springframework.batch.core.step.builder.SimpleStepBuilder#createTasklet()
	 */
@Override
protected Tasklet createTasklet() {
    Assert.state(getReader() != null, "ItemReader must be provided");
    Assert.state(getProcessor() != null || getWriter() != null, "ItemWriter or ItemProcessor must be provided");
    addSpecialExceptions();
    registerSkipListeners();
    ChunkProvider<I> chunkProvider = createChunkProvider();
    ChunkProcessor<I> chunkProcessor = createChunkProcessor();
    ChunkOrientedTasklet<I> tasklet = new ChunkOrientedTasklet<I>(chunkProvider, chunkProcessor);
    tasklet.setBuffering(!isReaderTransactionalQueue());
    return tasklet;
}

@Before
public void init() throws Exception {
    this.context.register(BatchConfiguration.class);
    this.context.refresh();
    JobRepository jobRepository = this.context.getBean(JobRepository.class);
    this.jobLauncher = this.context.getBean(JobLauncher.class);
    this.jobs = new JobBuilderFactory(jobRepository);
    PlatformTransactionManager transactionManager = this.context.getBean(PlatformTransactionManager.class);
    this.steps = new StepBuilderFactory(jobRepository, transactionManager);
    this.step = this.steps.get("step").tasklet(new Tasklet() {

        @Override
        public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {
            return null;
        }
    }).build();
    this.job = this.jobs.get("job").start(this.step).build();
    this.jobExplorer = this.context.getBean(JobExplorer.class);
    this.runner = new JobLauncherCommandLineRunner(this.jobLauncher, this.jobExplorer);
    this.context.getBean(BatchConfiguration.class).clear();
}

@Bean
public Step step1() {
    return stepBuilderFactory.get("step1").tasklet(new Tasklet() {

        @Override
        public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {
            System.out.println("Hello Spring XD!");
            return RepeatStatus.FINISHED;
        }
    }).build();
}

@Override
public RepeatStatus execute(final StepContribution contribution, final ChunkContext chunkContext) throws Exception {
    // set contextual data in JobExecutionContext
    chunkContext.getStepContext().getStepExecution().getJobExecution().getExecutionContext().put("concepts", this.concepts);
    log.info("Tasklet execution >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
    //                Thread.sleep(14000L);
    return RepeatStatus.FINISHED;
}

@Before
public void init() throws Exception {
    context.register(BatchConfiguration.class);
    context.refresh();
    JobRepository jobRepository = context.getBean(JobRepository.class);
    jobLauncher = context.getBean(JobLauncher.class);
    jobs = new JobBuilderFactory(jobRepository);
    PlatformTransactionManager transactionManager = this.context.getBean(PlatformTransactionManager.class);
    steps = new StepBuilderFactory(jobRepository, transactionManager);
    step = steps.get("step").tasklet(new Tasklet() {

        @Override
        public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {
            return null;
        }
    }).build();
    job = jobs.get("job").start(step).build();
    jobExplorer = context.getBean(JobExplorer.class);
    runner = new YarnJobLauncher();
    runner.setJobLauncher(jobLauncher);
    runner.setJobExplorer(jobExplorer);
    context.getBean(BatchConfiguration.class).clear();
}

/**
	 * Builds a {@link ChunkHandler} from the {@link ChunkProcessor} extracted from the {@link #setStep(TaskletStep)
	 * step} provided. Also modifies the step to send chunks to the chunk handler via the
	 * {@link #setChunkWriter(ItemWriter) chunk writer}.
	 * 
	 * @see FactoryBean#getObject()
	 */
public ChunkProcessor<T> getObject() throws Exception {
    if (stepContributionSource == null) {
        Assert.state(chunkWriter instanceof StepContributionSource, "The chunk writer must be a StepContributionSource or else the source must be provided explicitly");
        stepContributionSource = (StepContributionSource) chunkWriter;
    }
    Assert.state(step instanceof TaskletStep, "Step [" + step.getName() + "] must be a TaskletStep");
    logger.debug("Converting TaskletStep with name=" + step.getName());
    Tasklet tasklet = getTasklet((TaskletStep) step);
    Assert.state(tasklet instanceof ChunkOrientedTasklet<?>, "Tasklet must be ChunkOrientedTasklet in step=" + step.getName());
    ChunkProcessor<T> chunkProcessor = getChunkProcessor((ChunkOrientedTasklet<?>) tasklet);
    Assert.state(chunkProcessor != null, "ChunkProcessor must be accessible in Tasklet in step=" + step.getName());
    //		System.out.println("====="+chunkWriter.getClass());
    //		setField(chunkWriter, "chunkProcessor", chunkProcessor);
    //		if (Proxy.isProxyClass(chunkWriter.getClass())){
    //			InvocationHandler ih = Proxy.getInvocationHandler(chunkWriter);
    //			Class[] cls = new Class[]{ChunkProcessor.class};
    //			Method m = MyChunkMessageChannelItemWriter.class.getMethod("setChunkProcessor", cls);
    //			try {
    //				ih.invoke(chunkWriter, m, new Object[]{chunkProcessor});
    //			} catch (Throwable e) {
    //				// TODO Auto-generated catch block
    //				e.printStackTrace();
    //			}
    //		} else {
    //			((MyChunkMessageChannelItemWriter<T>)chunkWriter).setChunkProcessor(chunkProcessor);
    //		}
    ItemWriter<T> itemWriter = getItemWriter(chunkProcessor);
    Assert.state(!(itemWriter instanceof ChunkMessageChannelItemWriter<?>), "Cannot adapt step [" + step.getName() + "] because it already has a remote chunk writer.  Use a local writer in the step.");
    replaceChunkProcessor((ChunkOrientedTasklet<?>) tasklet, chunkWriter, stepContributionSource);
    if (chunkWriter instanceof StepExecutionListener) {
        step.registerStepExecutionListener((StepExecutionListener) chunkWriter);
    }
    ChunkProcessorChunkHandler<T> handler = new ChunkProcessorChunkHandler<T>();
    setNonBuffering(chunkProcessor);
    handler.setChunkProcessor(chunkProcessor);
    // TODO: create step context for the processor in case it has
    // scope="step" dependencies
    handler.afterPropertiesSet();
    return chunkProcessor;
}

@Deprecated
public void schedule(final String jobName, Date initialTime, long delay, JobRegistry jobRegistry, final JobRepository jobRepository, Map<String, Object> jobData, ResourcelessTransactionManager transactionManager) throws TaskSystemException {
    try {
        final TaskletStep step = new TaskletStep();
        step.setName(jobName);
        Tasklet tasklet = (Tasklet) Class.forName(BATCH_JOB_CLASS_PATH_PREFIX + getHelperName(jobName)).newInstance();
        step.setTasklet(tasklet);
        step.setJobRepository(jobRepository);
        step.setTransactionManager(transactionManager);
        step.afterPropertiesSet();
        jobRegistry.register(new JobFactory() {

            @Override
            public Job createJob() {
                SimpleJob job = new SimpleJob(jobName + "Job");
                job.setJobRepository(jobRepository);
                job.setRestartable(true);
                job.registerJobExecutionListener(new BatchJobListener());
                job.addStep(step);
                return job;
            }

            @Override
            public String getJobName() {
                return jobName + "Job";
            }
        });
    } catch (Exception e) {
        throw new TaskSystemException(e);
    }
    JobDetailBean jobDetailBean = new JobDetailBean();
    jobDetailBean.setJobDataAsMap(jobData);
    try {
        jobDetailBean.setJobClass(Class.forName(BATCH_JOB_CLASS_PATH_PREFIX + jobName));
    } catch (ClassNotFoundException cnfe) {
        throw new TaskSystemException(cnfe);
    }
    jobDetailBean.setName(jobName + "Job");
    jobDetailBean.setGroup(Scheduler.DEFAULT_GROUP);
    jobDetailBean.afterPropertiesSet();
    SimpleTrigger trigger = new SimpleTrigger();
    trigger.setName(jobName + "Job");
    trigger.setGroup(Scheduler.DEFAULT_GROUP);
    trigger.setStartTime(initialTime);
    trigger.setRepeatInterval(delay);
    trigger.setRepeatCount(SimpleTrigger.REPEAT_INDEFINITELY);
    try {
        scheduler.scheduleJob(jobDetailBean, trigger);
    } catch (SchedulerException se) {
        throw new TaskSystemException(se);
    }
}

@Deprecated
public void schedule(final String jobName, Date initialTime, long delay, JobRegistry jobRegistry, final JobRepository jobRepository, Map<String, Object> jobData, ResourcelessTransactionManager transactionManager) throws TaskSystemException {
    try {
        final TaskletStep step = new TaskletStep();
        step.setName(jobName);
        Tasklet tasklet = (Tasklet) Class.forName(BATCH_JOB_CLASS_PATH_PREFIX + getHelperName(jobName)).newInstance();
        step.setTasklet(tasklet);
        step.setJobRepository(jobRepository);
        step.setTransactionManager(transactionManager);
        step.afterPropertiesSet();
        jobRegistry.register(new JobFactory() {

            @Override
            public Job createJob() {
                SimpleJob job = new SimpleJob(jobName + "Job");
                job.setJobRepository(jobRepository);
                job.setRestartable(true);
                job.registerJobExecutionListener(new BatchJobListener());
                job.addStep(step);
                return job;
            }

            @Override
            public String getJobName() {
                return jobName + "Job";
            }
        });
    } catch (Exception e) {
        throw new TaskSystemException(e);
    }
    JobDetailBean jobDetailBean = new JobDetailBean();
    jobDetailBean.setJobDataAsMap(jobData);
    try {
        jobDetailBean.setJobClass(Class.forName(BATCH_JOB_CLASS_PATH_PREFIX + jobName));
    } catch (ClassNotFoundException cnfe) {
        throw new TaskSystemException(cnfe);
    }
    jobDetailBean.setName(jobName + "Job");
    jobDetailBean.setGroup(Scheduler.DEFAULT_GROUP);
    jobDetailBean.afterPropertiesSet();
    SimpleTrigger trigger = new SimpleTrigger();
    trigger.setName(jobName + "Job");
    trigger.setGroup(Scheduler.DEFAULT_GROUP);
    trigger.setStartTime(initialTime);
    trigger.setRepeatInterval(delay);
    trigger.setRepeatCount(SimpleTrigger.REPEAT_INDEFINITELY);
    try {
        scheduler.scheduleJob(jobDetailBean, trigger);
    } catch (SchedulerException se) {
        throw new TaskSystemException(se);
    }
}

public Tasklet getTasklet() {
    return tasklet;
}

@Bean
protected Tasklet tasklet() {
    return new PrintTasklet();
}

protected TaskletStep createTaskletStep(String name, Tasklet tasklet) {
    TaskletStep ts = new TaskletStep(name);
    ts.setJobRepository(jobRepository);
    ts.setTransactionManager(transactionManager);
    ts.setTasklet(tasklet);
    return ts;
}