Spring Batch Architecture

Spring Batch Architecture কি?

Spring Batch হল একটি শক্তিশালী ফ্রেমওয়ার্ক যা বড় আকারের ব্যাচ প্রসেসিংয়ের জন্য ডিজাইন করা হয়েছে। এটি বিশেষভাবে উপযোগী যেখানে বড় ডেটাসেট নিয়ে কাজ করতে হয়, যেমন ডেটা মাইগ্রেশন, রিপোর্ট তৈরি, ডেটাবেস আপডেট ইত্যাদি। Spring Batch অ্যাপ্লিকেশনগুলো সাধারণত একাধিক স্টেপ এবং জবের সমন্বয়ে তৈরি হয়। Spring Batch এর আর্কিটেকচার মূলত কয়েকটি কোর উপাদান নিয়ে গঠিত, যেগুলো ব্যাচ প্রসেসিংয়ের কার্যক্রম সুষ্ঠুভাবে পরিচালনা করে।

স্প্রিং ব্যাচে কিছু গুরুত্বপূর্ণ কম্পোনেন্ট রয়েছে যা ব্যাচ জবের কার্যক্রম পরিচালনা করে, যেমন Job, Step, ItemReader, ItemProcessor, ItemWriter, JobLauncher, ইত্যাদি।

Spring Batch এর প্রধান উপাদান

১. Job

Job হল স্প্রিং ব্যাচের সবচেয়ে বড় ইউনিট। একটি Job এক বা একাধিক Step নিয়ে গঠিত। একে বলা হয় ব্যাচ প্রসেসের "প্রধান কাঠামো"। একটি Job হল ব্যাচ প্রসেসিংয়ের সমস্ত কার্যক্রমের একটি শৃঙ্খলা বা অর্ডার।

২. Step

Step একটি একক ব্যাচ প্রসেসিং একক। প্রতিটি Step এক বা একাধিক ItemReader, ItemProcessor, এবং ItemWriter এর মাধ্যমে কাজ করে। প্রতিটি Step কিছু নির্দিষ্ট কার্যাবলী (যেমন ডেটা রিড করা, প্রসেসিং করা, অথবা লিখা) সম্পাদন করে। একটি Job অনেকগুলো Step নিয়ে গঠিত হতে পারে, এবং প্রতিটি Step নিজস্বভাবে সফল বা ব্যর্থ হতে পারে।

৩. ItemReader

ItemReader একটি ইনপুট ডেটা সোর্স থেকে ডেটা পড়ার জন্য ব্যবহৃত হয়। এটি সাধারণত ডেটাবেস, ফাইল, অথবা অন্যান্য স্টোরেজ সিস্টেম থেকে ডেটা পড়তে ব্যবহৃত হয়। একে read() মেথডের মাধ্যমে ডেটা পড়ার জন্য ব্যবহার করা হয়।

৪. ItemProcessor

ItemProcessor একটি ইনপুট ডেটাকে প্রসেস করে এবং সেটি আউটপুট ডেটাতে রূপান্তরিত করে। সাধারণত এটি ডেটা ফিল্টার করা, পরিবর্তন করা, অথবা যেকোনো ধরনের কাস্টম প্রসেসিং করার জন্য ব্যবহৃত হয়।

৫. ItemWriter

ItemWriter ব্যাচ প্রসেসিংয়ের শেষে প্রক্রিয়াজাত ডেটা আউটপুটে লেখার জন্য ব্যবহৃত হয়। এটি ডেটাবেস, ফাইল, অথবা অন্য যেকোনো আউটপুট টার্গেটে ডেটা লিখতে ব্যবহৃত হয়।

৬. JobLauncher

JobLauncher একটি অ্যাপ্লিকেশনের ভিতরে Job চালানোর জন্য ব্যবহৃত হয়। এটি একটি Job এর কার্যক্রম শুরু করতে সহায়তা করে।

৭. JobRepository

JobRepository ব্যাচ প্রসেসের চলমান অবস্থা সংরক্ষণ করে। এটি একটি ডেটাবেসে Job এবং Step এর স্ট্যাটাস (যেমন, সফল বা ব্যর্থ) সংরক্ষণ করে যাতে পরবর্তী সময়ে সেগুলোর উপর ভিত্তি করে সিদ্ধান্ত নেওয়া যায়।

৮. JobExecution

JobExecution হল একটি নির্দিষ্ট Job এর এক্সিকিউশনের তথ্য সংরক্ষণকারী অবজেক্ট। এটি JobRepository এর মাধ্যমে ট্র্যাক করা হয় এবং একটি Job এর শুরু, শেষ, বা ব্যর্থতার তথ্য ধারণ করে।

Spring Batch Architecture Diagram

Spring Batch এর আর্কিটেকচার নিচে প্রদত্তভাবে একটি জব এবং স্টেপের সমন্বয়ে কাজ করে:

