How data is passed from Reader to Processor and to Writer - spring-batch

Question

I am new to spring batch. I want to understand how the data is passed from Reader to Processor and from processor to Writer? So basically in Reader we will be having read() method which will return some kind of data, say String.. this return type will be used as an input parameter in process() method in Processor.
So what I want to understand is once read() method returns a String data, until it reaches process() method, how this transfer is handled? Does spring stores this data somewhere and then passes to the next phase? How it happens?
Any pointers to understand this or some good links to readup on the same are welcome.
Thanks in advance!

Answer 1

Spring Batch uses chunk-oriented processing as explained here: https://docs.spring.io/spring-batch/4.0.x/reference/html/step.html#chunkOrientedProcessing
The idea is to read/process items one at a time until a chunk (of a predefined size) is created. This design choice avoids loading the whole data source in memory which is very efficient when dealing with large amounts of data. The writing on the other hand operates on a chunk of items (and not a single item) in order to optimize writes (like jdbc batch inserts or elastic search bulk inserts).
If you want more details on what's happening behind the scene, I invite you to take a look at the code of the ChunkOrientedTasklet class which uses basically two collaborators:
A ChunkProvider which provides chunks of items (delegating item reading to an ItemReader)
A ChunkProcessor which processes chunks (delegating processing and writing respectively to an ItemProcessor/ItemWriter)
Here is a simplified version of the code:
Chunk inputs = chunkProvider.provide(contribution);
chunkProcessor.process(contribution, inputs);
The contribution object is used to add the chunk contribution to the step. So to answer your question:
"how this transfer is handled? Does spring stores this data somewhere and then passes to the next phase?"
Items are actually handed between these two collaborators through the inputs variable of type Chunk.
Hope this helps!

Answer 2

You seem to be thinking about this as WAY more complicated than it is. This is no different than any other object oriented method call.
When the read() method completes it returns a (hopefully defined generics typed) object(s) which then is passed as an argument to the process() method which then when it completes passes that object(s) the write() method. It all takes place effective instantly, in memory (which is why jobs are chucked) just the same way you pass any object to a method.
Object someData = read();
process(someData);
write(someData);