Struct ChunkOrientedStepBuilder 

pub struct ChunkOrientedStepBuilder<'a, I, O> { /* private fields */ }

Builder for creating ChunkOrientedStep instances.

Provides a fluent API for configuring chunk-oriented steps with validation to ensure all required components (reader, processor, writer) are provided.

Type Parameters

• I: The input item type (what the reader produces)
• O: The output item type (what the processor produces and writer consumes)

Examples

use spring_batch_rs::core::step::ChunkOrientedStepBuilder;
use spring_batch_rs::core::item::{ItemReader, ItemProcessor, ItemWriter};
use spring_batch_rs::BatchError;

let reader = MyReader;
let processor = MyProcessor;
let writer = MyWriter;

let step = ChunkOrientedStepBuilder::new("number-to-string")
    .reader(&reader)
    .processor(&processor)
    .writer(&writer)
    .chunk_size(500)
    .skip_limit(25)
    .build();

Implementations

impl<'a, I, O> ChunkOrientedStepBuilder<'a, I, O>

pub fn new(name: &str) -> Self

Creates a new ChunkOrientedStepBuilder with the specified name.

Sets default values:

• chunk_size: 10
• skip_limit: 0 (no error tolerance)

Parameters

• name: Human-readable name for the step

Examples

use spring_batch_rs::core::step::ChunkOrientedStepBuilder;

let builder = ChunkOrientedStepBuilder::<String, String>::new("data-migration");

pub fn reader(self, reader: &'a dyn ItemReader<I>) -> Self

Sets the item reader for this step.

The reader is responsible for providing items to be processed. This is a required component for chunk-oriented steps.

Parameters

• reader: Implementation of ItemReader that produces items of type I

Examples

let reader = FileReader;
let builder = ChunkOrientedStepBuilder::<String, String>::new("file-processing")
    .reader(&reader);

pub fn processor(self, processor: &'a dyn ItemProcessor<I, O>) -> Self

Sets the item processor for this step.

The processor transforms items from type I to type O. This is a required component for chunk-oriented steps.

Parameters

• processor: Implementation of ItemProcessor that transforms items from I to O

Examples

let reader = FileReader;
let processor = UppercaseProcessor;
let builder = ChunkOrientedStepBuilder::new("text-processing")
    .reader(&reader)
    .processor(&processor);

pub fn writer(self, writer: &'a dyn ItemWriter<O>) -> Self

Sets the item writer for this step.

The writer is responsible for persisting processed items. This is a required component for chunk-oriented steps.

Parameters

• writer: Implementation of ItemWriter that consumes items of type O

Examples

let reader = FileReader;
let processor = UppercaseProcessor;
let writer = FileWriter;
let builder = ChunkOrientedStepBuilder::new("file-processing")
    .reader(&reader)
    .processor(&processor)
    .writer(&writer);

pub fn chunk_size(self, chunk_size: u16) -> Self

Sets the chunk size for this step.

The chunk size determines how many items are processed together in a single transaction. Larger chunks can improve performance but use more memory.

Parameters

• chunk_size: Number of items to process per chunk (must be > 0)

Examples

use spring_batch_rs::core::step::ChunkOrientedStepBuilder;

let builder = ChunkOrientedStepBuilder::<String, String>::new("bulk-processing")
    .chunk_size(1000); // Process 1000 items per chunk

pub fn skip_limit(self, skip_limit: u16) -> Self

Sets the skip limit for this step.

The skip limit determines how many errors are tolerated before the step fails. A value of 0 means no errors are tolerated.

Parameters

• skip_limit: Maximum number of errors allowed

Examples

use spring_batch_rs::core::step::ChunkOrientedStepBuilder;

let builder = ChunkOrientedStepBuilder::<String, String>::new("fault-tolerant-processing")
    .skip_limit(100); // Allow up to 100 errors

pub fn build(self) -> ChunkOrientedStep<'a, I, O>

Builds the ChunkOrientedStep instance.

Panics

Panics if any required component (reader, processor, writer) has not been set.

Examples

let reader = MyReader;
let processor = MyProcessor;
let writer = MyWriter;

let step = ChunkOrientedStepBuilder::new("complete-step")
    .reader(&reader)
    .processor(&processor)
    .writer(&writer)
    .chunk_size(500)
    .skip_limit(10)
    .build();