Java 类org.springframework.batch.core.JobParameter 实例源码

@Test
public void testCreateGenericArchive() throws NoSuchJobException,
JobExecutionAlreadyRunningException, JobRestartException,
JobInstanceAlreadyCompleteException, JobParametersInvalidException, IOException {
    Map<String, JobParameter> parameters =
            new HashMap<String, JobParameter>();

    JobParameters jobParameters = new JobParameters(parameters);

    Job palmwebArchive = jobLocator.getJob("PalmWeb");
    assertNotNull("Palmweb must not be null",  palmwebArchive);
    JobExecution jobExecution = jobLauncher.run(palmwebArchive, jobParameters);
    assertEquals("The job should complete successfully",jobExecution.getExitStatus().getExitCode(),"COMPLETED");
    for (StepExecution stepExecution : jobExecution.getStepExecutions()) {
        logger.info(stepExecution.getStepName() + " "
                + stepExecution.getReadCount() + " "
                + stepExecution.getFilterCount() + " "
                + stepExecution.getWriteCount() + " " + stepExecution.getCommitCount());
    }
}

protected Parameter convertParameterEntryToParameter(Map.Entry<String, JobParameter> entry) {
    Parameter paramToAdd = new Parameter().setKey(entry.getKey());
    JobParameter parameter = entry.getValue();
    if (parameter.getType() == JobParameter.ParameterType.DATE) {
        paramToAdd.setParameterType(ParameterType.DATE);
        Date param = (Date) parameter.getValue();
        if (param != null) {
            paramToAdd.value(DateUtil.getDate(param));
        }
        return paramToAdd;
    }
    return paramToAdd
            .value(parameter.getValue().toString())
            .parameterType(parameter.getType() == JobParameter.ParameterType.STRING ?
                                   ParameterType.STRING : ParameterType.NUMBER);
}

private static void createSampleJob(String jobName, int jobExecutionCount) {
    JobInstance instance = jobRepository.createJobInstance(jobName, new JobParameters());
    jobInstances.add(instance);
    TaskExecution taskExecution = dao.createTaskExecution(jobName, new Date(), new ArrayList<String>(), null);
    Map<String, JobParameter> jobParameterMap = new HashMap<>();
    jobParameterMap.put("foo", new JobParameter("FOO", true));
    jobParameterMap.put("bar", new JobParameter("BAR", false));
    JobParameters jobParameters = new JobParameters(jobParameterMap);
    JobExecution jobExecution = null;
    for (int i = 0; i < jobExecutionCount; i++) {
        jobExecution = jobRepository.createJobExecution(instance, jobParameters, null);
        taskBatchDao.saveRelationship(taskExecution, jobExecution);
        StepExecution stepExecution = new StepExecution("foobar", jobExecution);
        jobRepository.add(stepExecution);
    }
}

private void assertCorrectMixins(RestTemplate restTemplate) {
    boolean containsMappingJackson2HttpMessageConverter = false;

    for (HttpMessageConverter<?> converter : restTemplate.getMessageConverters()) {
        if (converter instanceof MappingJackson2HttpMessageConverter) {
            containsMappingJackson2HttpMessageConverter = true;

            final MappingJackson2HttpMessageConverter jacksonConverter = (MappingJackson2HttpMessageConverter) converter;
            final ObjectMapper objectMapper = jacksonConverter.getObjectMapper();

            assertNotNull(objectMapper.findMixInClassFor(JobExecution.class));
            assertNotNull(objectMapper.findMixInClassFor(JobParameters.class));
            assertNotNull(objectMapper.findMixInClassFor(JobParameter.class));
            assertNotNull(objectMapper.findMixInClassFor(JobInstance.class));
            assertNotNull(objectMapper.findMixInClassFor(ExitStatus.class));
            assertNotNull(objectMapper.findMixInClassFor(StepExecution.class));
            assertNotNull(objectMapper.findMixInClassFor(ExecutionContext.class));
            assertNotNull(objectMapper.findMixInClassFor(StepExecutionHistory.class));
        }
    }

    if (!containsMappingJackson2HttpMessageConverter) {
        fail("Expected that the restTemplate's list of Message Converters contained a "
                + "MappingJackson2HttpMessageConverter");
    }
}

/**
 * @param jobId
 *            Set the job id
 * @param jobName
 *            Set the job name
 * @param authorityName
 *            Set the authority name
 * @param version
 *            Set the version
 */
public void createJobInstance(String jobId,
        String jobName, String authorityName,
        String version) {
    enableAuthentication();
    Long id = null;
    if (jobId != null && jobId.length() > 0) {
        id = Long.parseLong(jobId);
    }
    Integer v = null;
    if (version != null && version.length() > 0) {
        v = Integer.parseInt(version);
    }
    Map<String, JobParameter> jobParameterMap = new HashMap<String, JobParameter>();

    if (authorityName != null && authorityName.length() > 0) {
        jobParameterMap.put("authority.name", new JobParameter(
                authorityName));
    }
    JobParameters jobParameters = new JobParameters(jobParameterMap);
    JobInstance jobInstance = new JobInstance(id, jobParameters, jobName);
    jobInstance.setVersion(v);
    data.push(jobInstance);
    jobInstanceService.save(jobInstance);
    disableAuthentication();
}