+----------------------------------+
|          JobLauncher             | 
|    (Triggers the execution)      |   
+-------------------+--------------+     
                    |  
                    v  
            +----------------+       +----------------+
            |   Job          | ----> |   Step 1       |
            |                |       |  (Process data)|
            +----------------+       +----------------+
                    |  
                    v  
            +----------------+       +----------------+
            |   Step 2       | ----> |   Step N       |
            |  (Process data)|       |  (Process data)|
            +----------------+       +----------------+
                    |  
                    v  
           +------------------+
           |  ItemReader      |    (Reads data)
           +------------------+
                    |  
                    v  
           +------------------+
           |  ItemProcessor   |    (Process data)
           +------------------+
                    |  
                    v  
           +------------------+
           |  ItemWriter      |    (Writes processed data)
           +------------------+

Spring Batch Workflow

স্প্রিং ব্যাচের কার্যক্রম সাধারণত নিম্নলিখিত প্রক্রিয়ায় পরিচালিত হয়:

1. Job Execution: একটি JobLauncher দ্বারা Job চালানো হয়।
2. Step Execution: Job এর মধ্যে একাধিক Step থাকে, প্রতিটি Step আলাদাভাবে কার্যকর হয়।
3. ItemReader: Step এর প্রথম অংশ হিসেবে ItemReader ডেটা পড়তে থাকে (ডেটাবেস, ফাইল, ইত্যাদি)।
4. ItemProcessor: এরপর ItemProcessor ডেটার উপর কোনো কাস্টম প্রসেসিং প্রয়োগ করে।
5. ItemWriter: অবশেষে, প্রক্রিয়াজাত ডেটা ItemWriter এর মাধ্যমে আউটপুটে লেখা হয় (ডেটাবেস, ফাইল, ইত্যাদি)।
6. JobRepository: সবসময় JobRepository এর মাধ্যমে পুরো জব এবং স্টেপগুলোর স্ট্যাটাস (সফল/ব্যর্থ) সংরক্ষিত হয়।

Spring Batch এর সুবিধাসমূহ

1. Batch Processing: স্প্রিং ব্যাচ বড় আকারের ডেটা প্রসেসিং কাজগুলো সহজ এবং কার্যকরভাবে পরিচালনা করতে সহায়তা করে।
2. Scalability: এটা বড় আকারের ডেটাসেটের জন্য স্কেলেবল, যেমন লাখো বা কোটি ডেটা প্রক্রিয়াজাত করা।
3. Fault Tolerance: স্প্রিং ব্যাচে স্বয়ংক্রিয়ভাবে সঠিক ত্রুটি পরিচালনার সুবিধা রয়েছে, যেমন ফেইল হয়ে গেলে পুনরায় প্রক্রিয়া চালু করা।
4. Transaction Management: প্রতিটি Step এর জন্য ট্রানজেকশন ম্যানেজমেন্ট নিশ্চিত করা হয়, যা ডেটার একনিষ্ঠতা নিশ্চিত করে।

সারাংশ

স্প্রিং ব্যাচের আর্কিটেকচার খুবই মডুলার এবং ফ্লেক্সিবল, যা ব্যাচ প্রসেসিংয়ের জন্য প্রয়োজনীয় প্রতিটি উপাদান নিয়ে গঠিত। এটি একাধিক Step, ItemReader, ItemProcessor, ItemWriter, এবং JobLauncher এর মাধ্যমে বড় আকারের ডেটা প্রসেসিং কাজগুলো সুষ্ঠুভাবে সম্পাদন করতে সহায়তা করে। JobRepository ব্যবহার করে ব্যাচ জবের অবস্থান এবং স্ট্যাটাস ট্র্যাক করা হয়, যা ব্যাচ প্রসেসিংয়ের স্থিতিশীলতা এবং নির্ভরযোগ্যতা নিশ্চিত করে।

Spring Batch একটি শক্তিশালী ফ্রেমওয়ার্ক যা ব্যাচ প্রসেসিংয়ের জন্য ডিজাইন করা হয়েছে। ব্যাচ প্রসেসিং সাধারণত বড় আকারের ডেটা সেটগুলোর জন্য ব্যবহৃত হয়, যেখানে ডেটা প্রসেসিং এবং বিশ্লেষণ একত্রে সম্পন্ন করা হয়। Spring Batch সহজেই বড় আকারের ডেটা প্রসেসিংয়ের কাজ করতে সাহায্য করে, যেমন ডেটা মাইগ্রেশন, রিপোর্টিং, ব্যাচ কাজের স্বয়ংক্রিয়ীকরণ ইত্যাদি।

Spring Batch এর আর্কিটেকচার এবং এর কম্পোনেন্টগুলো ভালোভাবে জানলে, আপনি ব্যাচ প্রসেসিংয়ের কাজগুলো আরও সহজ ও কার্যকরীভাবে সম্পন্ন করতে পারবেন।

Spring Batch এর আর্কিটেকচার

Spring Batch এর আর্কিটেকচার বেশ কিছু মৌলিক কম্পোনেন্ট দ্বারা গঠিত, যা ডেটা প্রসেসিংয়ের কার্যক্রম পরিচালনা করে। এই কম্পোনেন্টগুলোর মাধ্যমে ডেটা রিড, প্রসেস এবং রাইটিংয়ের কাজগুলো খুবই সহজে পরিচালিত হয়।

