Tasklet এবং Chunk এর মধ্যে পার্থক্য

Tasklet এবং Chunk-based Processing কি?

স্প্রিং ব্যাচে Tasklet এবং Chunk-based Processing হল দুটি প্রধান পদ্ধতি যা ব্যাচ প্রসেসিংয়ের জন্য ব্যবহৃত হয়। প্রতিটি পদ্ধতির নিজস্ব সুবিধা এবং উদ্দেশ্য রয়েছে, এবং এগুলো ডেটা প্রসেসিংয়ের জন্য বিভিন্ন ধরনের পরিস্থিতিতে উপযোগী।

1. Tasklet: এটি একটি সাধারণ পদ্ধতি যেখানে একটি একক কাজ সম্পাদন করা হয়, যেমন একটি ডেটাবেস থেকে ডেটা ডিলিট করা বা ফাইল লেখার কাজ। একক কাজের জন্য খুবই উপযোগী।
2. Chunk-based Processing: এটি ডেটার বৃহৎ সেট নিয়ে কাজ করার জন্য ব্যবহৃত হয়, যেখানে ডেটাকে ছোট ছোট অংশে (chunk) ভাগ করা হয় এবং সেগুলো ব্যাচে প্রসেস করা হয়। এটি বড় ডেটাসেটের জন্য কার্যকরী।

স্প্রিং ব্যাচে এই দুটি পদ্ধতি একত্রে ব্যবহার করা যেতে পারে অথবা পৃথকভাবে প্রয়োগ করা যেতে পারে, ডেটার পরিমাণ এবং কাজের ধরণের উপর নির্ভর করে।

Tasklet

Tasklet হল একটি সাধারণ একক কাজ যা একটি Step হিসেবে কাজ করে। যখন একটি Step কেবল একটি নির্দিষ্ট একক কাজ সম্পাদন করবে, তখন Tasklet ব্যবহার করা হয়। এটি সাধারণত কোনো একক রেকর্ড, ফাইল অপারেশন, বা ডেটাবেসে আপডেট করার জন্য ব্যবহৃত হয়।

Tasklet এর কাঠামো

Tasklet হল একটি ইন্টারফেস, এবং এটি সাধারণত execute() মেথডকে অতিক্রম করে, যেখানে কাজটি বাস্তবায়িত হয়।

import org.springframework.batch.core.Step;
import org.springframework.batch.core.StepContribution;
import org.springframework.batch.core.scope.context.ChunkContext;
import org.springframework.batch.core.step.tasklet.Tasklet;
import org.springframework.stereotype.Component;

@Component
public class MyTasklet implements Tasklet {

    @Override
    public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {
        // Tasklet logic goes here
        System.out.println("Tasklet executed");
        return RepeatStatus.FINISHED; // Indicates the task is completed
    }
}

এখানে RepeatStatus.FINISHED নির্দেশ করে যে কাজটি শেষ হয়েছে। আপনি চাইলে RepeatStatus.CONTINUABLE ব্যবহার করে কাজ পুনরায় চালু করার জন্য নির্দেশ দিতে পারেন।

Tasklet ব্যবহার করে Step তৈরি করা

import org.springframework.batch.core.Step;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.core.job.flow.FlowExecutionStatus;
import org.springframework.batch.core.launch.support.RunIdIncrementer;
import org.springframework.batch.core.Job;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class BatchConfig {

    @Bean
    public Job job(JobBuilderFactory jobBuilderFactory, Step step) {
        return jobBuilderFactory.get("job")
            .incrementer(new RunIdIncrementer())
            .start(step)
            .build();
    }

    @Bean
    public Step step(StepBuilderFactory stepBuilderFactory, MyTasklet tasklet) {
        return stepBuilderFactory.get("step")
            .tasklet(tasklet)
            .build();
    }
}

এখানে, MyTasklet নামক Tasklet ক্লাস ব্যবহার করা হয়েছে এবং সেটি Step হিসাবে কনফিগার করা হয়েছে। এরপর সেটি একটি Job এর অংশ হিসেবে যুক্ত করা হয়েছে।

Chunk-based Processing

Chunk-based Processing একটি অত্যন্ত জনপ্রিয় পদ্ধতি যা ব্যাচ ডেটা প্রসেসিংয়ে ব্যবহৃত হয়। এই পদ্ধতিতে ডেটা ছোট ছোট অংশে (chunks) ভাগ করা হয় এবং প্রতিটি chunk আলাদাভাবে প্রসেস করা হয়। একটি chunk-এ নির্দিষ্ট সংখ্যক আইটেম (যেমন, ১০০, ১০০০ ইত্যাদি) নিয়ে কাজ করা হয়। যখন একটি chunk প্রসেস হয়, তখন সমস্ত আইটেম একসাথে write করা হয়।

