NUHMAN.com

In Spring Batch, handling job failures effectively is crucial to ensure robustness and avoid unnecessary interruptions. You can configure Spring Batch jobs to retry after a failure or restart from where it left off. Here are two main strategies you can use:

• Retry Policy: Automatically retries a step if it fails.
• Job Restart: Restarts the entire job after a failure.

🛠️ 1. Using Retry Policy in Spring Batch

You can configure a retry policy to make Spring Batch retry a step a specific number of times before giving up. This is useful when the failure is transient, and you expect that retrying will resolve the issue.

Example: Setting up Retry Policy

java

import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.core.step.builder.StepBuilder;
import org.springframework.batch.retry.policy.SimpleRetryPolicy;
import org.springframework.batch.retry.support.RetryTemplate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class BatchConfig {

    @Bean
    public Step step(StepBuilderFactory stepBuilderFactory) {
        return stepBuilderFactory.get("stepName")
                .<InputType, OutputType>chunk(10)
                .reader(reader())
                .processor(processor())
                .writer(writer())
                .faultTolerant()
                .retryPolicy(retryPolicy())
                .build();
    }

    @Bean
    public RetryTemplate retryTemplate() {
        RetryTemplate retryTemplate = new RetryTemplate();
        SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy();
        retryPolicy.setMaxAttempts(2); // Number of retry attempts
        retryTemplate.setRetryPolicy(retryPolicy);
        return retryTemplate;
    }
}

Explanation:

• retryPolicy(): Specifies how many times the step will retry before failing.
• maxAttempts: Set the maximum number of retry attempts (in this case, 2).

🛠️ 2. Using Job Restart in Spring Batch

If you want to restart the entire job after a failure, Spring Batch provides built-in support for restarting jobs from where they left off.

Example: Configuring Job Restart

java

import org.springframework.batch.core.Job;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class BatchConfig {

    @Bean
    public Job job(JobBuilderFactory jobBuilderFactory, StepBuilderFactory stepBuilderFactory) {
        return jobBuilderFactory.get("jobName")
                .start(step(stepBuilderFactory))
                .preventRestart() // Prevents restart (remove if you want to allow restarts)
                .build();
    }

    @Bean
    public Step step(StepBuilderFactory stepBuilderFactory) {
        return stepBuilderFactory.get("stepName")
                .<InputType, OutputType>chunk(10)
                .reader(reader())
                .processor(processor())
                .writer(writer())
                .build();
    }
}

Explanation:

• preventRestart(): This can be omitted to allow job restarts. By default, Spring Batch allows restarts, but you can choose to prevent them if needed.

🛠️ 3. Handling Specific Exceptions in Spring Batch

You may want to skip certain exceptions or not roll back the transaction in case of specific errors. This allows the job to continue processing after certain exceptions.

Example: Skipping Specific Exceptions

java

@Bean
public Step step(StepBuilderFactory stepBuilderFactory) {
    return stepBuilderFactory.get("stepName")
            .<InputType, OutputType>chunk(10)
            .reader(reader())
            .processor(processor())
            .writer(writer())
            .faultTolerant()
            .skip(Exception.class) // Skips specific exceptions
            .skipLimit(1) // Limit the number of skips
            .build();
}

Explanation:

• skip(Exception.class): Tells Spring Batch to skip the step if the specified exception occurs.
• skipLimit(1): Limits the number of times an exception can be skipped.

🧠 Key Strategies for Failure Handling

FeatureApproachDescriptionRetry MechanismretryPolicy()Retries the step a specified number of times before failure.Job RestartpreventRestart() or default configurationRestarts the entire job from where it left off.Skipping Exceptionsskip(Exception.class)Skips specific exceptions and continues the job.

🔧 Use Cases and Applications

• ✅ Retrying transient issues: When dealing with network errors or temporary resource unavailability.
• ✅ Restarting after critical failures: Ideal for large batch jobs that need to pick up from where they left off.
• ✅ Skipping known non-critical errors: For example, skipping invalid records but continuing with others.

🚀 Summary

• Retry Policy: Set a retry count to attempt recovering from failures.
• Job Restart: Allow jobs to restart from where they left off if they fail.
• Exception Handling: Skip known exceptions to avoid stopping the job.

You can customize the approach based on the severity of errors and your business requirements, making your Spring Batch jobs more resilient and fault-tolerant.