Java-如何在SpringBatch应用程序中设置ExitCode

Question

I am making a Spring Batch application where I have tasklet and processor. In the processor I throw Exceptions, and my needs is to System.exit() the application according to the exceptions I thrown.

But I don't know how to do this.

Thanks for your reply

Answer 1

You can find a good explanation in this article . One way to do it is to provide the ExitCodeExceptionMapper bean to map the exception to some specific exit code:

@Bean
ExitCodeExceptionMapper exceptionMapper() {
    return exception -> {
        if (exception.getCause() instanceof NumberFormatException) {
            return 80;
        }
        return 1;
    };
}

UPDATE

This small example should make it clear:

@SpringBootApplication
public class DemoApplication implements CommandLineRunner {
  @Bean
  ExitCodeExceptionMapper exitCodeExceptionMapper() {
    return exception -> {
      if (exception.getCause() instanceof MyException) {
        return 10;
      }
      return 1;
    };
  }

  public static void main(String[] args) {
    System.exit(SpringApplication
        .exit(SpringApplication.run(DemoApplication.class, args)));
  }

  @Override
  public void run(String... args) throws Exception {
    throw new MyException();
  }

  private class MyException extends RuntimeException {}
}

Then I execute the following commands to run the app:

mvn package
java -jar target/demo-1.0.0-SNAPSHOT.jar

After this commands I can check the exit code with the following command for windows:

echo Exit Code is %errorlevel%

And it returns:

Exit Code is 10

Answer 2

my needs is to System.exit() the application according to the exceptions I thrown

I would not recommend to call System.exit to kill your application as this will kill your job without gracefully shutting down the process and cleaning up resources.

If you use the CommandLineJobRunner , you can provide a custom ExitCodeMapper . See here: https://docs.spring.io/spring-batch/4.0.x/reference/html/job.html#exitCodes

If you use Spring Boot, you need to call System.exit with the return value of SpringApplication . You can find an example here: https://github.com/spring-projects/spring-boot/blob/master/spring-boot-samples/spring-boot-sample-batch/src/main/java/sample/batch/SampleBatchApplication.java#L67 and more details in the reference documentation here: https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#boot-features-application-exit

Now to be able to customise the exit code of the job when an exception occurs in the processor, you need to:

• propagate this information at the job level. This is possible by getting access to the job execution context in your processor and then use it in a job listener
• use a custom ExitCodeGenerator to get access to the job execution through the JobExectutionEvent sent by Spring Boot and customise the exit code

Here is an example:

@Configuration
@EnableBatchProcessing
public class MyJob {

@Autowired
private JobBuilderFactory jobs;

@Autowired
private StepBuilderFactory steps;

@Bean
public Step step() {
    return steps.get("step")
            .<Integer, Integer>chunk(2)
            .reader(new ListItemReader<>(Arrays.asList(1, 2, 3, 4)))
            .processor(new ItemProcessor<Integer, Integer>() {

                private StepExecution stepExecution;

                @BeforeStep
                public void beforeStep(StepExecution stepExecution) {
                    this.stepExecution = stepExecution;
                }

                @Override
                public Integer process(Integer item) {
                    if (item.equals(3)) {
                        stepExecution.getJobExecution().getExecutionContext().put("failure", "item not accepted");
                        throw new IllegalArgumentException("3 is not accepted");
                    }
                    return item;
                }
            })
            .writer(items -> {
                for (Integer item : items) {
                    System.out.println("item = " + item);
                }
            })
            .build();
}

@Bean
public Job job() {
    return jobs.get("job")
            .start(step())
            .listener(new JobExecutionListenerSupport() {
                @Override
                public void afterJob(JobExecution jobExecution) {
                    String failure = jobExecution.getExecutionContext().getString("failure");
                    if (failure != null && failure.equalsIgnoreCase("item not accepted")) {
                        jobExecution.setExitStatus(new ExitStatus("Not Accepted"));
                    }
                }
            })
            .build();
}

@Bean
public ExitCodeGenerator exitCodeGenerator () {
    return new MyExitCodeGenerator();
}

static class MyExitCodeGenerator implements ExitCodeGenerator, ApplicationListener<JobExecutionEvent> {

    private JobExecution jobExecution;

    @Override
    public int getExitCode() {
        if (jobExecution.getExitStatus().getExitCode().equalsIgnoreCase("Not Accepted")) {
            return 42;
        }
        return 0;
    }

    @Override
    public void onApplicationEvent(JobExecutionEvent jobExecutionEvent) {
        this.jobExecution = jobExecutionEvent.getJobExecution();
    }
   }

}

If you run this with:

@SpringBootApplication
public class DemoExitCodeApplication {

public static void main(String[] args) {
    System.exit(
            SpringApplication.exit(
                SpringApplication.run(DemoExitCodeApplication.class, args)
            )
    );
   }
}

The exit code of the JVM is 42, which is what was set when an exception is thrown in the processor.