১. Job

Job Spring Batch এর একটি মৌলিক অংশ যা পুরো ব্যাচ প্রসেসিং প্রক্রিয়া পরিচালনা করে। এটি বিভিন্ন স্টেপের সংকলন এবং স্টেপগুলোকে একটি নির্দিষ্ট ক্রমে সম্পাদন করে। প্রতিটি Job একটি নির্দিষ্ট কাজ বা প্রসেস যা এক বা একাধিক Step দ্বারা সম্পাদিত হয়। Job এর মাধ্যমে ব্যাচ প্রসেসিংয়ের চলাচল (execution flow) নির্ধারণ করা হয়।

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

২. Step

Step হলো Job এর একটি অংশ যা একটি একক প্রসেসিং ইউনিট হিসেবে কাজ করে। প্রতিটি Step ডেটার রিডিং, প্রসেসিং এবং রাইটিংয়ের জন্য ব্যবহৃত হয়। Step সাধারণত তিনটি প্রধান উপাদান দিয়ে গঠিত:

• ItemReader: ডেটা রিড করার জন্য
• ItemProcessor: রিড করা ডেটার উপর প্রসেসিং করার জন্য
• ItemWriter: প্রসেস করা ডেটা লেখার জন্য

@Bean
public Step exampleStep(StepBuilderFactory stepBuilderFactory, ItemReader<String> reader, ItemProcessor<String, String> processor, ItemWriter<String> writer) {
    return stepBuilderFactory.get("exampleStep")
        .<String, String>chunk(10)
        .reader(reader)
        .processor(processor)
        .writer(writer)
        .build();
}

৩. ItemReader, ItemProcessor, ItemWriter

• ItemReader: ডেটা রিড করার জন্য ব্যবহৃত হয়। এটি সাধারণত ডেটাবেস, ফাইল বা অন্য কোনো ডাটা সোর্স থেকে ডেটা রিড করে।
• ItemProcessor: রিড করা ডেটার উপর কোনো প্রক্রিয়া বা ট্রান্সফরমেশন করার জন্য ব্যবহৃত হয়।
• ItemWriter: প্রসেস করা ডেটাকে কোনো আউটপুট সোর্সে লিখে দেয় (যেমন ডেটাবেস, ফাইল ইত্যাদি)।

এগুলোর মধ্যে একটি Step পরিচালনার জন্য ডেটা রিড, প্রসেস এবং রাইটিং এর কাজগুলো সুনির্দিষ্টভাবে ভাগ করা হয়।

Spring Batch এর কম্পোনেন্টগুলো

Spring Batch এর প্রধান কম্পোনেন্টগুলো হলো:

১. JobLauncher

JobLauncher হলো Spring Batch এর একটি ইন্টারফেস যা Job চালানোর কাজ করে। এটি Job এর execution শুরু করার জন্য ব্যবহৃত হয়। JobLauncher ব্যবহার করে আমরা একটি Job চালাতে পারি।

@Autowired
private JobLauncher jobLauncher;

@Autowired
private Job job;

public void runJob() throws JobExecutionException {
    jobLauncher.run(job, new JobParameters());
}

২. JobRepository

JobRepository হলো Spring Batch এর একটি কম্পোনেন্ট যা Job এর execution এর স্টেট (state) ট্র্যাক করে। এটি Job এর execution history রেকর্ড রাখে, যেমন সফল বা ব্যর্থ হওয়ার তথ্য। JobRepository সাধারণত ডেটাবেসে সংরক্ষিত হয়।

৩. JobExecution

JobExecution হলো একটি অবজেক্ট যা একটি Job এর execution সম্পর্কিত তথ্য ধারণ করে। এতে Job এর স্ট্যাটাস, ফেইলিউর এবং সাকসেস স্ট্যাটাস সম্পর্কিত তথ্য থাকে। এটি JobRepository তে সংরক্ষিত হয়।

৪. JobParameters

JobParameters একটি অবজেক্ট যা Job এর execution এর জন্য প্রয়োজনীয় প্যারামিটার ধারণ করে। এই প্যারামিটারগুলি Job চলাকালে প্রয়োজনীয় কনফিগারেশন এবং ডেটা প্রদান করে।

৫. ItemReader, ItemProcessor, ItemWriter

এগুলি ব্যাচ প্রসেসিং এর মূল উপাদান। ItemReader ডেটা রিড করে, ItemProcessor ডেটা প্রসেস করে এবং ItemWriter প্রসেস করা ডেটা আউটপুটে লেখে। এদের বিভিন্ন কনফিগারেশনের মাধ্যমে আপনি আপনার প্রোজেক্টের নির্দিষ্ট ডেটা প্রসেসিং প্রয়োজন মেটাতে পারেন।

৬. SkipPolicy এবং RetryPolicy

• SkipPolicy: এটি ব্যাচ প্রসেসিং চলাকালীন ত্রুটি হলে সেই ত্রুটির উপর ভিত্তি করে রেকর্ড স্কিপ করার জন্য ব্যবহৃত হয়।
• RetryPolicy: এটি কোনো ত্রুটি ঘটলে পুনরায় একটি নির্দিষ্ট পরিমাণ চেষ্টা করার জন্য ব্যবহৃত হয়।