@Override
public void launch(JobLaunchRequest request) {
    Job job;
    try {
        job = jobLocator.getJob(request.getJob());
        Map<String, JobParameter> jobParameterMap = new HashMap<String, JobParameter>();
        for(String parameterName : request.getParameters().keySet()) {
            jobParameterMap.put(parameterName, new JobParameter(request.getParameters().get(parameterName)));
        }
        JobParameters jobParameters = new JobParameters(jobParameterMap);
        try {
            jobLauncher.run(job, jobParameters);
        } catch (JobExecutionAlreadyRunningException jeare) {
            jobStatusNotifier.notify(new JobExecutionException(jeare.getLocalizedMessage()), request.getParameters().get("resource.identifier"));
        } catch (JobRestartException jre) {
            jobStatusNotifier.notify(new JobExecutionException(jre.getLocalizedMessage()), request.getParameters().get("resource.identifier"));
        } catch (JobInstanceAlreadyCompleteException jiace) {
            jobStatusNotifier.notify(new JobExecutionException(jiace.getLocalizedMessage()), request.getParameters().get("resource.identifier"));
        } catch (JobParametersInvalidException jpie) {
            jobStatusNotifier.notify(new JobExecutionException(jpie.getLocalizedMessage()), request.getParameters().get("resource.identifier"));
        }
    } catch (NoSuchJobException nsje) {
        jobStatusNotifier.notify(new JobExecutionException(nsje.getLocalizedMessage()), request.getParameters().get("resource.identifier"));
    }
}

/**
 * @throws Exception
 */
@Test
public void testWriteTaxonFile() throws Exception {
    Map<String, JobParameter> parameters = new HashMap<String, JobParameter>();
    parameters.put("query", new JobParameter(""));
    parameters.put("selected.facets", new JobParameter("taxon.family_ss=Araceae"));
    parameters.put("download.taxon", new JobParameter(toParameter(DarwinCorePropertyMap.getConceptTerms(DwcTerm.Taxon))));
    parameters.put("download.file", new JobParameter(UUID.randomUUID().toString() + ".txt"));
    parameters.put("download.limit", new JobParameter(new Integer(Integer.MAX_VALUE).toString()));
    parameters.put("download.fieldsTerminatedBy", new JobParameter("\t"));
    parameters.put("download.fieldsEnclosedBy", new JobParameter("\""));
    parameters.put("download.format", new JobParameter("taxon"));

    JobParameters jobParameters = new JobParameters(parameters);
    Job archiveCreatorJob = jobLocator.getJob("FlatFileCreation");
    assertNotNull("flatFileCreatorJob must exist", archiveCreatorJob);
    JobExecution jobExecution = jobLauncher.run(archiveCreatorJob,
            jobParameters);

    assertEquals("The Job should be sucessful", ExitStatus.COMPLETED, jobExecution.getExitStatus());
}

@Test
public void testWriteChecklistPdf() throws Exception {
    Map<String, JobParameter> parameters = new HashMap<String, JobParameter>();
    parameters.put("query", new JobParameter(""));
    parameters.put("selected.facets", new JobParameter("taxon.family_ss=Araceae"));
    parameters.put("download.taxon", new JobParameter(toParameter(DarwinCorePropertyMap.getConceptTerms(DwcTerm.Taxon))));
    parameters.put("download.file", new JobParameter(UUID.randomUUID().toString() + ".pdf"));
    parameters.put("download.limit", new JobParameter(new Integer(Integer.MAX_VALUE).toString()));
    parameters.put("download.fieldsTerminatedBy", new JobParameter("\t"));
    parameters.put("download.fieldsEnclosedBy", new JobParameter("\""));
    parameters.put("download.sort", new JobParameter("searchable.label_sort_asc"));
    parameters.put("download.format", new JobParameter("hierarchicalChecklist"));
    parameters.put("download.template.filepath", new JobParameter("org/emonocot/job/download/reports/name_report1.jrxml"));

    JobParameters jobParameters = new JobParameters(parameters);
    Job archiveCreatorJob = jobLocator.getJob("FlatFileCreation");
    assertNotNull("flatFileCreator Job must exist", archiveCreatorJob);
    JobExecution jobExecution = jobLauncher.run(archiveCreatorJob,
            jobParameters);

    assertEquals("The Job should be sucessful", ExitStatus.COMPLETED, jobExecution.getExitStatus());
}

/**
 *
 * @throws IOException
 *             if a temporary file cannot be created.
 * @throws NoSuchJobException
 *             if SpeciesPageHarvestingJob cannot be located
 * @throws JobParametersInvalidException
 *             if the job parameters are invalid
 * @throws JobInstanceAlreadyCompleteException
 *             if the job has already completed
 * @throws JobRestartException
 *             if the job cannot be restarted
 * @throws JobExecutionAlreadyRunningException
 *             if the job is already running
 */
