下面列出了org.springframework.jdbc.core.namedparam.BeanPropertySqlParameterSource#org.springframework.batch.core.ExitStatus 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
private ExecutionResult runJob(Job job) {
try {
JobExecution execution = this.jobLauncher.run(job, new JobParameters());
if (!ExitStatus.COMPLETED.equals(execution.getExitStatus())) {
return ExecutionResult.failure(new IllegalStateException(
"Job failed to get executed successfully. Failed with exit code ["
+ execution.getExitStatus().getExitCode()
+ "] and description ["
+ execution.getExitStatus().getExitDescription() + "]"));
}
List<Exception> thrownExceptions = exceptionsThrownBySteps(execution);
return new ExecutionResult(thrownExceptions);
}
catch (JobExecutionException ex) {
return ExecutionResult.failure(ex);
}
}
@Override
public ExitStatus afterStep(StepExecution stepExecution) {
val context = BatchContextHolder.getContext();
// 機能別の終了処理を呼び出す
try {
after(context, stepExecution);
} catch (Exception e) {
log.error("exception occurred. ", e);
throw new IllegalStateException(e);
}
// ログ出力
logAfterStep(context, stepExecution);
ExitStatus exitStatus = stepExecution.getExitStatus();
return exitStatus;
}
public StepExecution mapRow(ResultSet rs, int rowNum) throws SQLException {
StepExecution stepExecution = new StepExecution(rs.getString(2), null);
stepExecution.setId(rs.getLong(1));
stepExecution.setStartTime(rs.getTimestamp(3));
stepExecution.setEndTime(rs.getTimestamp(4));
stepExecution.setStatus(BatchStatus.valueOf(rs.getString(5)));
stepExecution.setCommitCount(rs.getInt(6));
stepExecution.setReadCount(rs.getInt(7));
stepExecution.setFilterCount(rs.getInt(8));
stepExecution.setWriteCount(rs.getInt(9));
stepExecution.setExitStatus(new ExitStatus(rs.getString(10), rs.getString(11)));
stepExecution.setReadSkipCount(rs.getInt(12));
stepExecution.setWriteSkipCount(rs.getInt(13));
stepExecution.setProcessSkipCount(rs.getInt(14));
stepExecution.setRollbackCount(rs.getInt(15));
stepExecution.setLastUpdated(rs.getTimestamp(16));
stepExecution.setVersion(rs.getInt(17));
return stepExecution;
}
@Test
public void testFindJobExecutionsAllQueryParameters() {
this.createJobExecutionsForQuery();
final String jobName = "queryJob";
final Integer size = 4;
final Date startDate = new Date(System.currentTimeMillis() - 100000);
final Date endDate = new Date(System.currentTimeMillis() + 100000);
final String exitStatus = ExitStatus.COMPLETED.getExitCode();
final Map<String, Object> queryParameters = new HashMap<>();
queryParameters.put(QueryParameterKey.EXIT_STATUS, exitStatus);
queryParameters.put(QueryParameterKey.START_DATE, startDate);
queryParameters.put(QueryParameterKey.END_DATE, endDate);
final List<JobExecution> result = this.mapLightminJobExecutionDao.findJobExecutions(jobName, queryParameters, size);
assertThat(result).isNotNull();
assertThat(result).isNotEmpty();
assertThat(result).hasSize(size);
}
@Test
public void testFindJobExecutionsAllQueryParametersWithOutJobName() {
this.createJobExecutionsForQuery();
final Integer size = 4;
final Date startDate = new Date(System.currentTimeMillis() - 100000);
final Date endDate = new Date(System.currentTimeMillis() + 100000);
final String exitStatus = ExitStatus.COMPLETED.getExitCode();
final Map<String, Object> queryParameters = new HashMap<>();
queryParameters.put(QueryParameterKey.EXIT_STATUS, exitStatus);
queryParameters.put(QueryParameterKey.START_DATE, startDate);
queryParameters.put(QueryParameterKey.END_DATE, endDate);
final List<JobExecution> result = this.mapLightminJobExecutionDao.findJobExecutions(null, queryParameters, size);
assertThat(result).isNotNull();
assertThat(result).isNotEmpty();
assertThat(result).hasSize(size);
}
/**
* Generates an appropriate statistic of the processed, <br>
* delegates the cleanup and the metric notification.
*
* @param se
* the StepExecution
*/
@Override
@Transactional(propagation = Propagation.REQUIRES_NEW)
public ExitStatus afterStep(StepExecution se) {
LOG.info(se);
statisticDao.save(createImportStatistic(se));
if (CampusProcessStep.IMPORT_CONTROLFILE.name().equalsIgnoreCase(se.getStepName())) {
if (se.getWriteCount() != getFixedNumberOfFilesToBeExported()) {
// if (se.getReadCount() != getFixedNumberOfFilesToBeExported() || se.getWriteCount() != getFixedNumberOfFilesToBeExported()) {
notifyMetrics(se);
return ExitStatus.FAILED;
}
}
removeOldDataIfExist(se);
notifyMetrics(se);
return null;
}
@Test
public void taxCalculationStep_generatesCorrectCalculation() throws Exception {
Employee employee = haveOneEmployee();
JobParameters jobParameters = new JobParametersBuilder()
.addLong("year", 2014L, true)
.addLong("month", 5L, true)
.toJobParameters();
JobExecution jobExecution = jobLauncherTestUtils.launchStep(EmployeeJobConfigSingleJvm.TAX_CALCULATION_STEP, jobParameters);
assertThat(jobExecution.getExitStatus()).isEqualTo(ExitStatus.COMPLETED);
List<TaxCalculation> byEmployee = taxCalculationRepository.findByEmployee(employee);
assertThat(byEmployee).hasSize(1);
TaxCalculation taxCalculation = byEmployee.get(0);
assertThat(taxCalculation.getEmployee().getId()).isEqualTo(employee.getId());
assertThat(taxCalculation.getYear()).isEqualTo(2014);
assertThat(taxCalculation.getMonth()).isEqualTo(5);
List<TaxCalculation> byYearAndMonth = taxCalculationRepository.find(2014, 5, 1L);
assertThat(byYearAndMonth).hasSize(1);
}
@Test
public void createProtocol() throws Exception {
// Given
JobExecution jobExecution = new JobExecution(1L,
new JobParametersBuilder().addString("test", "value").toJobParameters());
jobExecution.setJobInstance(new JobInstance(1L, "test-job"));
jobExecution.setCreateTime(new Date());
jobExecution.setStartTime(new Date());
jobExecution.setEndTime(new Date());
jobExecution.setExitStatus(new ExitStatus("COMPLETED_WITH_ERRORS", "This is a default exit message"));
jobExecution.getExecutionContext().put("jobCounter", 1);
StepExecution stepExecution = jobExecution.createStepExecution("test-step-1");
stepExecution.getExecutionContext().put("stepCounter", 1);
ProtocolListener protocolListener = new ProtocolListener();
// When
protocolListener.afterJob(jobExecution);
// Then
String output = this.outputCapture.toString();
assertThat(output, containsString("Protocol for test-job"));
assertThat(output, containsString("COMPLETED_WITH_ERRORS"));
}
@Test
public void givenNumberGeneratorDecider_whenDeciderRuns_thenStatusIsNotify() throws Exception {
JobExecution jobExecution = jobLauncherTestUtils.launchJob();
Collection<StepExecution> actualStepExecutions = jobExecution.getStepExecutions();
ExitStatus actualJobExitStatus = jobExecution.getExitStatus();
assertEquals("COMPLETED", actualJobExitStatus.getExitCode()
.toString());
assertEquals(2, actualStepExecutions.size());
boolean notifyStepDidRun = false;
Iterator<StepExecution> iterator = actualStepExecutions.iterator();
while (iterator.hasNext() && !notifyStepDidRun) {
if (iterator.next()
.getStepName()
.equals("Notify step")) {
notifyStepDidRun = true;
}
}
assertTrue(notifyStepDidRun);
}
@Test
public void whenEndpointFailsTwicePasses3rdTime_thenSuccess() throws Exception {
FileSystemResource expectedResult = new FileSystemResource(EXPECTED_OUTPUT);
FileSystemResource actualResult = new FileSystemResource(TEST_OUTPUT);
//fails for first two calls and passes third time onwards
when(httpResponse.getEntity())
.thenReturn(new StringEntity("{ \"age\":10, \"postCode\":\"430222\" }"));
when(closeableHttpClient.execute(any()))
.thenThrow(new ConnectTimeoutException("Timeout count 1"))
.thenThrow(new ConnectTimeoutException("Timeout count 2"))
.thenReturn(httpResponse);
JobExecution jobExecution = jobLauncherTestUtils.launchJob(defaultJobParameters());
JobInstance actualJobInstance = jobExecution.getJobInstance();
ExitStatus actualJobExitStatus = jobExecution.getExitStatus();
assertThat(actualJobInstance.getJobName(), is("retryBatchJob"));
assertThat(actualJobExitStatus.getExitCode(), is("COMPLETED"));
AssertFile.assertFileEquals(expectedResult, actualResult);
}
@Test
public void givenReferenceOutput_whenJobExecuted_thenSuccess() throws Exception {
// given
FileSystemResource expectedResult = new FileSystemResource(EXPECTED_OUTPUT);
FileSystemResource actualResult = new FileSystemResource(TEST_OUTPUT);
// when
JobExecution jobExecution = jobLauncherTestUtils.launchJob(defaultJobParameters());
JobInstance actualJobInstance = jobExecution.getJobInstance();
ExitStatus actualJobExitStatus = jobExecution.getExitStatus();
// then
assertThat(actualJobInstance.getJobName(), is("transformBooksRecords"));
assertThat(actualJobExitStatus.getExitCode(), is("COMPLETED"));
AssertFile.assertFileEquals(expectedResult, actualResult);
}
@Test
public void givenReferenceOutput_whenStep1Executed_thenSuccess() throws Exception {
// given
FileSystemResource expectedResult = new FileSystemResource(EXPECTED_OUTPUT);
FileSystemResource actualResult = new FileSystemResource(TEST_OUTPUT);
// when
JobExecution jobExecution = jobLauncherTestUtils.launchStep("step1", defaultJobParameters());
Collection<StepExecution> actualStepExecutions = jobExecution.getStepExecutions();
ExitStatus actualJobExitStatus = jobExecution.getExitStatus();
// then
assertThat(actualStepExecutions.size(), is(1));
assertThat(actualJobExitStatus.getExitCode(), is("COMPLETED"));
AssertFile.assertFileEquals(expectedResult, actualResult);
}
@Test
public void testValidRun() {
try {
JobExecution jobExecution = this.launchStep("step1");
//Ensure job completed successfully.
Assert.isTrue(jobExecution.getExitStatus().equals(ExitStatus.COMPLETED), "Step Execution did not complete normally: " + jobExecution.getExitStatus());
//Check output.
Assert.isTrue(actual.exists(), "Actual does not exist.");
AssertFile.assertFileEquals(expected.getFile(), actual.getFile());
} catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
@Test
public void testValidRun() {
try {
JobExecution jobExecution = this.launchStep("step1");
//Ensure job completed successfully.
Assert.isTrue(jobExecution.getExitStatus().equals(ExitStatus.COMPLETED), "Step Execution did not complete normally: " + jobExecution.getExitStatus());
//Check output.
Assert.isTrue(actual.exists(), "Actual does not exist.");
AssertFile.assertFileEquals(expected.getFile(), actual.getFile());
} catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
@Operation(summary = "Start a Spring Batch job execution")
@PostMapping
public ResponseEntity<JobExecutionResource> put(@RequestBody JobConfig jobConfig) {
JobExecutionResource resource = new JobExecutionResource(jobExecutionService.launch(jobConfig));
boolean failed = resource.getJobExecution().getExitCode().equals(ExitStatus.FAILED.getExitCode());
return new ResponseEntity<>(resource, failed ? HttpStatus.INTERNAL_SERVER_ERROR : HttpStatus.OK);
}
@Test
public void jobExceptionMessageIsPropagatedToClient() {
String exceptionMessage = "excepted exception";
JobExecution je = startJobThatThrowsException(exceptionMessage);
assertThat(je.getExitCode()).isEqualTo(ExitStatus.FAILED.getExitCode());
assertThat(je.getExitDescription()).contains(exceptionMessage);
assertThat(restTemplate.getForObject(url("/jobExecutions?exitCode=FAILED"), String.class))
.contains("\"exitCode\":\"FAILED\",\"exitDescription\":\"java.lang.RuntimeException");
}
@Test
public void jobExecutionsMaxNumberOfJobInstancesFailed() {
Collection<JobExecution> jes =
jobExecutionService.jobExecutions(empty(), Optional.of(ExitStatus.FAILED.getExitCode()), 1);
Assertions.assertThat(jes).hasSize(2);
Assertions.assertThat(jes).extracting(je -> je.getExitCode()).allMatch(s -> s.equals("FAILED"));
}
@Test
public void jobExecutionsMaxNumberOfJobInstancesCompleted() {
Collection<JobExecution> jes =
jobExecutionService.jobExecutions(empty(), Optional.of(ExitStatus.COMPLETED.getExitCode()), 1);
Assertions.assertThat(jes).hasSize(2);
Assertions.assertThat(jes).extracting(je -> je.getJobName()).containsExactly(JOB_NAME_2, JOB_NAME_1);
}
@Test
public void jobExceptionMessageIsPropagatedToClient() {
String exceptionMessage = "excepted exception";
JobExecution je = startJobThatThrowsException(exceptionMessage);
assertThat(je.getExitCode()).isEqualTo(ExitStatus.FAILED.getExitCode());
assertThat(je.getExitDescription()).contains(exceptionMessage);
assertThat(restTemplate.getForObject(url("/jobExecutions?exitCode=FAILED"), String.class))
.contains("\"exitCode\":\"FAILED\",\"exitDescription\":\"java.lang.RuntimeException");
}
@Bean
public Job multiStepJob() {
// return jobBuilderFactory.get("multiStepJob")
// .start(step1())
// .next(step2())
// .next(step3())
// .build();
return jobBuilderFactory.get("multiStepJob2")
.start(step1())
.on(ExitStatus.COMPLETED.getExitCode()).to(step2())
.from(step2())
.on(ExitStatus.COMPLETED.getExitCode()).to(step3())
.from(step3()).end()
.build();
}
@Test
public void testSuccessfulRun() {
TaskExecution taskExecution = getDefaultTaskExecution(0, null);
when(this.taskExplorer.getTaskExecution(anyLong())).thenReturn(taskExecution);
populateExecutionContext(111L);
assertEquals(ExitStatus.COMPLETED, this.taskListener.afterStep(this.stepExecution));
}
@Test
public void testExitMessageRunSuccess() {
ExitStatus expectedTaskStatus = new ExitStatus("TEST_EXIT_MESSAGE");
TaskExecution taskExecution = getDefaultTaskExecution(0,
expectedTaskStatus.getExitCode());
when(this.taskExplorer.getTaskExecution(anyLong())).thenReturn(taskExecution);
populateExecutionContext(111L);
assertEquals(expectedTaskStatus, this.taskListener.afterStep(this.stepExecution));
}
@Test
public void testExitMessageRunFail() {
ExitStatus expectedTaskStatus = new ExitStatus("TEST_EXIT_MESSAGE");
TaskExecution taskExecution = getDefaultTaskExecution(1,
expectedTaskStatus.getExitCode());
when(this.taskExplorer.getTaskExecution(anyLong())).thenReturn(taskExecution);
populateExecutionContext(111L);
assertEquals(expectedTaskStatus, this.taskListener.afterStep(this.stepExecution));
}
@Test
public void testFailedRun() {
TaskExecution taskExecution = getDefaultTaskExecution(1, null);
when(this.taskExplorer.getTaskExecution(anyLong())).thenReturn(taskExecution);
populateExecutionContext(111L);
assertEquals(ExitStatus.FAILED, this.taskListener.afterStep(this.stepExecution));
}
@Override
public ExitStatus afterStep(StepExecution stepExecution) {
if(stepExecution.getStatus() == BatchStatus.COMPLETED){
LogUtil.getLogger().info("批量任务Step-->[{}-{}]-->处理完成，ReadCount=[{}]，WriteCount=[{}]，CommitCount==[{}]，Duration[{}]ms", stepExecution.getJobExecutionId(), stepExecution.getStepName(), stepExecution.getReadCount(), stepExecution.getWriteCount(), stepExecution.getCommitCount(), SystemClockUtil.INSTANCE.now()-stepExecution.getStartTime().getTime());
LogUtil.getLogger().info("-----------------------------------------------------------------------");
}
return stepExecution.getExitStatus();
}
private StepExecutionListener releaserListener(NamedArgumentsSupplier argsSupplier,
ReleaserTask releaserTask) {
return new StepExecutionListenerSupport() {
@Override
public ExitStatus afterStep(StepExecution stepExecution) {
Arguments args = argsSupplier.get();
FlowRunner.Decision decision = afterTask(args.options, args.properties,
releaserTask);
if (decision == FlowRunner.Decision.ABORT) {
return ExitStatus.FAILED;
}
ExecutionResult result = (ExecutionResult) stepExecution
.getExecutionContext().get("result");
if (result == null || result.isSuccess()) {
return stepExecution.getExitStatus();
}
else if (result.isUnstable()) {
return ExitStatus.COMPLETED
.addExitDescription(BuildUnstableException.DESCRIPTION);
}
else if (result.isFailure()) {
return ExitStatus.FAILED;
}
return ExitStatus.COMPLETED;
}
};
}
/**
* Mutable operation to add several required MixIns to the provided
* {@link ObjectMapper}.
*
* @param objectMapper Must not be null
* @return ObjectMapper with several mixIns applied
*/
public static ObjectMapper prepareObjectMapper(ObjectMapper objectMapper) {
Assert.notNull(objectMapper, "The objectMapper must not be null.");
return objectMapper
.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);
}
private void assertCorrectMixins(ObjectMapper objectMapper) {
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));
}
@Test
public void testSuccessfulRun() {
TaskExecution taskExecution = getDefaultTaskExecution(0, null);
when(this.taskExplorer.getTaskExecution(anyLong())).thenReturn(taskExecution);
populateExecutionContext(111L);
assertEquals(ExitStatus.COMPLETED, this.taskListener.afterStep(this.stepExecution));
}
@Test
public void testExitMessageRunSuccess() {
ExitStatus expectedTaskStatus = new ExitStatus("TEST_EXIT_MESSAGE");
TaskExecution taskExecution = getDefaultTaskExecution(0,
expectedTaskStatus.getExitCode());
when(this.taskExplorer.getTaskExecution(anyLong())).thenReturn(taskExecution);
populateExecutionContext(111L);
assertEquals(expectedTaskStatus, this.taskListener.afterStep(this.stepExecution));
}