৭. Tasklet

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

@Bean
public Tasklet tasklet() {
    return (contribution, chunkContext) -> {
        System.out.println("Tasklet is executed");
        return RepeatStatus.FINISHED;
    };
}

Spring Batch এর প্রক্রিয়া (Flow)

Spring Batch একটি স্টেপ-বাই-স্টেপ প্রক্রিয়া অনুসরণ করে, যেখানে প্রতিটি Job একাধিক Step এর মাধ্যমে সম্পাদিত হয়। প্রতিটি Step মূলত তিনটি প্রধান কাজের সাথে সম্পর্কিত:

1. ItemReader থেকে ডেটা রিড করা।
2. ItemProcessor এর মাধ্যমে ডেটা প্রসেসিং করা।
3. ItemWriter তে প্রসেস করা ডেটা লিখে দেওয়া।

এগুলি পরস্পরের সাথে একত্রে কাজ করে একটি নির্দিষ্ট ব্যাচ প্রসেসিং কাজ সম্পাদন করতে।

সারাংশ

Spring Batch এর আর্কিটেকচার এবং কম্পোনেন্টগুলো একটি শক্তিশালী ব্যাচ প্রসেসিং ফ্রেমওয়ার্ক তৈরিতে সহায়ক। Job এবং Step এর মাধ্যমে আপনি ব্যাচ কাজের কার্যক্রম কনফিগার করতে পারেন এবং ItemReader, ItemProcessor, এবং ItemWriter এর মাধ্যমে ডেটা রিড, প্রসেস এবং রাইট করতে পারেন। এর মাধ্যমে বড় আকারের ডেটা প্রসেসিং কাজগুলো সহজ এবং সুসংহতভাবে পরিচালিত হয়, যা ডেটাবেস মাইগ্রেশন, ব্যাচ রিপোর্টিং এবং অন্যান্য কার্যক্রমে কার্যকরী ভূমিকা রাখে।

Spring Batch একটি জনপ্রিয় ফ্রেমওয়ার্ক যা বড় পরিমাণ ডেটা প্রসেসিংয়ের জন্য তৈরি করা হয়েছে, যেমন ডেটাবেস থেকে ডেটা পাঠানো বা বড় আকারের ফাইল প্রসেস করা। এটি পুনরাবৃত্তি-ভিত্তিক ডেটা প্রসেসিং কাজে ব্যবহৃত হয় এবং একটি উচ্চক্ষমতাসম্পন্ন ও দক্ষ সমাধান প্রদান করে। Spring Batch এর মধ্যে প্রধান চারটি ধারণা হল Job, Step, Tasklet, এবং Chunk ভিত্তিক প্রসেসিং, যা একে অত্যন্ত শক্তিশালী এবং কাস্টমাইজযোগ্য করে তোলে।

এই ধারণাগুলির প্রতিটি Spring Batch এ ডেটা প্রসেসিংয়ের একটি গুরুত্বপূর্ণ উপাদান, যা মিলিতভাবে কাজ করে একটি ব্যাচ প্রসেসিং ফ্লো তৈরি করতে।

Job

Job হল Spring Batch এর সবচেয়ে বড় কাঠামো। এটি সমস্ত প্রসেসিং স্টেপের একটি সেট যা একে একে সম্পন্ন হয়। একটি Job এক বা একাধিক Step ধারণ করতে পারে, এবং প্রতিটি Step এর মধ্যে নির্দিষ্ট কাজ সম্পাদিত হয়। একটি Job শুরু করার জন্য সাধারণত কিছু ইনপুট প্রোডাক্ট থাকে এবং শেষে একটি আউটপুট প্রোডাক্ট তৈরি হয়।

Job এর একটি ক্লাস তৈরি করতে সাধারণত @EnableBatchProcessing অ্যানোটেশন এবং JobBuilderFactory এবং StepBuilderFactory ব্যবহার করা হয়।

উদাহরণ

@Configuration
@EnableBatchProcessing
public class BatchConfig {

    @Autowired
    private JobBuilderFactory jobBuilderFactory;

    @Autowired
    private StepBuilderFactory stepBuilderFactory;

    @Bean
    public Job myJob() {
        return jobBuilderFactory.get("myJob")
                .start(step1())
                .next(step2())
                .build();
    }

    @Bean
    public Step step1() {
        return stepBuilderFactory.get("step1")
                .tasklet(new MyTasklet())
                .build();
    }

    @Bean
    public Step step2() {
        return stepBuilderFactory.get("step2")
                .tasklet(new AnotherTasklet())
                .build();
    }
}

এখানে, একটি Job তৈরি করা হয়েছে যা দুটি Step (step1 এবং step2) নিয়ে গঠিত।

Step

