Spring Batch এ Step হলো একটি ব্যাচ জবের একটি গুরুত্বপূর্ণ অংশ যা ডাটা প্রক্রিয়া করার জন্য নির্দিষ্ট একটি কাজ সম্পাদন করে। এক বা একাধিক স্টেপের সমন্বয়ে একটি ব্যাচ জব গঠিত হয়। প্রতিটি Step নির্দিষ্ট ইনপুট, প্রসেসিং এবং আউটপুট করার জন্য কনফিগার করা হয়। Step Configuration এ আপনি ItemReader, ItemProcessor, এবং ItemWriter এর মধ্যে সম্পর্ক স্থাপন করেন, যা ডাটা রিড, প্রসেস, এবং লেখার জন্য ব্যবহৃত হয়।
Spring Batch এ Step Configuration হল ব্যাচ প্রক্রিয়া কনফিগার করার অন্যতম গুরুত্বপূর্ণ অংশ। এখানে ব্যাচ প্রক্রিয়ার কাজ সম্পন্ন করার জন্য আপনাকে Step কনফিগার করতে হয় এবং একটি ব্যাচ জব তৈরির সময় একাধিক Step যোগ করা যায়।
Spring Batch Step Configuration এর মধ্যে নিম্নলিখিত উপাদানগুলির কনফিগারেশন করা হয়:
Spring Batch Step কনফিগারেশন সঠিকভাবে তৈরি করতে নিচে একটি উদাহরণ দেওয়া হয়েছে যেখানে ItemReader, ItemProcessor, এবং ItemWriter কনফিগার করা হয়েছে।
package com.example.demo;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.core.launch.support.RunIdIncrementer;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.item.ItemReader;
import org.springframework.batch.item.ItemProcessor;
import org.springframework.batch.item.ItemWriter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class BatchConfig {
@Bean
public Job job(JobBuilderFactory jobBuilderFactory, Step step1) {
return jobBuilderFactory.get("job")
.incrementer(new RunIdIncrementer())
.flow(step1) // Step configuration
.end()
.build();
}
@Bean
public Step step1(StepBuilderFactory stepBuilderFactory,
ItemReader<String> reader,
ItemProcessor<String, String> processor,
ItemWriter<String> writer) {
return stepBuilderFactory.get("step1")
.<String, String>chunk(10) // chunk size set to 10
.reader(reader)
.processor(processor)
.writer(writer)
.build();
}
// ItemReader, ItemProcessor, and ItemWriter beans will be configured below
}
এখানে, StepBuilderFactory এর মাধ্যমে Step কনফিগার করা হয়েছে এবং chunk(10) এর মাধ্যমে প্রতিটি চাঙ্কে ১০টি আইটেম প্রক্রিয়া হবে সেটি নির্ধারণ করা হয়েছে।
ItemReader, ItemProcessor, এবং ItemWriter তৈরি করা হয় যেগুলি ডাটা রিড, প্রসেস এবং লেখার জন্য ব্যবহৃত হবে।
package com.example.demo;
import org.springframework.batch.item.ItemReader;
import org.springframework.batch.item.ItemProcessor;
import org.springframework.batch.item.ItemWriter;
import org.springframework.stereotype.Component;
import java.util.List;
@Component
public class SimpleReader implements ItemReader<String> {
private int count = 0;
private final String[] data = {"Item1", "Item2", "Item3", "Item4", "Item5"};
@Override
public String read() throws Exception {
if (count < data.length) {
return data[count++];
}
return null; // End of data
}
}
@Component
public class SimpleProcessor implements ItemProcessor<String, String> {
@Override
public String process(String item) throws Exception {
return item.toUpperCase(); // Convert item to uppercase
}
}
@Component
public class SimpleWriter implements ItemWriter<String> {
@Override
public void write(List<? extends String> items) throws Exception {
items.forEach(System.out::println); // Write each item to console
}
}
এখানে, SimpleReader ক্লাসে read()
মেথড ব্যবহার করে ডাটাবেস বা ফাইল থেকে ডাটা পড়া হচ্ছে। SimpleProcessor ডাটাকে uppercase করে এবং SimpleWriter ডাটাকে কনসোলে লিখছে।
Spring Batch এর JobLauncher ব্যবহার করে ব্যাচ জব রান করা হয়। এই জবটি চালানোর জন্য CommandLineRunner অথবা অন্য কোনো Trigger ব্যবহার করা যেতে পারে।
package com.example.demo;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
@Component
public class JobRunner implements CommandLineRunner {
@Autowired
private JobLauncher jobLauncher;
@Autowired
private Job job;
@Override
public void run(String... args) throws Exception {
jobLauncher.run(job, new JobParameters());
}
}
এখানে JobLauncher ব্যাচ জব চালানোর জন্য ব্যবহৃত হচ্ছে এবং run() মেথডের মাধ্যমে এই জবটি চালানো হচ্ছে।
Spring Batch এ Step Configuration একটি গুরুত্বপূর্ণ অংশ, যা ডাটা রিড, প্রসেস এবং লেখার জন্য ব্যবহৃত হয়। ItemReader, ItemProcessor, এবং ItemWriter ব্যবহার করে Step কনফিগার করা হয়, এবং chunk-based processing এর মাধ্যমে একসাথে একাধিক ডাটা প্রক্রিয়া করা হয়। Spring Batch এর Step কনফিগারেশন ডাটা প্রক্রিয়ার গতি বৃদ্ধি, রিসোর্স ব্যবস্থাপনা এবং অ্যাপ্লিকেশনের স্কেলেবিলিটি উন্নত করতে সাহায্য করে।
Spring Batch একটি শক্তিশালী ফ্রেমওয়ার্ক যা বড় পরিমাণে ডেটা প্রক্রিয়াকরণের জন্য ব্যবহৃত হয়। এটি বিশেষ করে ব্যাচ প্রসেসিংয়ের জন্য ডিজাইন করা হয়েছে, যেখানে আপনি একটি সিরিজের কাজ বা কাজের ধাপ (steps) সম্পন্ন করার মাধ্যমে বড় কাজগুলো সম্পাদন করেন। Spring Batch-এ Step একটি অত্যন্ত গুরুত্বপূর্ণ উপাদান, কারণ এটি ব্যাচ প্রসেসিংয়ের একটি মৌলিক ইউনিট।
Spring Batch-এ Step হল একটি একক কাজ যা একটি ব্যাচ জব (Job) এর অংশ হিসেবে পরিচালিত হয়। প্রতিটি Step ডেটা রিড, প্রসেস এবং রাইটের মতো নির্দিষ্ট কাজ সম্পাদন করে। Step একটি নির্দিষ্ট কাজ বা প্রক্রিয়ার অংশ, যা পুরো ব্যাচ জবের কার্যক্রমে অবদান রাখে। Step গুলি সিরিয়ালি বা প্যারালালি একে অপরের পর পর সম্পন্ন হতে পারে।
প্রতিটি Step একটি নির্দিষ্ট কার্যকলাপ (যেমন: ডেটা রিড করা, প্রক্রিয়া করা, অথবা ডেটা রাইট করা) সম্পাদন করে এবং এটি সফলভাবে বা ব্যর্থভাবে শেষ হতে পারে। যখন Step সফলভাবে সম্পন্ন হয়, তখন এটি পরবর্তী Step বা শেষ জবের ফলাফল তৈরি করতে সাহায্য করে।
Spring Batch-এ একটি Step মূলত তিনটি উপাদান দিয়ে গঠিত:
এগুলি একত্রে একটি Chunk Processing প্যাটার্নে কাজ করে, যেখানে ডেটা ছোট অংশে প্রক্রিয়া করা হয় এবং প্রতিটি অংশ শেষে রাইট করা হয়।
@Bean
public Job job(JobCompletionNotificationListener listener, Step step1) {
return jobBuilderFactory.get("job")
.incrementer(new RunIdIncrementer())
.listener(listener)
.start(step1) // Step 1 কে চালু করে
.build();
}
@Bean
public Step step1(ItemReader<MyItem> reader, ItemProcessor<MyItem, MyProcessedItem> processor, ItemWriter<MyProcessedItem> writer) {
return stepBuilderFactory.get("step1")
.<MyItem, MyProcessedItem>chunk(10) // Chunk size 10
.reader(reader) // ডেটা রিড করতে
.processor(processor) // ডেটা প্রসেস করতে
.writer(writer) // প্রক্রিয়া করা ডেটা রাইট করতে
.build();
}
এখানে, step1
হল একটি Step, যা ItemReader
, ItemProcessor
, এবং ItemWriter
ব্যবহার করে ডেটা প্রক্রিয়াকরণের জন্য একটি chunk প্রক্রিয়া পরিচালনা করছে।
Spring Batch-এ Step ব্যাচ প্রসেসিংয়ের মৌলিক ইউনিট। একটি Job তৈরি করতে কমপক্ষে একটি Step প্রয়োজন, এবং প্রতিটি Step ব্যাচ প্রক্রিয়ার একটি নির্দিষ্ট অংশে কাজ করে। একটি Job সাধারণত একাধিক Step নিয়ে গঠিত হয়, এবং প্রতিটি Step আলাদা আলাদা কাজ করে (যেমন ডেটা রিড করা, প্রসেস করা এবং রাইট করা)।
Spring Batch-এ Step ব্যবহারের মাধ্যমে আপনি ব্যাচ প্রসেসিংয়ে আলাদা আলাদা কাজের জন্য পৃথক কাস্টম লজিক প্রয়োগ করতে পারেন। প্রতিটি Step নির্দিষ্টভাবে আলাদা কাজ করে এবং এটি সফলভাবে বা ব্যর্থভাবে সম্পন্ন হতে পারে। এটি ব্যাচ প্রসেসিংয়ের উন্নত নিয়ন্ত্রণ এবং কাস্টমাইজেশন প্রদান করে।
প্রতিটি Step ব্যাচ প্রসেসিংয়ের একটি আলাদা অংশ হওয়ায়, আপনি Step-এর জন্য পৃথকভাবে ত্রুটি পরিচালনা এবং পুনঃপ্রচেষ্টার কৌশল প্রয়োগ করতে পারেন। যদি একটি Step কোনো কারণে ব্যর্থ হয়, তবে আপনি শুধুমাত্র সেই Step পুনরায় চালাতে পারেন এবং পুরো Job পুনরায় চালানোর দরকার নেই।
Step ব্যবহারের মাধ্যমে, আপনি প্রতিটি ধাপের জন্য আলাদা আলাদা কনফিগারেশন এবং পারফরম্যান্স টিউনিং করতে পারেন। আপনি Chunk Processing ব্যবহার করে ডেটা ছোট অংশে প্রক্রিয়া করতে পারেন, যা পারফরম্যান্স উন্নত করে এবং মেমরি ব্যবস্থাপনা সহজ করে।
chunk
ব্যবহার করে তা ছোট ছোট অংশে প্রক্রিয়া করা যাবে, যা পুরো প্রক্রিয়াকে অনেক দ্রুত এবং কার্যকরী করে।Step ব্যবহারের মাধ্যমে আপনি আপনার ব্যাচ জবের কার্যক্রমগুলিকে লজিক্যালি বিভক্ত করতে পারেন। এটি কোড রিইউজেবিলিটি বৃদ্ধি করে এবং নির্দিষ্ট কাজের জন্য আলাদা আলাদা Step তৈরি করা সহজ হয়।
Spring Batch-এ Chunk Processing একটি গুরুত্বপূর্ণ কনসেপ্ট। এটি একটি প্রক্রিয়া প্যাটার্ন যেখানে ডেটা ছোট ছোট অংশে (chunks) প্রক্রিয়া করা হয়। প্রতিটি Step একটি chunk প্রক্রিয়া করে, যেখানে নির্দিষ্ট সংখ্যক আইটেম একসাথে পড়া, প্রক্রিয়া করা এবং লেখা হয়। এটি মেমরি ব্যবস্থাপনা এবং পারফরম্যান্স উন্নত করতে সহায়তা করে।
@Bean
public Step step1(ItemReader<MyItem> reader, ItemProcessor<MyItem, MyProcessedItem> processor, ItemWriter<MyProcessedItem> writer) {
return stepBuilderFactory.get("step1")
.<MyItem, MyProcessedItem> chunk(10) // Chunk size 10
.reader(reader)
.processor(processor)
.writer(writer)
.build();
}
এখানে chunk(10)
নির্ধারণ করছে যে, প্রতি 10টি আইটেম একত্রে পড়া, প্রক্রিয়া করা এবং লেখা হবে।
Spring Batch-এ Step হল একটি ব্যাচ জবের মূল উপাদান, যা একটি নির্দিষ্ট কাজ বা কার্যকলাপ সম্পন্ন করে। Step এর মধ্যে ItemReader, ItemProcessor, এবং ItemWriter অন্তর্ভুক্ত থাকে যা ডেটা রিড, প্রসেস এবং রাইট করার জন্য ব্যবহৃত হয়। Step ব্যবহারের মাধ্যমে আপনি ব্যাচ প্রক্রিয়াকে ছোট ছোট ইউনিটে বিভক্ত করতে পারেন, যা কোডের রিইউজেবিলিটি, পারফরম্যান্স এবং ত্রুটি পরিচালনাকে সহজ করে তোলে। Spring Batch-এ Step-এর মাধ্যমে আপনি ডেটা প্রক্রিয়াকরণের কার্যক্রমকে আরও নিয়ন্ত্রিত এবং স্কেলেবল করতে পারেন।
স্প্রিং ব্যাচ (Spring Batch) একটি ফ্রেমওয়ার্ক যা বড় পরিসরের ব্যাচ প্রসেসিং-এর জন্য ডিজাইন করা হয়েছে। এটি মূলত জাভা টেকনোলজি ব্যবহার করে ডেটা প্রক্রিয়াকরণের জন্য ব্যবহৃত হয়। স্প্রিং ব্যাচের মধ্যে দুটি মূল উপাদান আছে যেগুলোর মাধ্যমে ব্যাচ প্রসেসিং পরিচালিত হয়: Chunk-based এবং Tasklet-based Step। এই দুইটি ভিত্তিক Step-এর কাজগুলো বিস্তারিতভাবে জানবো।
Chunk-based Step হলো একটি স্টেপ যেখানে ডেটা ছোট ছোট অংশে (chunk) ভাগ করা হয় এবং প্রতিটি অংশের উপর আলাদা করে প্রসেসিং করা হয়। এটি তখনই উপকারী হয় যখন আপনি খুব বড় পরিসরের ডেটা নিয়ে কাজ করছেন এবং একে একে সব ডেটা মেমোরিতে লোড করা সম্ভব নয়।
এতে করে প্রতি chunk এর শেষে commit করা হয়, অর্থাৎ প্রতি chunk প্রসেসিং শেষে ডেটা ডাটাবেসে সেভ হয়ে যায়।
Tasklet-based Step একটি সাধারাণ স্টেপ যেখানে একটি নির্দিষ্ট কাজ সম্পন্ন করার জন্য শুধুমাত্র একটির বেশি কার্যক্রম বা স্টেপের প্রয়োজন হয় না। Tasklet হল একটি সিঙ্গল টাস্ক যা ব্যাচ প্রসেসিংয়ের জন্য বিশেষভাবে উপযুক্ত, যেমন কোনও সিস্টেম বা ফাইল থেকে ডেটা সরানো, বা ডেটাবেসের মধ্যে নির্দিষ্ট আপডেট করা।
execute()
মেথডের মাধ্যমে কাজ করে যা যে কাজটি করবে তা নির্দেশ করে।ফাইল সিস্টেম থেকে একটি ফাইল মুছে ফেলতে Tasklet-based Step ব্যবহার করা যেতে পারে।
প্রতিটি Step-ই নির্দিষ্ট পরিস্থিতিতে উপকারী। Chunk-based Step তখন ব্যবহৃত হয় যখন বড় পরিসরের ডেটা প্রসেস করতে হয় এবং Tasklet-based Step ব্যবহৃত হয় যখন একটি নির্দিষ্ট একক কাজ সম্পাদন করা প্রয়োজন।
স্প্রিং ব্যাচে Chunk-based এবং Tasklet-based Step-এ কাজ করার জন্য প্রাথমিকভাবে স্প্রিং ব্যাচের কিছু প্রয়োজনীয় কনফিগারেশন তৈরি করতে হয়। নিচে বিস্তারিত কোড সহ দুইটি ধরণের Step-এর উদাহরণ দেওয়া হলো।
Chunk-based প্রসেসিং-এ আপনি ডেটা পঠন, প্রক্রিয়া, এবং লেখার জন্য আলাদা আলাদা অংশ তৈরি করবেন। এখানে ItemReader
, ItemProcessor
, এবং ItemWriter
ব্যবহার করা হয়।
স্প্রিং ব্যাচ ব্যবহার করতে হলে, pom.xml ফাইলে নিচের ডিপেনডেন্সি গুলি যুক্ত করতে হবে:
<dependency>
<groupId>org.springframework.batch</groupId>
<artifactId>spring-batch-core</artifactId>
<version>5.0.0</version> <!-- Ensure to use the latest version -->
</dependency>
ItemReader
, ItemProcessor
, এবং ItemWriter
ক্লাস তৈরিimport org.springframework.batch.item.ItemProcessor;
import org.springframework.batch.item.ItemReader;
import org.springframework.batch.item.ItemWriter;
import org.springframework.stereotype.Component;
@Component
public class MyItemProcessor implements ItemProcessor<MyData, MyData> {
@Override
public MyData process(MyData item) throws Exception {
// Process each item (e.g., transforming it)
item.setName(item.getName().toUpperCase());
return item;
}
}
@Component
public class MyItemReader implements ItemReader<MyData> {
private List<MyData> data = Arrays.asList(
new MyData("John"), new MyData("Jane"), new MyData("Doe")
);
private int index = 0;
@Override
public MyData read() throws Exception {
if (index < data.size()) {
return data.get(index++);
}
return null; // End of data
}
}
@Component
public class MyItemWriter implements ItemWriter<MyData> {
@Override
public void write(List<? extends MyData> items) throws Exception {
for (MyData item : items) {
System.out.println("Writing: " + item.getName());
}
}
}
import org.springframework.batch.core.Step;
import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.core.launch.support.RunIdIncrementer;
import org.springframework.batch.core.repository.JobRepository;
import org.springframework.batch.core.step.tasklet.TaskletStep;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.batch.core.Job;
@Configuration
@EnableBatchProcessing
public class BatchConfig {
@Bean
public Job job(JobBuilderFactory jobBuilderFactory, Step step) {
return jobBuilderFactory.get("myJob")
.incrementer(new RunIdIncrementer())
.start(step)
.build();
}
@Bean
public Step step(StepBuilderFactory stepBuilderFactory, MyItemReader reader, MyItemProcessor processor, MyItemWriter writer) {
return stepBuilderFactory.get("myStep")
.<MyData, MyData>chunk(2) // 2 items per chunk
.reader(reader)
.processor(processor)
.writer(writer)
.build();
}
}
MyData
ক্লাসpublic class MyData {
private String name;
public MyData(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
এই কনফিগারেশন অনুসারে, ২টি ডেটা একসাথে প্রসেস করা হবে প্রতি চাঙ্কে এবং প্রতিটি আইটেম প্রসেস করার পরে ItemWriter
তাদের আউটপুট দেখাবে।
Tasklet-based Step-এ আপনি একক কার্যক্রম সম্পাদন করেন। উদাহরণস্বরূপ, একটি ফাইল থেকে ডেটা সরিয়ে ফেলা বা নির্দিষ্ট কোনও কাজ করতে এই পদ্ধতি ব্যবহার করা হয়।
import org.springframework.batch.core.Step;
import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.core.launch.support.RunIdIncrementer;
import org.springframework.batch.core.repository.JobRepository;
import org.springframework.batch.core.step.tasklet.Tasklet;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.batch.core.Job;
@Configuration
@EnableBatchProcessing
public class TaskletBatchConfig {
@Bean
public Job taskletJob(JobBuilderFactory jobBuilderFactory, Step taskletStep) {
return jobBuilderFactory.get("taskletJob")
.incrementer(new RunIdIncrementer())
.start(taskletStep)
.build();
}
@Bean
public Step taskletStep(StepBuilderFactory stepBuilderFactory, Tasklet myTasklet) {
return stepBuilderFactory.get("taskletStep")
.tasklet(myTasklet)
.build();
}
@Bean
public Tasklet myTasklet() {
return (contribution, chunkContext) -> {
System.out.println("Executing Tasklet...");
return null; // return null to indicate completion
};
}
}
এখানে Tasklet একটি নির্দিষ্ট কাজ সম্পাদন করছে, যেমন কনসোল আউটপুট। আপনি আরও জটিল কাজ যেমন ফাইল রিড, ডাটাবেস অপারেশন বা ফাইল মুছে ফেলা ইত্যাদি করতে পারেন।
এই দুইটি উদাহরণের মাধ্যমে আপনি স্প্রিং ব্যাচের Chunk-based এবং Tasklet-based Step এর কনফিগারেশন এবং কাজ দেখতে পেলেন। আপনার প্রজেক্টের প্রয়োজন অনুযায়ী এগুলো ব্যবহার করতে পারেন।
Spring Batch একটি শক্তিশালী ফ্রেমওয়ার্ক যা ব্যাচ প্রসেসিংয়ের জন্য ব্যবহৃত হয়, যেমন বড় ডেটাসেটের প্রক্রিয়াকরণ, ডেটা ট্রান্সফরমেশন, এবং ডেটা মাইগ্রেশন। Spring Batch এর একটি গুরুত্বপূর্ণ উপাদান হলো Step, যা একটি নির্দিষ্ট ব্যাচ কাজ সম্পাদন করে। Step দুটি প্রধান ধরনের হতে পারে: Chunk-based এবং Tasklet-based।
এই দুইটি ধরনের Step এর কাজ আলাদা, এবং এগুলির মাধ্যমে ডেটা প্রসেসিংয়ের বিভিন্ন শৈলী ব্যবহার করা যায়।
Chunk-based Step হলো এমন একটি প্রসেসিং মডেল যেখানে ডেটাকে ছোট ছোট অংশ (chunk) এ বিভক্ত করে একাধিক রেকর্ড একসঙ্গে প্রসেস করা হয়। একটি chunk-এ অনেকগুলো আইটেম হতে পারে, এবং প্রতিটি chunk প্রসেস করার পর, সেই chunk এর জন্য একত্রিত হয়ে একটি কমিট (commit) করা হয়।
ItemWriter
দিয়ে ডেটা কমিট করা হয়। অর্থাৎ, chunk এর সমস্ত আইটেম একত্রে প্রক্রিয়াকৃত হয়ে আউটপুটে লেখা হয়।@Bean
public Step step1() {
return stepBuilderFactory.get("step1")
.<Person, Person> chunk(10) // প্রতি 10টি আইটেমের পরে কমিট হবে
.reader(personReader())
.processor(personProcessor())
.writer(personWriter())
.build();
}
@Bean
public ItemReader<Person> personReader() {
return new PersonItemReader(); // ডেটা রিডারের উদাহরণ
}
@Bean
public ItemProcessor<Person, Person> personProcessor() {
return new PersonItemProcessor(); // ডেটা প্রসেসরের উদাহরণ
}
@Bean
public ItemWriter<Person> personWriter() {
return new PersonItemWriter(); // ডেটা রাইটারের উদাহরণ
}
এখানে, chunk(10)
নির্দেশ করে যে প্রতি 10টি আইটেম প্রসেস হওয়ার পর কমিট করা হবে। এটি ItemReader, ItemProcessor, এবং ItemWriter সমন্বয়ে কাজ করে।
Tasklet-based Step হলো এমন একটি প্রসেসিং মডেল যেখানে একটি নির্দিষ্ট কাজ (task) একবারে সম্পন্ন করা হয়। এখানে ডেটার chunk ভাগ করা হয় না, বরং একটি নির্দিষ্ট কাজ একটি স্টেপে সম্পন্ন হয়, যেমন ডেটাবেস টেবিল ক্লিয়ার করা, ফাইল মুছে ফেলা বা কোনো নির্দিষ্ট স্ট্যাটাস আপডেট করা। Tasklet একটি প্রক্রিয়া বা কাজের উপর দৃষ্টি নিবদ্ধ করে, যা সাধারণত Void ধরনের কাজ হয়।
ExecutionContext
ব্যবহার করে আপনি স্টেপের মধ্যে স্টেট সংরক্ষণ করতে পারেন, যা পরবর্তী রানগুলোর জন্য দরকারি হতে পারে।@Bean
public Step step2() {
return stepBuilderFactory.get("step2")
.tasklet(new Tasklet() {
@Override
public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {
System.out.println("Tasklet is executing");
return RepeatStatus.FINISHED; // কাজ সম্পন্ন হলে।
}
})
.build();
}
এখানে একটি Tasklet তৈরি করা হয়েছে যা একটি কাজ সম্পাদন করবে, যেমন কনসোল এ "Tasklet is executing" মেসেজ প্রিন্ট করবে।
Feature | Chunk-based Step | Tasklet-based Step |
---|---|---|
Data Processing | ডেটার আইটেমগুলো chunk আকারে প্রসেস করা হয়। | একক কাজ (task) হিসাবে একবারেই কাজ করা হয়। |
Use Case | বড় আকারের ডেটা প্রসেসিং (যেমন ডেটাবেস থেকে তথ্য সংগ্রহ করা)। | ছোট কাজ, যেমন ক্লিনআপ বা রিপোর্ট তৈরি। |
Error Handling | Chunk প্রক্রিয়াকরণের মধ্যে ত্রুটি ঘটলে পুরো chunk পুনরায় প্রসেস করা যায়। | কোনো ত্রুটি হলে পুরো task পুনরায় চেষ্টা করা যায়। |
Transaction Management | প্রতিটি chunk আলাদা আলাদা ট্রানজেকশনে সম্পাদিত হয়। | একটি ট্রানজেকশনে সম্পূর্ণ task সম্পন্ন হয়। |
Complexity | বেশি জটিল এবং ডেটার সাথে কাজ করতে উপযোগী। | সহজ, ছোট কাজগুলোর জন্য উপযোগী। |
Spring Batch এ Chunk-based Step এবং Tasklet-based Step দুটি আলাদা ধরনের প্রসেসিং মডেল। Chunk-based Step বৃহত্তর ডেটাসেট নিয়ে কাজ করতে উপযোগী, যেখানে ডেটা ছোট ছোট অংশে ভাগ করে প্রসেস করা হয় এবং প্রতিটি chunk প্রসেস করার পর ডেটা কমিট করা হয়। অন্যদিকে, Tasklet-based Step একক কাজের জন্য ব্যবহৃত হয়, যেখানে একটি নির্দিষ্ট কাজ একবারে সম্পন্ন হয়। উভয় মডেলই Spring Batch এ ব্যাচ প্রসেসিংয়ের জন্য গুরুত্বপূর্ণ ভূমিকা পালন করে, এবং উপযুক্ত পরিস্থিতিতে প্রতিটি মডেল ব্যবহার করা যেতে পারে।
Spring Batch এর একটি গুরুত্বপূর্ণ অংশ হল Step Configuration, যেখানে একটি Step এর মাধ্যমে একটি ব্যাচ প্রোগ্রামে একাধিক কাজ সম্পন্ন করা হয়। Step একটি নির্দিষ্ট কাজের সেটকে নির্দেশ করে, যেমন ডেটা রিড করা, প্রোসেস করা এবং রাইট করা। প্রতিটি Step সাধারণত একটি ItemReader, ItemProcessor, এবং ItemWriter ব্যবহার করে কাজ সম্পন্ন করে।
এখানে একটি Step Configuration এর উদাহরণ দেওয়া হবে, যেখানে Spring Batch এর বিভিন্ন কনফিগারেশন ব্যবহার করে একটি Step তৈরি করা হবে।
Spring Batch অ্যাপ্লিকেশন তৈরি করতে হলে প্রথমে spring-boot-starter-batch ডিপেনডেন্সি pom.xml
ফাইলে যোগ করতে হবে।
<dependencies>
<!-- Spring Boot Starter Web -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- Spring Boot Starter Batch -->
<dependency>
<groupId>org.springframework.batch</groupId>
<artifactId>spring-batch-core</artifactId>
</dependency>
<!-- H2 Database for in-memory DB (optional) -->
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
</dependencies>
এখানে, spring-batch-core
ডিপেনডেন্সি Spring Batch এর প্রধান কার্যকারিতা প্রদান করে এবং H2 ডাটাবেস (যদি আপনি ডেটাবেস ব্যবহার করতে চান) একটি ইন-মেমরি ডেটাবেস হিসেবে ব্যবহার করা হচ্ছে।
Spring Batch এ Step তৈরি করতে হলে ItemReader, ItemProcessor, এবং ItemWriter এর কম্পোনেন্টগুলো কনফিগার করা হয়।
package com.example.batch.config;
import com.example.batch.model.User;
import com.example.batch.processor.UserItemProcessor;
import com.example.batch.reader.UserItemReader;
import com.example.batch.writer.UserItemWriter;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.launch.support.RunIdIncrementer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
@EnableBatchProcessing
public class BatchConfig {
private final JobBuilderFactory jobBuilderFactory;
private final StepBuilderFactory stepBuilderFactory;
public BatchConfig(JobBuilderFactory jobBuilderFactory, StepBuilderFactory stepBuilderFactory) {
this.jobBuilderFactory = jobBuilderFactory;
this.stepBuilderFactory = stepBuilderFactory;
}
@Bean
public Job userJob() {
return jobBuilderFactory.get("userJob")
.incrementer(new RunIdIncrementer())
.start(userStep())
.build();
}
@Bean
public Step userStep() {
return stepBuilderFactory.get("userStep")
.<User, User>chunk(10) // Process 10 items at a time
.reader(userItemReader())
.processor(userItemProcessor())
.writer(userItemWriter())
.build();
}
@Bean
public UserItemReader userItemReader() {
return new UserItemReader();
}
@Bean
public UserItemProcessor userItemProcessor() {
return new UserItemProcessor();
}
@Bean
public UserItemWriter userItemWriter() {
return new UserItemWriter();
}
}
এখানে:
userStep()
নামক Step কে অন্তর্ভুক্ত করা হয়েছে।chunk(10)
পদ্ধতি ব্যবহার করা হয়েছে, যা প্রতি 10টি আইটেম একসাথে প্রসেস করবে।এখন, ItemReader, ItemProcessor, এবং ItemWriter ক্লাসগুলো তৈরি করা হবে, যেগুলি Step এর মধ্যে কাজ করবে।
ItemReader ক্লাসটি ডেটা পড়ার জন্য ব্যবহৃত হয়। এখানে, UserItemReader
ক্লাস একটি সিম্পল ইউজার ডেটা রিডার হিসেবে কাজ করবে।
package com.example.batch.reader;
import com.example.batch.model.User;
import org.springframework.batch.item.ItemReader;
import java.util.Arrays;
import java.util.List;
public class UserItemReader implements ItemReader<User> {
private final List<User> users = Arrays.asList(
new User("John", "john@example.com"),
new User("Jane", "jane@example.com"),
new User("Bob", "bob@example.com")
);
private int index = 0;
@Override
public User read() throws Exception {
if (index < users.size()) {
return users.get(index++);
}
return null; // Return null when all items are read
}
}
এখানে, UserItemReader একটি স্ট্যাটিক লিস্ট থেকে ইউজার ডেটা রিড করে। প্রতিবার কল করার সময় এটি পরবর্তী ইউজার অবজেক্ট রিটার্ন করবে।
ItemProcessor ডেটা প্রসেস করার জন্য ব্যবহৃত হয়। এখানে, UserItemProcessor
ক্লাসের মধ্যে ডেটা প্রসেস করা হবে।
package com.example.batch.processor;
import com.example.batch.model.User;
import org.springframework.batch.item.ItemProcessor;
public class UserItemProcessor implements ItemProcessor<User, User> {
@Override
public User process(User item) throws Exception {
item.setName(item.getName().toUpperCase()); // Convert name to uppercase
return item;
}
}
এখানে, UserItemProcessor প্রতিটি User
অবজেক্টের নামকে uppercase তে রূপান্তর করবে।
ItemWriter ডেটা লেখার জন্য ব্যবহৃত হয়। এখানে, UserItemWriter
ক্লাস কনসোলে প্রোসেস করা ডেটা লেখবে।
package com.example.batch.writer;
import com.example.batch.model.User;
import org.springframework.batch.item.ItemWriter;
import java.util.List;
public class UserItemWriter implements ItemWriter<User> {
@Override
public void write(List<? extends User> items) throws Exception {
for (User user : items) {
System.out.println("Writing user: " + user);
}
}
}
এখানে, UserItemWriter প্রোসেস করা User
অবজেক্টগুলি কনসোলে প্রিন্ট করে।
এখন, আমাদের একটি User মডেল ক্লাস তৈরি করতে হবে, যেটি ডেটা রিড, প্রোসেস এবং রাইট করার জন্য ব্যবহৃত হবে।
package com.example.batch.model;
public class User {
private String name;
private String email;
// Constructor
public User(String name, String email) {
this.name = name;
this.email = email;
}
// Getters and Setters
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
@Override
public String toString() {
return "User{name='" + name + "', email='" + email + "'}";
}
}
এখানে, User ক্লাসের মধ্যে নাম এবং ইমেইল ফিল্ড রয়েছে এবং সেগুলির জন্য গেটার এবং সেটার মেথড রয়েছে।
Spring Batch অ্যাপ্লিকেশন চালানোর জন্য, আপনি BatchConfig কনফিগারেশন ক্লাসে JobLauncher ব্যবহার করে জব রান করতে পারেন।
package com.example.batch;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.batch.core.launch.support.RunIdIncrementer;
import org.springframework.batch.core.JobExecutionException;
import org.springframework.batch.core.JobExecution;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class BatchApplication {
public static void main(String[] args) throws JobExecutionException {
ApplicationContext context = new AnnotationConfigApplicationContext(BatchConfig.class);
JobLauncher jobLauncher = context.getBean(JobLauncher.class);
Job job = context.getBean("userJob", Job.class);
JobExecution execution = jobLauncher.run(job, new JobParameters());
System.out.println("Job Status : " + execution.getStatus());
}
}
এখানে, JobLauncher ব্যবহার করে userJob রান করা হয়েছে। এক্সিকিউশনের স্ট্যাটাস কনসোলে প্রদর্শিত হবে।
Spring Batch এর মাধ্যমে আপনি Step Configuration ব্যবহার করে ব্যাচ প্রসেস তৈরি করতে পারেন। ItemReader, ItemProcessor, এবং ItemWriter এর মাধ্যমে ডেটা রিড, প্রোসেস এবং রাইট করার কাজ করা হয়। এই উদাহরণে, আমরা দেখেছি কিভাবে একটি User ব্যাচ প্রসেস তৈরি করতে হয় এবং প্রতিটি Step এ ডেটা প্রোসেস করা হয়। Spring Batch বড় আকারের ডেটা প্রসেসিংয়ে সহায়ক এবং স্কেলেবল একটি ফ্রেমওয়ার্ক।
Read more