@Test
public final void testNotModifiedResponse() throws IOException,
NoSuchJobException, JobExecutionAlreadyRunningException,
JobRestartException, JobInstanceAlreadyCompleteException,
JobParametersInvalidException {
    Map<String, JobParameter> parameters = new HashMap<String, JobParameter>();
    parameters.put("query.string", new JobParameter("select i from Image i"));

    JobParameters jobParameters = new JobParameters(parameters);

    Job job = jobLocator.getJob("ImageProcessing");
    assertNotNull("ImageProcessing must not be null", job);
    JobExecution jobExecution = jobLauncher.run(job, jobParameters);
    assertEquals("The job should complete successfully",jobExecution.getExitStatus().getExitCode(),"COMPLETED");

    for (StepExecution stepExecution : jobExecution.getStepExecutions()) {
        logger.info(stepExecution.getStepName() + " "
                + stepExecution.getReadCount() + " "
                + stepExecution.getFilterCount() + " "
                + stepExecution.getWriteCount());
    }
}

/**
 *
 * @throws Exception
 *             if there is a problem serializing the object
 */
@Test
public void testWriteJobInstance() throws Exception {
    Map<String, JobParameter> jobParameterMap
    = new HashMap<String, JobParameter>();
    jobParameterMap.put("authority.name", new JobParameter("test"));
    JobInstance jobInstance = new JobInstance(1L, new JobParameters(
            jobParameterMap), "testJob");
    jobInstance.setVersion(1);

    try {
        objectMapper.writeValueAsString(jobInstance);
    } catch (Exception e) {
        fail("No exception expected here");
    }

}

@Override
public void launch(JobLaunchRequest request) {
    Job job;
    try {
        job = jobLocator.getJob(request.getJob());
        Map<String, JobParameter> jobParameterMap = new HashMap<String, JobParameter>();
        for(String parameterName : request.getParameters().keySet()) {
            jobParameterMap.put(parameterName, new JobParameter(request.getParameters().get(parameterName)));
        }

        JobParameters jobParameters = new JobParameters(jobParameterMap);
        jobLauncher.run(job, jobParameters);
    } catch (NoSuchJobException 
            | JobExecutionAlreadyRunningException
            | JobRestartException
            | JobInstanceAlreadyCompleteException
            | JobParametersInvalidException exception) {
            jobStatusNotifier.notify(new JobExecutionException(exception.getLocalizedMessage()), request.getParameters().get("job.configuration.id"));
    }
}

/**
 * @throws Exception
 */
@Test
public void testWriteTaxonFile() throws Exception {
    Map<String, JobParameter> parameters = new HashMap<String, JobParameter>();
    parameters.put("query", new JobParameter(""));
    parameters.put("selected.facets", new JobParameter("taxon.family_ss=Araceae"));
    parameters.put("download.taxon", new JobParameter(toParameter(DarwinCorePropertyMap.getConceptTerms(DwcTerm.Taxon))));
    parameters.put("download.file", new JobParameter(UUID.randomUUID().toString() + ".txt"));
    parameters.put("download.limit", new JobParameter(new Integer(Integer.MAX_VALUE).toString()));
    parameters.put("download.fieldsTerminatedBy", new JobParameter("\t"));
    parameters.put("download.fieldsEnclosedBy", new JobParameter("\""));
    parameters.put("download.format", new JobParameter("taxon"));

    JobParameters jobParameters = new JobParameters(parameters);
    Job archiveCreatorJob = jobLocator.getJob("FlatFileCreation");
    assertNotNull("flatFileCreatorJob must exist", archiveCreatorJob);
    JobExecution jobExecution = jobLauncher.run(archiveCreatorJob,
            jobParameters);


    assertEquals("The Job should be sucessful", ExitStatus.COMPLETED, jobExecution.getExitStatus());
}

@Test
public void testWriteChecklistPdf() throws Exception {
    Map<String, JobParameter> parameters = new HashMap<String, JobParameter>();
    parameters.put("query", new JobParameter(""));
    parameters.put("selected.facets", new JobParameter("taxon.family_ss=Araceae"));
    parameters.put("download.taxon", new JobParameter(toParameter(DarwinCorePropertyMap.getConceptTerms(DwcTerm.Taxon))));
    parameters.put("download.file", new JobParameter(UUID.randomUUID().toString() + ".pdf"));
    parameters.put("download.limit", new JobParameter(new Integer(Integer.MAX_VALUE).toString()));
    parameters.put("download.fieldsTerminatedBy", new JobParameter("\t"));
    parameters.put("download.fieldsEnclosedBy", new JobParameter("\""));
    parameters.put("download.sort", new JobParameter("searchable.label_sort_asc"));
    parameters.put("download.format", new JobParameter("hierarchicalChecklist"));
    parameters.put("download.template.filepath", new JobParameter("org/emonocot/job/download/reports/name_report1.jrxml"));

    JobParameters jobParameters = new JobParameters(parameters);
    Job archiveCreatorJob = jobLocator.getJob("FlatFileCreation");
    assertNotNull("flatFileCreator Job must exist", archiveCreatorJob);
    JobExecution jobExecution = jobLauncher.run(archiveCreatorJob,
            jobParameters);

    assertEquals("The Job should be sucessful", ExitStatus.COMPLETED, jobExecution.getExitStatus());
}