Step হল একটি একক প্রসেসিং ইউনিট যা একটি নির্দিষ্ট কাজ সম্পাদন করে। একটি Job এক বা একাধিক Step ধারণ করতে পারে, এবং প্রতিটি Step নির্দিষ্ট একটি কাজ (যেমন, ডেটাবেস থেকে ডেটা রিড করা, ফাইল লিখা, বা ডেটা প্রসেস করা) সম্পন্ন করে।

Step দুটি মূল ভাবে হতে পারে:

1. Tasklet Step: একটি একক কাজ সম্পাদন করার জন্য ব্যবহৃত হয়।
2. Chunk-oriented Step: বৃহৎ পরিমাণ ডেটার জন্য ব্যবহৃত হয় যেখানে ডেটা ছোট ছোট অংশে প্রসেস করা হয়।

Tasklet

Tasklet একটি ছোট এবং একক কাজ (এটি একটি Tasklet ইন্টারফেস বাস্তবায়িত ক্লাস) সম্পাদন করার জন্য ব্যবহৃত হয়। এটি সাধারণত ছোট এবং একক কাজের জন্য উপযুক্ত, যেমন ফাইল সিস্টেমে ফাইল কপি করা বা একটি ছোট স্ক্রিপ্ট চালানো। Tasklet সাধারণত Step এর ভিতরে ব্যবহৃত হয়।

উদাহরণ

public class MyTasklet implements Tasklet {
    @Override
    public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {
        // একক কাজ সম্পাদন করা
        System.out.println("Executing tasklet");
        return RepeatStatus.FINISHED;  // কাজ শেষ হয়েছে
    }
}

এখানে, Tasklet ক্লাস একটি কাজ সম্পাদন করবে এবং RepeatStatus.FINISHED দিয়ে জানিয়ে দেবে যে কাজটি সম্পন্ন হয়েছে।

Chunk ভিত্তিক Processing

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

প্রথমে ডেটার একটি chunk পড়া হয়, তারপর সেটি প্রসেস করা হয় এবং অবশেষে ডেটাবেস বা ফাইলের মধ্যে সেভ করা হয়। এই পদ্ধতিতে একাধিক রিড, প্রসেস এবং রাইট স্টেপ হতে পারে, যা ডেটার প্রতিটি অংশকে আলাদাভাবে প্রসেস করে।

উদাহরণ

@Bean
public Step chunkStep() {
    return stepBuilderFactory.get("chunkStep")
            .<InputType, OutputType>chunk(10)  // প্রতি 10টি রেকর্ডে প্রসেস
            .reader(myReader())  // ডেটা রিডার
            .processor(myProcessor())  // ডেটা প্রসেসর
            .writer(myWriter())  // ডেটা রাইটার
            .build();
}

এখানে, প্রতি 10টি রেকর্ডে একটি chunk প্রসেস করা হচ্ছে। এই পদ্ধতি খুবই উপযোগী যখন আপনাকে বৃহৎ পরিমাণ ডেটা প্রসেস করতে হয় এবং পুরো ডেটাসেট একসাথে প্রসেস করলে মেমরি সমস্যা হতে পারে।

সারাংশ

Spring Batch এর মূল ধারণাগুলোর মধ্যে Job, Step, Tasklet, এবং Chunk ভিত্তিক Processing অত্যন্ত গুরুত্বপূর্ণ।

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

এই ধারণাগুলির মাধ্যমে Spring Batch বড় পরিমাণ ডেটা কার্যকরীভাবে এবং দক্ষতার সাথে প্রসেস করার একটি শক্তিশালী কাঠামো প্রদান করে।

স্প্রিং ব্যাচ (Spring Batch) একটি শক্তিশালী ফ্রেমওয়ার্ক যা বড় আকারের ডেটা প্রসেসিংয়ের জন্য ব্যবহৃত হয়। এটি কাজের ফ্লো পরিচালনা, ডেটা প্রসেসিং, ব্যাচ জব এক্সিকিউশন এবং ট্রানজেকশন ম্যানেজমেন্টের জন্য বিভিন্ন উপাদান প্রদান করে। এই উপাদানগুলোর মধ্যে JobRepository, JobLauncher, এবং JobExecution অত্যন্ত গুরুত্বপূর্ণ ভূমিকা পালন করে।

JobRepository

JobRepository একটি গুরুত্বপূর্ণ কম্পোনেন্ট যা ব্যাচ জবের স্টেট এবং তথ্য সংরক্ষণ করে। এটি ব্যাচ জবের জন্য একটি ডেটাবেস স্টোর হিসেবে কাজ করে এবং ব্যাচ প্রসেসিংয়ের বিভিন্ন ইনফরমেশন যেমন জবের স্টেট, স্টেপের স্টেট, এবং জব এক্সিকিউশনের ইতিহাস সংরক্ষণ করে।

JobRepository এর ভূমিকা:

