Struct ChunkOrientedStepBuilder 

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

Implementations

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

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 processor( self, processor: &'a dyn ItemProcessor<I, O>, ) -> ChunkOrientedStepBuilder<'a, I, O, HasProcessor>

Sets the item processor for this step.

The processor transforms items from type I to type O. Setting a processor is optional: when the reader’s output type I and the writer’s input type O are the same, omitting this call falls back to an internal identity processor in ChunkOrientedStepBuilder::build.

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);

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

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 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

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

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

Builds the ChunkOrientedStep instance using the processor set via ChunkOrientedStepBuilder::processor.

Panics

Panics if the reader or the 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();

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

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

Builds the ChunkOrientedStep instance, falling back to an internal identity processor since no processor was set.

This overload is only available when the reader’s output type I and the writer’s input type O are the same type: the fallback processor returns each item unchanged, so I and O must match. If they differ and no processor was set via ChunkOrientedStepBuilder::processor, this method is not applicable and the call to .build() fails to compile.

Panics

Panics if the reader or the writer has not been set.

Examples

let reader = MyReader;
let writer = MyWriter;

let step = ChunkOrientedStepBuilder::new("pass-through-step")
    .reader(&reader)
    .writer(&writer)
    .build();