@Test
public void testCreateGenericArchive() throws NoSuchJobException,
JobExecutionAlreadyRunningException, JobRestartException,
JobInstanceAlreadyCompleteException, JobParametersInvalidException, IOException {
    Map<String, JobParameter> parameters =
            new HashMap<String, JobParameter>();

    JobParameters jobParameters = new JobParameters(parameters);

    Job palmwebArchive = jobLocator.getJob("PalmWeb");
    assertNotNull("Palmweb must not be null",  palmwebArchive);
    JobExecution jobExecution = jobLauncher.run(palmwebArchive, jobParameters);
    assertEquals("The job should complete successfully",jobExecution.getExitStatus().getExitCode(),"COMPLETED");
    for (StepExecution stepExecution : jobExecution.getStepExecutions()) {
        logger.info(stepExecution.getStepName() + " "
                + stepExecution.getReadCount() + " "
                + stepExecution.getFilterCount() + " "
                + stepExecution.getWriteCount() + " " + stepExecution.getCommitCount());
    }
}

public static ParameterType convert(JobParameter.ParameterType type) {
    if(JobParameter.ParameterType.DATE.equals(type)) {
        return DATE;
    }
    else if(JobParameter.ParameterType.DOUBLE.equals(type)) {
        return DOUBLE;
    }
    else if(JobParameter.ParameterType.LONG.equals(type)) {
        return LONG;
    }
    else if(JobParameter.ParameterType.STRING.equals(type)) {
        return STRING;
    }
    else {
        throw new IllegalArgumentException("Unable to convert type");
    }
}

public JobParametersEvent(Map<String,JobParameter> jobParameters) {
    this.parameters = new LinkedHashMap<>();
    for(Map.Entry<String, JobParameter> entry: jobParameters.entrySet()){
        if(entry.getValue().getValue() instanceof String){
            parameters.put(entry.getKey(), new JobParameterEvent(entry.getValue()));
        }
        else if(entry.getValue().getValue() instanceof Long){
            parameters.put(entry.getKey(), new JobParameterEvent(entry.getValue()));
        }
        else if(entry.getValue().getValue() instanceof Date){
            parameters.put(entry.getKey(), new JobParameterEvent(entry.getValue()));
        }
        else if(entry.getValue().getValue() instanceof Double){
            parameters.put(entry.getKey(), new JobParameterEvent(entry.getValue()));
        }
    }
}

@Test
public void testJobParameters() {
    String[] JOB_PARAM_KEYS = {"A", "B", "C", "D"};
    Date testDate = new Date();
    JobParameter[] PARAMETERS = {new JobParameter("FOO", true), new JobParameter(1L, true),
            new JobParameter(1D, true), new JobParameter(testDate, false)};

    Map jobParamMap = new LinkedHashMap<>();
    for (int paramCount = 0; paramCount < JOB_PARAM_KEYS.length; paramCount++) {
        jobParamMap.put(JOB_PARAM_KEYS[paramCount], PARAMETERS[paramCount]);
    }
    jobParameters = new JobParameters(jobParamMap);
    JobExecution jobExecution = new JobExecution(jobInstance, JOB_EXECUTION_ID, jobParameters, JOB_CONFIGURATION_NAME);
    JobExecutionEvent jobExecutionEvent = new JobExecutionEvent(jobExecution);

    assertNotNull("Job Parameter A was expected", jobExecutionEvent.getJobParameters().getString("A"));
    assertNotNull("Job Parameter B was expected", jobExecutionEvent.getJobParameters().getLong("B"));
    assertNotNull("Job Parameter C was expected", jobExecutionEvent.getJobParameters().getDouble("C"));
    assertNotNull("Job Parameter D was expected", jobExecutionEvent.getJobParameters().getDate("D"));

    assertEquals("Job Parameter A value was not correct", "FOO", jobExecutionEvent.getJobParameters().getString("A"));
    assertEquals("Job Parameter B value was not correct", new Long(1), jobExecutionEvent.getJobParameters().getLong("B"));
    assertEquals("Job Parameter C value was not correct", new Double(1), jobExecutionEvent.getJobParameters().getDouble("C"));
    assertEquals("Job Parameter D value was not correct", testDate, jobExecutionEvent.getJobParameters().getDate("D"));
}

public static JobExecutionResource toJobExecutionResource(final JobExecution jobExecution) {
    final JobExecutionResource execution = new JobExecutionResource(
            toJobInstanceResource(jobExecution.getJobInstance()), jobExecution.getId());
    execution.setStatus(jobExecution.getStatus().name());
    execution.setStartDate(jobExecution.getStartTime());
    execution.setEndDate(jobExecution.getEndTime());
    execution.setExitStatus(jobExecution.getExitStatus().getExitCode());
    JobParameters jobParams = jobExecution.getJobParameters();
    if (jobParams != null) {
        Map<String, JobParameter> params = jobParams.getParameters();
        if (params != null && !params.isEmpty()) {
            Map<String, Object> jobParametersResource = new HashMap<String, Object>();
            for (String key : params.keySet()) {
                jobParametersResource.put(key, params.get(key).getValue());
            }
            execution.setJobParametersResource(jobParametersResource);
        }
    }
    return execution;
}

@Test
public void jobParameters() throws Exception {
    final Date date = new Date();

    final JobParameters parameters = new JobParametersBuilder() //
            .addString("stringName", "stringValue") //
            .addLong("longName", 123L) //
            .addDouble("doubleName", 123.456d, false) //
            .addDate("dateName", date, false) //
            .toJobParameters();

    final String json = mapper.writeValueAsString(parameters);
    final JobParameters read = mapper.readValue(json, JobParameters.class);

    assertThat("parameters after serialization", read, hasProperty("parameters", allOf(//
            hasEntry("stringName", new JobParameter("stringValue", true)), //
            hasEntry("longName", new JobParameter(123L, true)), //
            hasEntry("doubleName", new JobParameter(123.456d, false)), //
            hasEntry("dateName", new JobParameter(date, false)) //
            )));
}