Chunk-based Processing এর কাঠামো

Chunk-based Processing ব্যবহারের জন্য আপনাকে ItemReader, ItemProcessor, এবং ItemWriter এর সাহায্য নিতে হবে। এই তিনটি কম্পোনেন্টের মাধ্যমে ডেটা পড়ে, প্রক্রিয়া করে এবং লেখার কাজ করা হয়।

1. ItemReader: এটি ডেটা পড়ার জন্য ব্যবহৃত হয়।
2. ItemProcessor: এটি ডেটাকে প্রসেস করার জন্য ব্যবহৃত হয়।
3. ItemWriter: এটি প্রক্রিয়াজাত ডেটা লেখার জন্য ব্যবহৃত হয়।

উদাহরণ: Chunk-based Processing

import org.springframework.batch.core.Step;
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.Job;
import org.springframework.batch.item.ItemProcessor;
import org.springframework.batch.item.ItemReader;
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 chunkStep) {
        return jobBuilderFactory.get("chunkJob")
            .incrementer(new RunIdIncrementer())
            .start(chunkStep)
            .build();
    }

    @Bean
    public Step chunkStep(StepBuilderFactory stepBuilderFactory, ItemReader<String> reader, 
                          ItemProcessor<String, String> processor, ItemWriter<String> writer) {
        return stepBuilderFactory.get("chunkStep")
            .<String, String>chunk(10)  // Process 10 items at a time
            .reader(reader)
            .processor(processor)
            .writer(writer)
            .build();
    }

    @Bean
    public ItemReader<String> reader() {
        return new MyItemReader(); // Custom reader
    }

    @Bean
    public ItemProcessor<String, String> processor() {
        return new MyItemProcessor(); // Custom processor
    }

    @Bean
    public ItemWriter<String> writer() {
        return new MyItemWriter(); // Custom writer
    }
}

এখানে, একটি Step তৈরি করা হয়েছে যেখানে ১০টি আইটেম একসাথে প্রক্রিয়া করা হচ্ছে (chunk(10) এর মাধ্যমে)। ItemReader, ItemProcessor, এবং ItemWriter এ কাস্টম ক্লাস ব্যবহার করা হয়েছে।

ItemReader, ItemProcessor, এবং ItemWriter উদাহরণ

ItemReader:

import org.springframework.batch.item.ItemReader;

public class MyItemReader implements ItemReader<String> {
    private String[] data = {"Item1", "Item2", "Item3", "Item4", "Item5"};
    private int count = 0;

    @Override
    public String read() throws Exception {
        if (count < data.length) {
            return data[count++];
        } else {
            return null; // End of data
        }
    }
}

ItemProcessor:

import org.springframework.batch.item.ItemProcessor;

public class MyItemProcessor implements ItemProcessor<String, String> {
    @Override
    public String process(String item) throws Exception {
        return item.toUpperCase(); // Converts each item to uppercase
    }
}

ItemWriter:

import org.springframework.batch.item.ItemWriter;

public class MyItemWriter implements ItemWriter<String> {
    @Override
    public void write(List<? extends String> items) throws Exception {
        for (String item : items) {
            System.out.println("Writing item: " + item);
        }
    }
}

এখানে, MyItemReader ডেটা পড়ছে, MyItemProcessor আইটেমগুলোকে uppercase করছে এবং MyItemWriter সেগুলোকে আউটপুটে লিখছে।

Tasklet এবং Chunk-based Processing এর মধ্যে পার্থক্য

সারাংশ

স্প্রিং ব্যাচে Tasklet এবং Chunk-based Processing দুটি ভিন্ন পদ্ধতি, যার মাধ্যমে বিভিন্ন ধরনের ব্যাচ প্রসেসিং কার্যক্রম সম্পাদন করা যায়। Tasklet সাধারণত ছোট এবং একক কাজের জন্য ব্যবহৃত হয়, যখন Chunk-based Processing বড় ডেটাসেটের জন্য এবং ডেটার ব্যাচ প্রসেসিংয়ের জন্য ব্যবহৃত হয়। Chunk-based Processing ডেটাকে ছোট ছোট অংশে ভাগ করে এবং প্রতিটি অংশকে প্রসেস করে, যা বড় আকারের ডেটা প্রসেসিংয়ে কার্যকরী।