1. স্টোরেজ: এটি ব্যাচ জব সম্পর্কিত সমস্ত ডেটা যেমন জব স্টেট, স্টেপ স্টেট, পারামিটার, এবং অন্যান্য তথ্য স্টোর করে রাখে।
2. স্টেট ট্র্যাকিং: এটি ব্যাচ জবের প্রগ্রেস, সফলতা অথবা ব্যর্থতা ট্র্যাক করে। উদাহরণস্বরূপ, একটি ব্যাচ জব শুরু হলে সেটি JobExecution এ কনফিগার করা হয় এবং পরবর্তীতে এর অবস্থা আপডেট করা হয়।
3. রেসিলিয়েন্স: ব্যাচ জব পুনরায় চালানোর জন্য অতীতের তথ্যগুলির ওপর ভিত্তি করে পুনরায় শুরু করতে সাহায্য করে।

JobRepository কনফিগারেশন:

@Bean
public JobRepository jobRepository(DataSource dataSource, PlatformTransactionManager transactionManager) throws Exception {
    JobRepositoryFactoryBean factory = new JobRepositoryFactoryBean();
    factory.setDataSource(dataSource);
    factory.setTransactionManager(transactionManager);
    factory.setDatabaseType("MYSQL");
    return factory.getObject();
}

JobLauncher

JobLauncher একটি ইন্টারফেস যা স্প্রিং ব্যাচ জব এক্সিকিউট করতে ব্যবহার করা হয়। এটি ব্যাচ জব চালানোর জন্য ব্যবহৃত হয় এবং JobExecution অবজেক্ট রিটার্ন করে, যা ব্যাচ জবের এক্সিকিউশন স্টেটাস ধারণ করে।

JobLauncher এর ভূমিকা:

1. জব এক্সিকিউশন শুরু করা: JobLauncher এর মাধ্যমে ব্যাচ জব শুরু হয় এবং এটি JobExecution অবজেক্টের মাধ্যমে এক্সিকিউশনের অবস্থা মনিটর করে।
2. এন্ট্রি পয়েন্ট: এটি স্প্রিং ব্যাচের জন্য জব এক্সিকিউশনের মূল এন্ট্রি পয়েন্ট হিসেবে কাজ করে এবং জবের শুরু থেকে শেষ পর্যন্ত টার্গেট স্টেপে ডেটা প্রসেসিং পরিচালনা করে।

JobLauncher কনফিগারেশন:

@Bean
public JobLauncher jobLauncher(JobRepository jobRepository) {
    SimpleJobLauncher jobLauncher = new SimpleJobLauncher();
    jobLauncher.setJobRepository(jobRepository);
    return jobLauncher;
}

JobLauncher এর ব্যবহার:

@Autowired
private JobLauncher jobLauncher;

@Autowired
private Job job;

public void runBatchJob() throws Exception {
    JobExecution jobExecution = jobLauncher.run(job, new JobParameters());
    System.out.println("Job Status: " + jobExecution.getStatus());
}

এখানে, jobLauncher.run(job, new JobParameters()) ব্যবহার করে ব্যাচ জব চালানো হচ্ছে এবং এর রিটার্ন হিসেবে JobExecution পাওয়া যাচ্ছে।

JobExecution

JobExecution একটি ক্লাস যা ব্যাচ জবের এক্সিকিউশন স্টেটাস ধারণ করে। এটি ব্যাচ জবের মধ্যে ঘটে যাওয়া সমস্ত তথ্য সংরক্ষণ করে, যেমন জবের স্টেট, শুরু এবং শেষের সময়, ব্যাচ জবের পারামিটার, এবং ব্যতিক্রম (exception) ইত্যাদি।

JobExecution এর ভূমিকা:

1. জব এক্সিকিউশনের অবস্থা: এটি ব্যাচ জবের চলমান অবস্থা ট্র্যাক করে, যেমন "STARTED", "COMPLETED", "FAILED" ইত্যাদি।
2. পারামিটার সংরক্ষণ: এটি জব এক্সিকিউশনের সময় যে সমস্ত পারামিটার ব্যবহার হয় সেগুলি সংরক্ষণ করে রাখে।
3. অপারেশন ফলাফল: এটি এক্সিকিউশনের সময় যে কোনো ব্যতিক্রম বা ত্রুটি ঘটলে তা ট্র্যাক এবং রেজিস্টার করে।

JobExecution এর ব্যবহার:

@Autowired
private JobLauncher jobLauncher;

@Autowired
private Job job;

public void runJob() throws Exception {
    JobParameters jobParameters = new JobParametersBuilder()
                                        .addString("jobParameter", "value")
                                        .toJobParameters();
    JobExecution jobExecution = jobLauncher.run(job, jobParameters);
    
    System.out.println("Job Execution Status: " + jobExecution.getStatus());
    System.out.println("Job Execution ID: " + jobExecution.getId());
}

এখানে, JobExecution রিটার্ন হওয়ার পর আমরা এক্সিকিউশন স্টেটাস এবং অন্যান্য তথ্য দেখতে পারি।

JobRepository, JobLauncher, এবং JobExecution এর সম্পর্ক

1. JobRepository: এটি ব্যাচ জবের মেটাডেটা এবং স্টেট স্টোর করে রাখে। যখন একটি জব রান হয়, JobExecution অবজেক্টটি JobRepository তে সংরক্ষিত হয়।
2. JobLauncher: এটি একটি নির্দিষ্ট জব শুরু করতে ব্যবহৃত হয় এবং JobExecution তৈরি করে।
3. JobExecution: এটি ব্যাচ জবের রানিং স্টেটাস এবং অন্যান্য ইনফরমেশন ধারণ করে এবং JobRepository তে সংরক্ষণ করা হয়।