protected Map<String, JobParameter> getParameters(JobExecutionContext context) {
    Map<String, JobParameter> parameters = Maps.newHashMap();

    JobDataMap jobDataMap = context.getMergedJobDataMap();

    for (Entry<String, Object> entry : jobDataMap.entrySet()) {
        // only 4 types of jobparameters at this time...
        if (entry.getValue() instanceof String) {
            parameters.put(entry.getKey(), new JobParameter((String) entry.getValue()));
        } else if (entry.getValue() instanceof Long) {
            parameters.put(entry.getKey(), new JobParameter((Long) entry.getValue()));
        } else if (entry.getValue() instanceof Double) {
            parameters.put(entry.getKey(), new JobParameter((Double) entry.getValue()));
        } else if (entry.getValue() instanceof Date) {
            parameters.put(entry.getKey(), new JobParameter((Date) entry.getValue()));
        } else {
            parameters.put(entry.getKey(), new JobParameter(entry.getValue().toString()));
        }
    }
    return parameters;
}

private JobParameters createJobParametersWithIncrementerIfAvailable(String parameters, Job job) throws JobParametersNotFoundException {
    JobParameters jobParameters = jobParametersConverter.getJobParameters(PropertiesConverter.stringToProperties(parameters));
    // use JobParametersIncrementer to create JobParameters if incrementer is set and only if the job is no restart
    if (job.getJobParametersIncrementer() != null){
        JobExecution lastJobExecution = jobRepository.getLastJobExecution(job.getName(), jobParameters);
        boolean restart = false;
        // check if job failed before
        if (lastJobExecution != null) {
            BatchStatus status = lastJobExecution.getStatus();
            if (status.isUnsuccessful() && status != BatchStatus.ABANDONED) {
                restart = true;
            }
        }
        // if it's not a restart, create new JobParameters with the incrementer
        if (!restart) {
            JobParameters nextParameters = getNextJobParameters(job);
            Map<String, JobParameter> map = new HashMap<String, JobParameter>(nextParameters.getParameters());
            map.putAll(jobParameters.getParameters());
            jobParameters = new JobParameters(map);
        }
    }
    return jobParameters;
}

public RepeatStatus execute(StepContribution contribution,
        ChunkContext chunkContext) throws Exception {

    JobParameters jobParameters = chunkContext.getStepContext().getStepExecution().getJobParameters();

    System.out.println("Hello Spring Batch!");

    if (jobParameters != null && !jobParameters.isEmpty()) {

        final Set<Entry<String, JobParameter>> parameterEntries = jobParameters.getParameters().entrySet();
        System.out.println(LINE);
        System.out.println(String.format("The following %s Job Parameter(s) is/are present:", parameterEntries.size()));
        System.out.println(LINE);
        for (Entry<String, JobParameter> jobParameterEntry : parameterEntries) {
            System.out.println(String.format(
                    "Parameter name: %s; isIdentifying: %s; type: %s; value: %s",
                    jobParameterEntry.getKey(),
                    jobParameterEntry.getValue().isIdentifying(),
                    jobParameterEntry.getValue().getType().toString(),
                    jobParameterEntry.getValue().getValue()));
        }
        System.out.println(LINE);
    }
    return RepeatStatus.FINISHED;
}

/**
 * @param args
 */
public static void main(String[] args) {
  ClassPathXmlApplicationContext c = new ClassPathXmlApplicationContext(
      "billing_job.xml");
  SimpleJobLauncher launcher = new SimpleJobLauncher();
  launcher.setJobRepository((JobRepository) c.getBean("jobRepository"));
  launcher.setTaskExecutor(new SyncTaskExecutor());
  try {
    Map<String, JobParameter> parameters = new HashMap<String, JobParameter>();
    parameters.put(RUN_MONTH_KEY, new JobParameter("2011-2"));
    JobExecution je = launcher.run((Job) c.getBean("billingJob"),
        new JobParameters(parameters));
    System.out.println(je);
    System.out.println(je.getJobInstance());
    System.out.println(je.getStepExecutions());
  } catch (Exception e) {
    e.printStackTrace();
  }
}

public static void main(String[] args) {
  ClassPathXmlApplicationContext c = new ClassPathXmlApplicationContext(
      "message_job.xml");
  SimpleJobLauncher launcher = new SimpleJobLauncher();
  launcher.setJobRepository((JobRepository) c.getBean("jobRepository"));
  launcher.setTaskExecutor(new SyncTaskExecutor());
  try {
    Map<String, JobParameter> parameters = new HashMap<String, JobParameter>();
    parameters.put(RUN_MONTH_KEY, new JobParameter("2011-10"));
    JobExecution je = launcher.run((Job) c.getBean("messageJob"),
        new JobParameters(parameters));
    System.out.println(je);
    System.out.println(je.getJobInstance());
    System.out.println(je.getStepExecutions());
  } catch (Exception e) {
    e.printStackTrace();
  }
}

