@Before
  public void init() {
    taskletStep = new TaskletStep();
    taskletStep.setTasklet(new ExceptionTasklet());
    jobRepository = new UpdateCountingJobRepository();
    taskletStep.setJobRepository(jobRepository);
    taskletStep.setTransactionManager(new ResourcelessTransactionManager());

    JobInstance jobInstance = new JobInstance(1L, new JobParameters(), "testJob");
    JobExecution jobExecution = new JobExecution(jobInstance);
    stepExecution = new StepExecution("testStep", jobExecution);
  }
  private SimpleJob importProductsJob() throws Exception {
    // Create Job
    SimpleJob bean = new SimpleJob();
    bean.setName("importProductsJob");
    bean.setJobRepository(jobRepository);
    bean.afterPropertiesSet();

    // Create Steps
    List<Step> steps = new ArrayList<Step>();

    // Create Tasklet Step
    TaskletStep step = new TaskletStep();
    step.setName("importProducts");
    step.setTransactionManager(transactionManager);
    step.setJobRepository(jobRepository);
    step.setStartLimit(100);

    // Create repeat template for Chunk Size
    RepeatTemplate repeatTemplate = new TaskExecutorRepeatTemplate();
    repeatTemplate.setCompletionPolicy(new SimpleCompletionPolicy(5));
    // TaskletStep <- RepeatTemplate
    step.setStepOperations(repeatTemplate);

    // Create Chunk Tasklet with Provider (reader) and Chunk Processor
    // Tasklet <- ChunkProvider <- ItemReader, RepeatTemplate
    // Tasklet <- ChunkProcessor <- ItemProcessor, ItemWriter
    ChunkOrientedTasklet<Product> tasklet =
        new ChunkOrientedTasklet<Product>(
            new SimpleChunkProvider<Product>(productReader(), repeatTemplate),
            new SimpleChunkProcessor<Product, Product>(
                new PassThroughItemProcessor<Product>(), new ProductItemLoggerWriter()));

    // Job <- Steps <- TaskletStep <- Tasklet
    step.setTasklet(tasklet);
    // Job <- Steps <- TaskletStep
    steps.add(step);
    // Job <- Steps
    bean.setSteps(steps);
    return bean;
  }
  @Test
  public void testUpdateError() throws Exception {

    final RuntimeException exception = new RuntimeException();
    taskletStep.setJobRepository(
        new UpdateCountingJobRepository() {
          boolean firstCall = true;

          @Override
          public void update(StepExecution arg0) {
            if (firstCall) {
              firstCall = false;
              return;
            }
            throw exception;
          }
        });

    taskletStep.execute(stepExecution);
    assertEquals(UNKNOWN, stepExecution.getStatus());
    assertTrue(stepExecution.getFailureExceptions().contains(exception));
    assertTrue(stepExecution.getFailureExceptions().contains(taskletException));
  }
示例#4
0
  @Deprecated
  public void scheduleLoanArrearsAndPortfolioAtRisk(
      Date initialTime,
      long delay,
      JobRegistry jobRegistry,
      final JobRepository jobRepository,
      Map<String, Object> jobData,
      ResourcelessTransactionManager transactionManager)
      throws TaskSystemException {
    final String jobName = "LoanArrearsAndPortfolioAtRiskTask";
    try {
      final TaskletStep step1 = new TaskletStep();
      step1.setName("LoanArrearsAndPortfolioAtRiskTask-step-1");
      step1.setTasklet(
          (Tasklet)
              Class.forName(BATCH_JOB_CLASS_PATH_PREFIX + getHelperName("LoanArrearsTask"))
                  .newInstance());
      step1.setJobRepository(jobRepository);
      step1.setTransactionManager(transactionManager);
      step1.afterPropertiesSet();

      final TaskletStep step2 = new TaskletStep();
      step2.setName("LoanArrearsAndPortfolioAtRiskTask-step-2");
      step2.setTasklet(
          (Tasklet)
              Class.forName(BATCH_JOB_CLASS_PATH_PREFIX + getHelperName("PortfolioAtRiskTask"))
                  .newInstance());
      step2.setJobRepository(jobRepository);
      step2.setTransactionManager(transactionManager);
      step2.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(step1);
              job.addStep(step2);
              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 + "PortfolioAtRiskTask"));
    } 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);
    }
  }