স্প্রিং ব্যাচের এই তিনটি উপাদান একে অপরের সাথে কাজ করে ব্যাচ প্রসেসিংয়ের স্টেট ট্র্যাক করতে, ব্যাচ জব চালাতে এবং সফল বা ব্যর্থ এক্সিকিউশন সম্পর্কে ইনফরমেশন প্রদান করতে।

উপসংহার

স্প্রিং ব্যাচ (Spring Batch) এ JobRepository, JobLauncher, এবং JobExecution একটি ব্যাচ জবের সফল ব্যবস্থাপনা এবং এক্সিকিউশন নিশ্চিত করতে গুরুত্বপূর্ণ ভূমিকা পালন করে। JobRepository ব্যাচ জবের তথ্য সংরক্ষণ করে, JobLauncher ব্যাচ জব শুরু করে, এবং JobExecution এক্সিকিউশন ফলাফল এবং স্টেটাস সংরক্ষণ করে। এভাবে, স্প্রিং ব্যাচ অ্যাপ্লিকেশনগুলিতে ব্যাচ প্রক্রিয়াগুলির কার্যকরী ব্যবস্থাপনা এবং ট্র্যাকিং নিশ্চিত করা হয়।

স্প্রিং ব্যাচ (Spring Batch) একটি ফ্রেমওয়ার্ক যা বড় পরিমাণে ডেটা প্রোসেসিংয়ের জন্য ব্যবহৃত হয়। এটি বিশেষভাবে ব্যাচ প্রসেসিং, যেমন ডেটা মাইগ্রেশন, ডেটা ট্রান্সফরমেশন এবং ডেটা লোডিং, ইত্যাদির জন্য উপযুক্ত। স্প্রিং ব্যাচ একটি মডুলার আর্কিটেকচার ব্যবহার করে, যা অনেক কমপোনেন্ট দিয়ে গঠিত এবং এগুলো একে অপরের সাথে ইন্টিগ্রেটেডভাবে কাজ করে। স্প্রিং ব্যাচের আর্কিটেকচার মূলত তিনটি প্রধান অংশে বিভক্ত: Job, Step, এবং ItemProcessor।

এখানে আমরা স্প্রিং ব্যাচের আর্কিটেকচার এবং এর গুরুত্বপূর্ণ কম্পোনেন্টগুলো উদাহরণের মাধ্যমে বিশ্লেষণ করবো।

স্প্রিং ব্যাচ আর্কিটেকচারের প্রধান কম্পোনেন্টগুলো

স্প্রিং ব্যাচের আর্কিটেকচারে মূলত নিচের কম্পোনেন্টগুলো থাকে:

1. Job: এটি একটি ব্যাচ প্রসেসিং কাজের ইউনিট। একটি Job একটি বা একাধিক Step নিয়ে গঠিত, এবং প্রতিটি Step একটি নির্দিষ্ট কাজ সম্পন্ন করে।
2. Step: Step হলো ব্যাচ প্রসেসিংয়ের একক কার্যক্রম। এটি বিভিন্ন ধাপে বিভক্ত হতে পারে, যেমন রিডিং (reading), প্রসেসিং (processing), এবং রাইটিং (writing)।
3. ItemReader: এটি ডেটা রিডিংয়ের জন্য ব্যবহৃত হয়, অর্থাৎ একটি সিঙ্গেল আইটেম বা ডেটা সোর্স থেকে এক্সট্র্যাক্ট করা হয়।
4. ItemProcessor: এটি ডেটার উপর কোনো প্রক্রিয়া বা ট্রান্সফরমেশন সম্পন্ন করে।
5. ItemWriter: এটি প্রক্রিয়াকৃত ডেটাকে কোথাও (যেমন ডেটাবেস, ফাইল) লিখে রাখে।
6. JobLauncher: এটি একটি Job শুরু করার জন্য ব্যবহৃত হয়।

স্প্রিং ব্যাচের কাজের প্রক্রিয়া সাধারণত নিচের রূপে কাজ করে:

1. Job তৈরি করা হয়, যা এক বা একাধিক Step নিয়ে গঠিত।
2. প্রতিটি Step একটি নির্দিষ্ট কাজ সম্পন্ন করে, যেমন ডেটা রিড, প্রসেস এবং রাইট।
3. ItemReader ডেটা রিডিং করে, ItemProcessor ডেটা প্রসেস করে এবং ItemWriter ডেটাকে আউটপুট ডেস্টিনেশনে (যেমন ডেটাবেস, ফাইল, ইত্যাদি) লেখে।

স্প্রিং ব্যাচ আর্কিটেকচারের উদাহরণ

এখন আমরা একটি উদাহরণ দেখব যেখানে আমরা একটি ব্যাচ জব তৈরি করবো, যেটি একটি CSV ফাইল থেকে ডেটা পড়বে, ডেটাকে প্রসেস করবে এবং তা ডেটাবেসে লেখবে।