private JobParameters getNextJobParameters(Job job,
        JobParameters additionalParameters) {
    String name = job.getName();
    JobParameters parameters = new JobParameters();
    List<JobInstance> lastInstances = this.jobExplorer.getJobInstances(name, 0, 1);
    JobParametersIncrementer incrementer = job.getJobParametersIncrementer();
    Map<String, JobParameter> additionals = additionalParameters.getParameters();
    if (lastInstances.isEmpty()) {
        // Start from a completely clean sheet
        if (incrementer != null) {
            parameters = incrementer.getNext(new JobParameters());
        }
    }
    else {
        List<JobExecution> previousExecutions = this.jobExplorer
                .getJobExecutions(lastInstances.get(0));
        JobExecution previousExecution = previousExecutions.get(0);
        if (previousExecution == null) {
            // Normally this will not happen - an instance exists with no executions
            if (incrementer != null) {
                parameters = incrementer.getNext(new JobParameters());
            }
        }
        else if (isStoppedOrFailed(previousExecution) && job.isRestartable()) {
            // Retry a failed or stopped execution
            parameters = previousExecution.getJobParameters();
            // Non-identifying additional parameters can be removed to a retry
            removeNonIdentifying(additionals);
        }
        else if (incrementer != null) {
            // New instance so increment the parameters if we can
            parameters = incrementer.getNext(previousExecution.getJobParameters());
        }
    }
    return merge(parameters, additionals);
}

private void removeNonIdentifying(Map<String, JobParameter> parameters) {
    HashMap<String, JobParameter> copy = new HashMap<String, JobParameter>(
            parameters);
    for (Map.Entry<String, JobParameter> parameter : copy.entrySet()) {
        if (!parameter.getValue().isIdentifying()) {
            parameters.remove(parameter.getKey());
        }
    }
}

private JobParameters getNextJobParameters(Job job,
        JobParameters additionalParameters) {
    String name = job.getName();
    JobParameters parameters = new JobParameters();
    List<JobInstance> lastInstances = this.jobExplorer.getJobInstances(name, 0, 1);
    JobParametersIncrementer incrementer = job.getJobParametersIncrementer();
    Map<String, JobParameter> additionals = additionalParameters.getParameters();
    if (lastInstances.isEmpty()) {
        // Start from a completely clean sheet
        if (incrementer != null) {
            parameters = incrementer.getNext(new JobParameters());
        }
    }
    else {
        List<JobExecution> previousExecutions = this.jobExplorer
                .getJobExecutions(lastInstances.get(0));
        JobExecution previousExecution = previousExecutions.get(0);
        if (previousExecution == null) {
            // Normally this will not happen - an instance exists with no executions
            if (incrementer != null) {
                parameters = incrementer.getNext(new JobParameters());
            }
        }
        else if (isStoppedOrFailed(previousExecution) && job.isRestartable()) {
            // Retry a failed or stopped execution
            parameters = previousExecution.getJobParameters();
            // Non-identifying additional parameters can be removed to a retry
            removeNonIdentifying(additionals);
        }
        else if (incrementer != null) {
            // New instance so increment the parameters if we can
            parameters = incrementer.getNext(previousExecution.getJobParameters());
        }
    }
    return merge(parameters, additionals);
}

private void removeNonIdentifying(Map<String, JobParameter> parameters) {
    HashMap<String, JobParameter> copy = new HashMap<String, JobParameter>(
            parameters);
    for (Map.Entry<String, JobParameter> parameter : copy.entrySet()) {
        if (!parameter.getValue().isIdentifying()) {
            parameters.remove(parameter.getKey());
        }
    }
}

public JobParameters getNext(JobParameters parameters) {
    Map<String, JobParameter> map = new HashMap<String, JobParameter>(
            parameters.getParameters());
    map.put("run.count", new JobParameter(parameters
            .getLong("run.count", -1)+1));
    return new JobParameters(map);
}

public static void main(String[] args) {

        String[] springConfig = { "spring/batch/jobs/job-config.xml" };

        @SuppressWarnings("resource")
        ApplicationContext context = new ClassPathXmlApplicationContext(springConfig);

        JobLauncher jobLauncher = (JobLauncher) context.getBean("jobLauncher");
        Job job = (Job) context.getBean("scopesJob");

        Map<String, JobParameter> parameters = new HashMap<String, JobParameter>();
        parameters.put("customStepScopeParameter", new JobParameter("myCustomStepScopeParameterValue"));
        parameters.put("time", new JobParameter(System.currentTimeMillis()));
        JobParameters  jp = new JobParameters(parameters);

        try {
            JobExecution execution = jobLauncher.run(job, jp);
            System.out.println("Exit Status : " + execution.getStatus());
            System.out.println("Exit Status : " + execution.getAllFailureExceptions());

        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println("Done");

    }

/**
 * Will augment the provided {@link RestTemplate} with the Jackson Mixins required by
 * Spring Cloud Data Flow, specifically:
 * <p>
 * <ul>
 * <li>{@link JobExecutionJacksonMixIn}
 * <li>{@link JobParametersJacksonMixIn}
 * <li>{@link JobParameterJacksonMixIn}
 * <li>{@link JobInstanceJacksonMixIn}
 * <li>{@link ExitStatusJacksonMixIn}
 * <li>{@link StepExecutionJacksonMixIn}
 * <li>{@link ExecutionContextJacksonMixIn}
 * <li>{@link StepExecutionHistoryJacksonMixIn}
 * </ul>
 * <p>
 * Furthermore, this method will also register the {@link Jackson2HalModule}
 *
 * @param restTemplate Can be null. Instantiates a new {@link RestTemplate} if null
 * @return RestTemplate with the required Jackson Mixins
 */
public static RestTemplate prepareRestTemplate(RestTemplate restTemplate) {
    if (restTemplate == null) {
        restTemplate = new RestTemplate();
    }

    restTemplate.setErrorHandler(new VndErrorResponseErrorHandler(restTemplate.getMessageConverters()));

    boolean containsMappingJackson2HttpMessageConverter = false;

    for (HttpMessageConverter<?> converter : restTemplate.getMessageConverters()) {
        if (converter instanceof MappingJackson2HttpMessageConverter) {
            containsMappingJackson2HttpMessageConverter = true;
            final MappingJackson2HttpMessageConverter jacksonConverter = (MappingJackson2HttpMessageConverter) converter;
            jacksonConverter.getObjectMapper().registerModule(new Jackson2HalModule())
                    .addMixIn(JobExecution.class, JobExecutionJacksonMixIn.class)
                    .addMixIn(JobParameters.class, JobParametersJacksonMixIn.class)
                    .addMixIn(JobParameter.class, JobParameterJacksonMixIn.class)
                    .addMixIn(JobInstance.class, JobInstanceJacksonMixIn.class)
                    .addMixIn(ExitStatus.class, ExitStatusJacksonMixIn.class)
                    .addMixIn(StepExecution.class, StepExecutionJacksonMixIn.class)
                    .addMixIn(ExecutionContext.class, ExecutionContextJacksonMixIn.class)
                    .addMixIn(StepExecutionHistory.class, StepExecutionHistoryJacksonMixIn.class);
        }
    }

    if (!containsMappingJackson2HttpMessageConverter) {
        throw new IllegalArgumentException(
                "The RestTemplate does not contain a required " + "MappingJackson2HttpMessageConverter.");
    }
    return restTemplate;
}

@Test
public void testDeserializationOfMultipleJobExecutions() throws IOException {

    final ObjectMapper objectMapper = new ObjectMapper();

    final InputStream inputStream = JobExecutionDeserializationTests.class
            .getResourceAsStream("/JobExecutionJson.txt");

    final String json = new String(StreamUtils.copyToByteArray(inputStream));

    objectMapper.registerModule(new Jackson2HalModule());
    objectMapper.addMixIn(JobExecution.class, JobExecutionJacksonMixIn.class);
    objectMapper.addMixIn(JobParameters.class, JobParametersJacksonMixIn.class);
    objectMapper.addMixIn(JobParameter.class, JobParameterJacksonMixIn.class);
    objectMapper.addMixIn(JobInstance.class, JobInstanceJacksonMixIn.class);
    objectMapper.addMixIn(StepExecution.class, StepExecutionJacksonMixIn.class);
    objectMapper.addMixIn(StepExecutionHistory.class, StepExecutionHistoryJacksonMixIn.class);
    objectMapper.addMixIn(ExecutionContext.class, ExecutionContextJacksonMixIn.class);
    objectMapper.addMixIn(ExitStatus.class, ExitStatusJacksonMixIn.class);

    PagedResources<Resource<JobExecutionResource>> paged = objectMapper.readValue(json,
            new TypeReference<PagedResources<Resource<JobExecutionResource>>>() {
            });
    JobExecutionResource jobExecutionResource = paged.getContent().iterator().next().getContent();
    Assert.assertEquals("Expect 1 JobExecutionInfoResource", 6, paged.getContent().size());
    Assert.assertEquals(Long.valueOf(6), jobExecutionResource.getJobId());
    Assert.assertEquals("job200616815", jobExecutionResource.getName());
    Assert.assertEquals("COMPLETED", jobExecutionResource.getJobExecution().getStatus().name());

}

@Test
public void testDeserializationOfSingleJobExecution() throws IOException {

    final ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.registerModule(new Jackson2HalModule());

    final InputStream inputStream = JobExecutionDeserializationTests.class
            .getResourceAsStream("/SingleJobExecutionJson.txt");

    final String json = new String(StreamUtils.copyToByteArray(inputStream));

    objectMapper.addMixIn(JobExecution.class, JobExecutionJacksonMixIn.class);
    objectMapper.addMixIn(JobParameters.class, JobParametersJacksonMixIn.class);
    objectMapper.addMixIn(JobParameter.class, JobParameterJacksonMixIn.class);
    objectMapper.addMixIn(JobInstance.class, JobInstanceJacksonMixIn.class);
    objectMapper.addMixIn(StepExecution.class, StepExecutionJacksonMixIn.class);
    objectMapper.addMixIn(StepExecutionHistory.class, StepExecutionHistoryJacksonMixIn.class);
    objectMapper.addMixIn(ExecutionContext.class, ExecutionContextJacksonMixIn.class);
    objectMapper.addMixIn(ExitStatus.class, ExitStatusJacksonMixIn.class);
    objectMapper.setDateFormat(new ISO8601DateFormatWithMilliSeconds());

    final JobExecutionResource jobExecutionInfoResource = objectMapper.readValue(json, JobExecutionResource.class);

    Assert.assertNotNull(jobExecutionInfoResource);
    Assert.assertEquals(Long.valueOf(1), jobExecutionInfoResource.getJobId());
    Assert.assertEquals("ff.job", jobExecutionInfoResource.getName());
    Assert.assertEquals("COMPLETED", jobExecutionInfoResource.getJobExecution().getStatus().name());

}

/**
 * Runs the scheduled job.
 *
 * @throws JobParametersInvalidException
 * @throws JobInstanceAlreadyCompleteException
 * @throws JobRestartException
 * @throws JobExecutionAlreadyRunningException
 */
@Scheduled(fixedRate = RATE)
public void run() throws JobExecutionAlreadyRunningException,
        JobRestartException, JobInstanceAlreadyCompleteException,
        JobParametersInvalidException {
    JobParameters params = new JobParameters(new HashMap<String, JobParameter>() {
        private static final long serialVersionUID = 1L;
        {
            put("execDate", new JobParameter(new Date(), true));
        }
    });

    jobLauncher.run(job, params);
}

@Test
public void shouldTaskletWork() throws JobExecutionAlreadyRunningException, JobRestartException, JobInstanceAlreadyCompleteException,
        JobParametersInvalidException {
    Map<String, JobParameter> params = Maps.newHashMap();
    params.put("test", new JobParameter("przodownik"));
    params.put("time", new JobParameter(new Date()));
    JobExecution execution = jobLauncher.run(simpleStringProcessorTask, new JobParameters(params));
    log.info("Exit Status :  {}", execution.getExitStatus());
    Assert.assertEquals(ExitStatus.COMPLETED, execution.getExitStatus());

}

private JobParameters getNextJobParameters(Job job,
        JobParameters additionalParameters) {
    String name = job.getName();
    JobParameters parameters = new JobParameters();
    List<JobInstance> lastInstances = this.jobExplorer.getJobInstances(name, 0, 1);
    JobParametersIncrementer incrementer = job.getJobParametersIncrementer();
    Map<String, JobParameter> additionals = additionalParameters.getParameters();
    if (lastInstances.isEmpty()) {
        // Start from a completely clean sheet
        if (incrementer != null) {
            parameters = incrementer.getNext(new JobParameters());
        }
    }
    else {
        List<JobExecution> previousExecutions = this.jobExplorer
                .getJobExecutions(lastInstances.get(0));
        JobExecution previousExecution = previousExecutions.get(0);
        if (previousExecution == null) {
            // Normally this will not happen - an instance exists with no executions
            if (incrementer != null) {
                parameters = incrementer.getNext(new JobParameters());
            }
        }
        else if (isStoppedOrFailed(previousExecution) && job.isRestartable()) {
            // Retry a failed or stopped execution
            parameters = previousExecution.getJobParameters();
            // Non-identifying additional parameters can be removed to a retry
            removeNonIdentifying(additionals);
        }
        else if (incrementer != null) {
            // New instance so increment the parameters if we can
            parameters = incrementer.getNext(previousExecution.getJobParameters());
        }
    }
    return merge(parameters, additionals);
}

private void removeNonIdentifying(Map<String, JobParameter> parameters) {
    HashMap<String, JobParameter> copy = new HashMap<String, JobParameter>(
            parameters);
    for (Map.Entry<String, JobParameter> parameter : copy.entrySet()) {
        if (!parameter.getValue().isIdentifying()) {
            parameters.remove(parameter.getKey());
        }
    }
}

@Override
public void run(String... args) throws Exception {
    Map<String,JobParameter> params = Maps.newHashMap();
    params.put("message", new JobParameter("przodownik -> batch -> first -> example"));
    JobParameters jobParameters = new JobParameters(params);
    jobLauncher.run(firstJob, jobParameters);

}

/**
 *
 * @param jobInstance
 *            The jobExecution to save
 */
public final void save(final JobInstance jobInstance) {
    String jobKey = createJobKey(jobInstance.getJobParameters());
    getJdbcTemplate().update(
            "INSERT into BATCH_JOB_INSTANCE(JOB_INSTANCE_ID, JOB_NAME, VERSION, JOB_KEY)"
                    + " values (?, ?, ?, ?)", jobInstance.getId(),
                    jobInstance.getJobName(), jobInstance.getVersion(), jobKey);
    for (String key : jobInstance.getJobParameters().getParameters()
            .keySet()) {
        JobParameter jobParameter = jobInstance.getJobParameters()
                .getParameters().get(key);
        insertParameter(jobInstance.getId(), jobParameter.getType(), key,
                jobParameter.getValue());
    }
}

/**
 *
 */
@Test
public final void testJobExecution() {
    Map<String, JobParameter> jobParametersMap = new HashMap<String, JobParameter>();
    jobParametersMap.put("authority.name", new JobParameter("test"));
    JobInstance jobInstance = new JobInstance(1L, new JobParameters(
            jobParametersMap), "testJob");
    jobInstance.setVersion(1);
    jobInstanceDao.save(jobInstance);

    JobExecution jobExecution = new JobExecution(jobInstance, 1L);
    jobExecution.setCreateTime(new Date());
    jobExecutionDao.save(jobExecution);

    jobExecutionDao.delete(1L);
    jobInstanceDao.delete(1L);
}