Step 1: স্প্রিং ব্যাচ কনফিগারেশন

প্রথমে আমাদের @EnableBatchProcessing অ্যানোটেশন দিয়ে স্প্রিং ব্যাচ কনফিগারেশন সক্ষম করতে হবে।

@Configuration
@EnableBatchProcessing
public class BatchConfig {

    @Autowired
    private JobBuilderFactory jobBuilderFactory;

    @Autowired
    private StepBuilderFactory stepBuilderFactory;

    @Autowired
    private DataSource dataSource;

    @Bean
    public ItemReader<User> reader() {
        FlatFileItemReader<User> reader = new FlatFileItemReader<>();
        reader.setResource(new ClassPathResource("users.csv"));
        reader.setLineMapper(new DefaultLineMapper<User>() {{
            setLineTokenizer(new DelimitedLineTokenizer() {{
                setNames("id", "name", "email");
            }});
            setFieldSetMapper(new BeanWrapperFieldSetMapper<>() {{
                setTargetType(User.class);
            }});
        }});
        return reader;
    }

    @Bean
    public ItemProcessor<User, User> processor() {
        return new UserItemProcessor();
    }

    @Bean
    public ItemWriter<User> writer() {
        JdbcBatchItemWriter<User> writer = new JdbcBatchItemWriter<>();
        writer.setItemSqlParameterSourceProvider(new BeanPropertyItemSqlParameterSourceProvider<>());
        writer.setSql("INSERT INTO users (id, name, email) VALUES (:id, :name, :email)");
        writer.setDataSource(dataSource);
        return writer;
    }

    @Bean
    public Step step1() {
        return stepBuilderFactory.get("step1")
                .<User, User> chunk(10)
                .reader(reader())
                .processor(processor())
                .writer(writer())
                .build();
    }

    @Bean
    public Job importUserJob() {
        return jobBuilderFactory.get("importUserJob")
                .start(step1())
                .build();
    }

    @Bean
    public JobLauncher jobLauncher(JobRegistry jobRegistry) {
        return new SimpleJobLauncher();
    }
}

Step 2: ItemProcessor (ডেটা প্রসেসিং)

এখানে একটি UserItemProcessor ক্লাস তৈরি করা হয়েছে, যা ডেটা প্রসেস করে।

public class UserItemProcessor implements ItemProcessor<User, User> {

    @Override
    public User process(User user) throws Exception {
        user.setName(user.getName().toUpperCase()); // Name কে uppercase এ পরিবর্তন করা হচ্ছে
        return user;
    }
}

Step 3: ডেটাবেস মডেল (User)

এখন, আমাদের একটি User ক্লাস তৈরি করতে হবে, যেটি ডেটাবেসে সেভ করা হবে।

@Entity
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    private String email;

    // getters and setters
}

স্প্রিং ব্যাচের কাজের প্রক্রিয়া

1. ItemReader: প্রথমে ItemReader সিস্টেম CSV ফাইল থেকে ডেটা রিড করে। এখানে, FlatFileItemReader ব্যবহার করা হচ্ছে, যা ফাইল থেকে লাইন পড়বে এবং প্রতিটি লাইনের ডেটাকে User অবজেক্টে ম্যাপ করবে।
2. ItemProcessor: ItemProcessor ডেটার উপর কোনো প্রক্রিয়া বা ট্রান্সফরমেশন করে। আমাদের উদাহরণে, এটি User অবজেক্টের নামকে uppercase-এ রূপান্তর করে।
3. ItemWriter: ItemWriter প্রসেস করা ডেটাকে একটি ডেটাবেসে লেখে। এখানে, JdbcBatchItemWriter ব্যবহার করা হয়েছে, যা ডেটাকে ডেটাবেসে ইনসার্ট করবে।
4. Job and Step: একটি Job তৈরি করা হয়, যার মধ্যে একটি বা একাধিক Step থাকে। এখানে, আমরা একটি step1 তৈরি করেছি, যা ডেটা রিড, প্রসেস এবং রাইটিংয়ের জন্য দায়ী।
5. JobLauncher: JobLauncher ব্যবহার করে আমরা Job শুরু করি। এটি ব্যাচ প্রসেসিংয়ের কার্যক্রম শুরু করবে।

উপসংহার

স্প্রিং ব্যাচ (Spring Batch) একটি শক্তিশালী ফ্রেমওয়ার্ক, যা ব্যাচ প্রক্রিয়াকরণ, যেমন ডেটা ট্রান্সফরমেশন, লোডিং, এবং মাইগ্রেশন কাজগুলোকে সহজ করে তোলে। এর আর্কিটেকচার প্রধানত Job, Step, ItemReader, ItemProcessor, এবং ItemWriter এর চারপাশে গড়ে ওঠে। স্প্রিং ব্যাচের সাহায্যে আপনি বড় পরিমাণের ডেটা প্রক্রিয়া, ভ্যালিডেশন এবং রাইটিং কাজগুলো দক্ষভাবে পরিচালনা করতে পারবেন।