Spring Batch Environment সেটআপ

Spring Batch একটি ফ্রেমওয়ার্ক যা ব্যাচ প্রক্রিয়াগুলি (batch processing) পরিচালনা করতে ব্যবহৃত হয়, যেমন বৃহত ডেটাসেট প্রক্রিয়া, ডাটা ইনপুট/আউটপুট, ট্রানজেকশন ম্যানেজমেন্ট, এবং একাধিক ধাপে কাজ পরিচালনা। এটি মূলত বড় ডেটাসেট বা ব্যাচ প্রক্রিয়াগুলোর জন্য ডেভেলপ করা হয়েছে। Spring Batch ব্যবহার করে সহজে ব্যাচ জব তৈরি, কনফিগারেশন, এবং ম্যানেজমেন্ট করা যায়।

Spring Batch Environment সেটআপ করতে কিছু প্রাথমিক ধাপ অনুসরণ করতে হয়, যেমন ডিপেনডেন্সি কনফিগারেশন, ডাটাবেস সেটআপ, এবং ব্যাচ জব কনফিগারেশন তৈরি করা।

Spring Batch Environment সেটআপের জন্য পদক্ষেপ

1. Maven ডিপেনডেন্সি যোগ করা

Spring Batch ব্যবহার করার জন্য আপনাকে Spring Batch এর প্রয়োজনীয় ডিপেনডেন্সি আপনার pom.xml ফাইলে যোগ করতে হবে।

<dependency>
    <groupId>org.springframework.batch</groupId>
    <artifactId>spring-batch-core</artifactId>
    <version>5.0.0</version>  <!-- সর্বশেষ সংস্করণ ব্যবহার করুন -->
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-batch</artifactId>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

এখানে, spring-batch-core ডিপেনডেন্সি Spring Batch এর মূল ফিচার প্রদান করে এবং spring-boot-starter-batch স্টার্টার ব্যবহার করা হয় Spring Boot এর মধ্যে Spring Batch কাজ করার জন্য। H2 ডাটাবেস ডেভেলপমেন্টের জন্য ব্যবহার করা হয়েছে, তবে প্রোডাকশনে অন্য কোনো ডাটাবেস যেমন MySQL বা PostgreSQL ব্যবহার করতে পারেন।

2. application.properties কনফিগারেশন

Spring Batch এর জন্য ডাটাবেস কনফিগারেশন সেট করা প্রয়োজন। application.properties ফাইলে ডাটাবেসের কনফিগারেশন করতে হবে যাতে Spring Batch সঠিকভাবে ডাটাবেসে ব্যাচ জব সম্পর্কিত ডাটা স্টোর করতে পারে।

spring.datasource.url=jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect

# Spring Batch configuration
spring.batch.job.enabled=true
spring.batch.initialize-schema=always  # স্কিমা স্বয়ংক্রিয়ভাবে তৈরি করা হবে

এখানে spring.batch.initialize-schema=always দিয়ে Spring Batch এর জন্য প্রয়োজনীয় টেবিলগুলো স্বয়ংক্রিয়ভাবে তৈরি করার নির্দেশ দেওয়া হয়েছে।

3. Batch Configuration Class তৈরি করা

Spring Batch এর কাজ পরিচালনা করতে একটি কনফিগারেশন ক্লাস তৈরি করা হয়, যেখানে ব্যাচ জব, স্টেপ, রিডার, প্রসেসর, এবং লেখক কনফিগার করা হয়। নিচে একটি উদাহরণ দেখানো হলো।

package com.example.demo;

import org.springframework.batch.core.Job;
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.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)
                .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)
                .reader(reader)
                .processor(processor)
                .writer(writer)
                .build();
    }

    // ItemReader, ItemProcessor, and ItemWriter Beans will be configured below
}

এখানে, একটি Job এবং একটি Step কনফিগার করা হয়েছে। প্রতিটি Step এ একটি ItemReader, ItemProcessor, এবং ItemWriter থাকে যা ডাটা রিড, প্রসেস এবং লেখার কাজ করে।

4. ItemReader, ItemProcessor, and ItemWriter তৈরি করা

Spring Batch এ ডাটা রিড, প্রসেস এবং লেখার জন্য সাধারণত তিনটি উপাদান ব্যবহৃত হয়: ItemReader, ItemProcessor, এবং ItemWriter। এগুলোর কনফিগারেশন নিম্নরূপ হতে পারে:

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

@Component
public class SimpleReader implements ItemReader<String> {
    @Override
    public String read() throws Exception {
        return "Spring Batch Example";
    }
}

@Component
public class SimpleProcessor implements ItemProcessor<String, String> {
    @Override
    public String process(String item) throws Exception {
        return item.toUpperCase();  // Uppercase the input
    }
}

@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 একটি String রিডার, SimpleProcessor String কে uppercase করে এবং SimpleWriter ডাটাকে কনসোলে লিখে।

5. JobLauncher দিয়ে ব্যাচ জব রান করা

Spring Batch এ ব্যাচ জব চালানোর জন্য JobLauncher ব্যবহার করা হয়। নিচে একটি উদাহরণ দেয়া হলো, যেটি Spring Boot অ্যাপ্লিকেশন শুরু হলে ব্যাচ জব রান করবে।

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 Environment সেটআপের মাধ্যমে আপনি একটি শক্তিশালী ব্যাচ প্রক্রিয়া তৈরি করতে পারবেন। Spring Batch এর মাধ্যমে ডাটা প্রক্রিয়া, ট্রানজেকশন ম্যানেজমেন্ট, এবং ব্যাচ জব তৈরি ও কনফিগারেশন খুবই সহজ। Spring Batch ডিপেনডেন্সি যোগ, ডাটাবেস কনফিগারেশন, এবং কাস্টম ItemReader, ItemProcessor, এবং ItemWriter তৈরি করার মাধ্যমে কার্যকরভাবে ব্যাচ প্রক্রিয়া পরিচালনা করা যায়।

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

Maven দিয়ে Spring Batch প্রজেক্ট তৈরি করা

1. Spring Initializr ব্যবহার করে Spring Batch প্রজেক্ট তৈরি করা

Spring Initializr ব্যবহার করে Spring Batch প্রজেক্ট তৈরি করা সহজ। Maven ভিত্তিক প্রজেক্ট তৈরি করতে নিচের স্টেপগুলো অনুসরণ করুন:

1. Spring Initializr ওয়েবসাইটে যান: Spring Initializr
2. Project হিসেবে "Maven Project" নির্বাচন করুন।
3. Language হিসেবে "Java" নির্বাচন করুন।
4. Spring Boot Version নির্বাচন করুন (যেমন: 3.0.0 বা আপনার পছন্দের লেটেস্ট ভার্সন)।
5. Dependencies হিসেবে "Spring Batch" এবং "Spring Web" নির্বাচন করুন (আপনার প্রয়োজন অনুযায়ী অন্যান্য ডিপেনডেন্সিও নির্বাচন করতে পারেন)।
6. "Generate" বাটনে ক্লিক করুন এবং ডাউনলোড করা ZIP ফাইলটি এক্সট্র্যাক্ট করুন।

2. Maven ডিপেনডেন্সি কনফিগারেশন

Spring Batch-এ প্রয়োজনীয় ডিপেনডেন্সি pom.xml ফাইলে সংযুক্ত করতে হবে। নিচে একটি সাধারণ pom.xml ফাইলের উদাহরণ দেওয়া হলো:

<dependencies>
    <!-- Spring Boot Starter Web for web functionalities -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- Spring Batch for batch processing -->
    <dependency>
        <groupId>org.springframework.batch</groupId>
        <artifactId>spring-batch-core</artifactId>
    </dependency>

    <!-- Spring Boot Starter Batch for batch support -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-batch</artifactId>
    </dependency>

    <!-- H2 Database for in-memory database (optional, for testing purposes) -->
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>

    <!-- Spring Boot Starter Test for testing -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

এটি Spring Batch-এ ব্যাচ প্রসেসিং এবং ইন-মেমরি ডেটাবেস (যেমন H2) ব্যবহারের জন্য প্রয়োজনীয় ডিপেনডেন্সি যুক্ত করে।

3. Spring Batch কনফিগারেশন

Spring Batch কনফিগারেশন এবং ব্যাচ প্রসেসিং ম্যানেজ করার জন্য আপনি @EnableBatchProcessing অ্যনোটেশন ব্যবহার করবেন। নিচে একটি সাধারণ Spring Batch কনফিগারেশন উদাহরণ দেওয়া হলো:

@Configuration
@EnableBatchProcessing
public class BatchConfig {

    @Autowired
    private JobBuilderFactory jobBuilderFactory;

    @Autowired
    private StepBuilderFactory stepBuilderFactory;

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

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

এখানে একটি ব্যাচ জব কনফিগার করা হয়েছে, যেখানে একটি স্টেপ ডিফাইন করা হয়েছে। এই কনফিগারেশন আপনার ব্যাচ প্রসেসিং শুরু করার জন্য ব্যবহার করা যাবে।

Gradle দিয়ে Spring Batch প্রজেক্ট তৈরি করা

1. Spring Initializr ব্যবহার করে Gradle প্রজেক্ট তৈরি করা

Spring Initializr ব্যবহার করে Gradle ভিত্তিক Spring Batch প্রজেক্ট তৈরি করতে, Maven পদ্ধতির মতোই সেটআপ করতে হবে। তবে এই ক্ষেত্রে Project হিসেবে "Gradle Project" নির্বাচন করতে হবে।

1. Spring Initializr ওয়েবসাইটে যান: Spring Initializr
2. Project হিসেবে "Gradle Project" নির্বাচন করুন।
3. Language হিসেবে "Java" নির্বাচন করুন।
4. Spring Boot Version নির্বাচন করুন (যেমন: 3.0.0 বা আপনার পছন্দের লেটেস্ট ভার্সন)।
5. Dependencies হিসেবে "Spring Batch" এবং "Spring Web" নির্বাচন করুন।
6. "Generate" বাটনে ক্লিক করুন এবং ZIP ফাইল ডাউনলোড করে এক্সট্র্যাক্ট করুন।

2. Gradle ডিপেনডেন্সি কনফিগারেশন

Gradle প্রজেক্টের জন্য build.gradle ফাইলে প্রয়োজনীয় ডিপেনডেন্সি কনফিগার করা হয়। নিচে একটি উদাহরণ দেওয়া হলো:

plugins {
    id 'org.springframework.boot' version '3.0.0'
    id 'io.spring.dependency-management' version '1.0.15.RELEASE'
    id 'java'
}

group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '17'

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-batch'
    implementation 'org.springframework.boot:spring-boot-starter-web'
    runtimeOnly 'com.h2database:h2'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

test {
    useJUnitPlatform()
}

এখানে, spring-boot-starter-batch Spring Batch সমর্থনের জন্য এবং spring-boot-starter-web ওয়েব ফিচার যোগ করার জন্য ব্যবহৃত হয়েছে।

3. Spring Batch কনফিগারেশন

Gradle দিয়ে Spring Batch কনফিগার করার জন্য @EnableBatchProcessing অ্যনোটেশন ব্যবহার করা হয়, যা Spring Batch জব এবং স্টেপের কনফিগারেশন করে। এই কনফিগারেশন Maven-এর মতোই হবে। নিচে একটি উদাহরণ দেওয়া হলো:

@Configuration
@EnableBatchProcessing
public class BatchConfig {

    @Autowired
    private JobBuilderFactory jobBuilderFactory;

    @Autowired
    private StepBuilderFactory stepBuilderFactory;

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

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

এটি Spring Batch কনফিগারেশনের সাধারণ উদাহরণ, যা আপনাকে ব্যাচ প্রসেসিংয়ের জন্য প্রয়োজনীয় স্টেপ এবং জব তৈরি করতে সাহায্য করবে।

সারাংশ

Spring Batch প্রজেক্ট তৈরি করতে Maven বা Gradle ব্যবহারের মাধ্যমে এটি খুবই সহজ এবং কার্যকরী হয়। Maven বা Gradle দিয়ে ডিপেনডেন্সি কনফিগারেশনের পর, @EnableBatchProcessing এবং JobBuilderFactory, StepBuilderFactory এর মাধ্যমে ব্যাচ কনফিগারেশন সম্পন্ন করা হয়। Spring Batch আপনাকে বড় পরিমাণে ডেটা প্রক্রিয়াকরণ, স্কেলেবিলিটি এবং ব্যাচ আর্কিটেকচারের সমাধান প্রদান করে।

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

Spring Batch এর জন্য প্রয়োজনীয় ডিপেনডেন্সি যুক্ত করতে হলে, আপনি আপনার Spring Boot প্রকল্পের pom.xml ফাইলে নির্দিষ্ট ডিপেনডেন্সি যোগ করবেন। Spring Batch এর মূল ডিপেনডেন্সি হল spring-boot-starter-batch এবং অন্যান্য ডিপেনডেন্সি প্রয়োজন অনুযায়ী যুক্ত করা হয়।

Spring Batch ডিপেনডেন্সি যোগ করা

১. spring-boot-starter-batch ডিপেনডেন্সি

Spring Batch ব্যবহার করতে প্রথমে spring-boot-starter-batch ডিপেনডেন্সি যোগ করতে হবে। এটি Spring Batch এর মৌলিক উপাদানগুলিকে আপনার Spring Boot প্রকল্পে সংযুক্ত করে। উদাহরণস্বরূপ:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-batch</artifactId>
</dependency>

এই ডিপেনডেন্সিটি আপনার প্রজেক্টে Spring Batch এর সমস্ত প্রয়োজনীয় ফিচার এবং কনফিগারেশন অন্তর্ভুক্ত করবে, যেমন Batch job, JobRepository, ItemReader, ItemProcessor, এবং ItemWriter।

২. ডাটাবেস ডিপেনডেন্সি (যদি প্রয়োজন হয়)

Spring Batch সাধারণত ডেটাবেস ব্যবহার করে ব্যাচ জবের স্টেট সংরক্ষণ করতে এবং ট্র্যাকিং করতে। তাই, আপনি যেই ডেটাবেস ব্যবহার করবেন তার ডিপেনডেন্সি যোগ করতে হবে। উদাহরণস্বরূপ, যদি আপনি MySQL ডেটাবেস ব্যবহার করেন, তাহলে নিচের ডিপেনডেন্সি যুক্ত করতে হবে:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

এছাড়া, আপনি যদি H2 ইন-মেমরি ডেটাবেস ব্যবহার করতে চান (ডেভেলপমেন্ট বা টেস্টিং এর জন্য), তাহলে এর ডিপেনডেন্সি যুক্ত করতে পারেন:

<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

৩. Spring Batch এর জন্য অন্যান্য অতিরিক্ত ডিপেনডেন্সি

Spring Batch দিয়ে বিভিন্ন ধরনের ডেটা সোর্স (যেমন, ফাইল, ডেটাবেস, এবং JMS) প্রসেসিং করতে আপনি নির্দিষ্ট ডিপেনডেন্সি ব্যবহার করতে পারেন। উদাহরণস্বরূপ:

• Spring Batch File Processing: ফাইল থেকে ডেটা প্রসেস করার জন্য আপনি spring-boot-starter-integration ডিপেনডেন্সি ব্যবহার করতে পারেন।

<dependency>
    <groupId>org.springframework.integration</groupId>
    <artifactId>spring-integration-file</artifactId>
</dependency>

• Spring Batch for JMS Processing: যদি আপনি JMS (Java Message Service) ব্যবহার করেন, তাহলে আপনি নিচের ডিপেনডেন্সি যোগ করতে পারেন:

<dependency>
    <groupId>org.springframework.jms</groupId>
    <artifactId>spring-jms</artifactId>
</dependency>

৪. Logging এবং Monitoring ডিপেনডেন্সি

Spring Batch এর মধ্যে logging এবং monitoring ব্যবস্থার জন্য কিছু অতিরিক্ত ডিপেনডেন্সি প্রয়োজন হতে পারে, যেমন:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-logging</artifactId>
</dependency>

এটি Spring Boot অ্যাপ্লিকেশনে লোগিং সক্ষম করে এবং ব্যাচ প্রসেসিং এর বিভিন্ন স্টেপে লগিং করা সম্ভব হয়।

pom.xml ফাইলের সম্পূর্ণ উদাহরণ

এখন পর্যন্ত যে সমস্ত ডিপেনডেন্সি আলোচনা করা হয়েছে, তা একত্রিত করে একটি সম্পূর্ণ pom.xml ফাইলের উদাহরণ দেওয়া হলো:

<dependencies>
    <!-- Spring Boot Starter for Batch Processing -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-batch</artifactId>
    </dependency>

    <!-- Spring Data JPA for Database Operations -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>

    <!-- MySQL Database Driver -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>

    <!-- Spring Boot Starter for Web (If you are using a web application) -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- Spring Boot Starter for Logging -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-logging</artifactId>
    </dependency>

    <!-- Spring Integration File Processing (For file-based batch jobs) -->
    <dependency>
        <groupId>org.springframework.integration</groupId>
        <artifactId>spring-integration-file</artifactId>
    </dependency>

    <!-- Spring JMS for Java Message Service processing -->
    <dependency>
        <groupId>org.springframework.jms</groupId>
        <artifactId>spring-jms</artifactId>
    </dependency>

    <!-- H2 Database for In-memory database (optional) -->
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>
</dependencies>

সারাংশ

Spring Batch ব্যবহার করার জন্য spring-boot-starter-batch ডিপেনডেন্সি প্রধানত প্রয়োজন। এছাড়াও, আপনি যে ডেটাবেস বা ডেটা সোর্স ব্যবহার করছেন, তার জন্য প্রয়োজনীয় ডিপেনডেন্সি যুক্ত করতে হবে, যেমন MySQL, H2, বা JMS। Spring Batch ব্যবহার করে আপনি বড় আকারের ডেটা প্রসেসিংয়ের জন্য কার্যকরী ব্যাচ জবগুলো তৈরি করতে পারবেন, যেখানে ডেটার ট্রান্সফরমেশন এবং প্রক্রিয়াকরণের জন্য জটিল লজিক সহজে সম্পাদন করা যায়।

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

এখানে আমরা দেখব কীভাবে Eclipse এবং IntelliJ IDEA তে Spring Batch প্রজেক্ট সেটআপ করা যায়।

Eclipse তে Spring Batch প্রজেক্ট সেটআপ

১. Eclipse IDE ইনস্টল করা

Eclipse IDE যদি আপনার কম্পিউটারে ইনস্টল না থাকে, তবে Eclipse Download থেকে Eclipse IDE ডাউনলোড করে ইনস্টল করুন। ইনস্টল হয়ে গেলে Eclipse ওপেন করুন এবং Workspace নির্বাচন করুন।

২. Spring Tools 4 প্লাগইন ইনস্টল করা

স্প্রিং ব্যাচ প্রজেক্ট তৈরি করতে Spring Tools 4 প্লাগইনটি ইনস্টল করা প্রয়োজন।

1. Eclipse ওপেন করুন।
2. Help মেনু থেকে Eclipse Marketplace সিলেক্ট করুন।
3. সার্চ বক্সে Spring Tools টাইপ করুন এবং Spring Tools 4 ইনস্টল করুন।
4. ইনস্টলেশনের পর Eclipse রিস্টার্ট করুন।

৩. Spring Batch প্রজেক্ট তৈরি করা

1. File > New > Spring Starter Project নির্বাচন করুন।
2. প্রজেক্টের নাম, গ্রুপ, আর্টিফ্যাক্ট, এবং ডিপেনডেন্সি নির্বাচন করুন।
   • Group: com.example
   • Artifact: batchdemo
3. ডিপেনডেন্সি হিসেবে Spring Batch নির্বাচন করুন। আপনি Spring Web এবং Spring Data JPA যদি প্রয়োজন মনে করেন, তা-ও যোগ করতে পারেন।
4. প্রজেক্ট তৈরি হওয়ার পর, Eclipse আপনাকে স্প্রিং ব্যাচের জন্য প্রয়োজনীয় কনফিগারেশন ফাইল এবং ক্লাস তৈরি করে দিবে।

৪. Spring Batch কনফিগারেশন

application.properties ফাইলে স্প্রিং ব্যাচের জন্য কনফিগারেশন যোগ করুন:

spring.batch.job.enabled=true
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.jpa.hibernate.ddl-auto=update

৫. Spring Batch Job এবং Step কনফিগার করা

এখন, একটি সিম্পল স্প্রিং ব্যাচ জব এবং স্টেপ তৈরি করা হবে।

import org.springframework.batch.core.Job;
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.JobLauncher;
import org.springframework.batch.core.launch.support.RunIdIncrementer;
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 exampleJob(JobBuilderFactory jobBuilderFactory, StepBuilderFactory stepBuilderFactory) {
        return jobBuilderFactory.get("exampleJob")
                .incrementer(new RunIdIncrementer())
                .flow(exampleStep(stepBuilderFactory))
                .end()
                .build();
    }

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

    @Bean
    public ItemReader<String> itemReader() {
        return new CustomItemReader();
    }

    @Bean
    public ItemProcessor<String, String> itemProcessor() {
        return new CustomItemProcessor();
    }

    @Bean
    public ItemWriter<String> itemWriter() {
        return new CustomItemWriter();
    }
}

এখানে CustomItemReader, CustomItemProcessor, এবং CustomItemWriter আপনার নিজস্ব কাস্টম ক্লাস যা ডেটা রিড, প্রসেস এবং রাইট করবে।

৬. Spring Batch Job রান করা

SpringBootApplication ক্লাসে JobLauncher ব্যবহার করে ব্যাচ জব রান করতে পারেন।

import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.batch.core.launch.support.RunIdIncrementer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class BatchApplication {

    @Autowired
    private JobLauncher jobLauncher;

    @Autowired
    private Job exampleJob;

    public static void main(String[] args) {
        SpringApplication.run(BatchApplication.class, args);
    }

    @Bean
    public CommandLineRunner run() {
        return args -> {
            jobLauncher.run(exampleJob, new JobParameters());
        };
    }
}

এখন আপনি অ্যাপ্লিকেশন চালিয়ে ব্যাচ জব রান করতে পারেন।

IntelliJ IDEA তে Spring Batch প্রজেক্ট সেটআপ

১. IntelliJ IDEA ইনস্টল করা

IntelliJ IDEA ডাউনলোড ও ইনস্টল করতে IntelliJ IDEA Download থেকে ইনস্টলার ডাউনলোড করুন। ইনস্টল হয়ে গেলে IntelliJ IDEA ওপেন করুন।

২. Spring Initializr ব্যবহার করা

1. File > New > Project সিলেক্ট করুন।
2. Spring Initializr নির্বাচন করুন এবং Next ক্লিক করুন।
3. গ্রুপ, আর্টিফ্যাক্ট, প্রজেক্টের নাম এবং ডিপেনডেন্সি নির্বাচন করুন:
   • Group: com.example
   • Artifact: batchdemo
   • ডিপেনডেন্সি হিসেবে Spring Batch সিলেক্ট করুন।
4. প্রজেক্ট তৈরি হওয়ার পর IntelliJ IDEA আপনার প্রজেক্টের জন্য স্বয়ংক্রিয়ভাবে ডিপেনডেন্সি এবং কনফিগারেশন তৈরি করবে।

৩. Spring Batch কনফিগারেশন

application.properties ফাইলে স্প্রিং ব্যাচ কনফিগারেশন যোগ করুন:

spring.batch.job.enabled=true
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.jpa.hibernate.ddl-auto=update

৪. Job এবং Step কনফিগারেশন

স্প্রিং ব্যাচের জন্য একটি সিম্পল কনফিগারেশন তৈরি করুন:

@Configuration
@EnableBatchProcessing
public class BatchConfig {

    @Autowired
    public JobBuilderFactory jobBuilderFactory;

    @Autowired
    public StepBuilderFactory stepBuilderFactory;

    @Bean
    public Job job() {
        return jobBuilderFactory.get("job")
                .incrementer(new RunIdIncrementer())
                .flow(step())
                .end()
                .build();
    }

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

    @Bean
    public ItemReader<String> reader() {
        return new CustomReader();
    }

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

    @Bean
    public ItemWriter<String> writer() {
        return new CustomWriter();
    }
}

৫. Spring Batch Job রান করা

IntelliJ IDEA তে SpringBootApplication ক্লাস তৈরি করুন:

@SpringBootApplication
public class BatchApplication {

    @Autowired
    private JobLauncher jobLauncher;

    @Autowired
    private Job job;

    public static void main(String[] args) {
        SpringApplication.run(BatchApplication.class, args);
    }

    @Bean
    public CommandLineRunner run() {
        return args -> {
            jobLauncher.run(job, new JobParameters());
        };
    }
}

এখন আপনার স্প্রিং ব্যাচ প্রজেক্ট রান হবে এবং আপনি কনসোলে ফলাফল দেখতে পাবেন।

সারাংশ

স্প্রিং ব্যাচ (Spring Batch) একটি শক্তিশালী ফ্রেমওয়ার্ক যা ব্যাচ প্রসেসিং এবং ডেটা ম্যানিপুলেশন করতে ব্যবহৃত হয়। Eclipse বা IntelliJ IDEA তে স্প্রিং ব্যাচ প্রজেক্ট সেটআপ করা খুবই সহজ। প্রজেক্ট তৈরির পর, স্প্রিং ব্যাচ কনফিগারেশন, জব, স্টেপ এবং প্রোসেসর ইত্যাদি তৈরি করে ডেটা প্রোসেসিং চালানো সম্ভব হয়।

Spring Batch একটি পাওয়ারফুল ফ্রেমওয়ার্ক যা বড় আকারের ডেটা প্রসেসিং (যেমন, ব্যাচ প্রসেসিং) পরিচালনা করতে ব্যবহৃত হয়। এটি এমন কাজের জন্য ডিজাইন করা হয়েছে যেখানে ডেটা সিকোয়েন্সিয়ালভাবে প্রসেস করা হয়, যেমন ডেটাবেস থেকে ডেটা রিড করা, ডেটা প্রোসেস করা, এবং ডেটাবেসে বা অন্য কোনো স্টোরেজে রাইট করা।

এখানে একটি Hello World Batch Example তৈরি করা হবে, যা Spring Batch ব্যবহার করে একটি ব্যাচ প্রসেস তৈরি করবে।

1. প্রয়োজনীয় ডিপেনডেন্সি ইনস্টল করা

Spring Batch অ্যাপ্লিকেশনে কাজ করার জন্য প্রথমে spring-boot-starter-batch ডিপেনডেন্সি আপনার pom.xml ফাইলে যোগ করতে হবে। যদি আপনি ডেটাবেস ব্যবহার করতে চান, তাহলে spring-boot-starter-data-jpa এবং ডেটাবেস ড্রাইভারও যোগ করতে হবে।

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

    <!-- Spring Boot Starter Data JPA for database integration (optional) -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>

    <!-- Database driver (e.g., H2, MySQL, PostgreSQL) -->
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>
</dependencies>

এখানে, spring-batch-core ডিপেনডেন্সি Spring Batch এর মূল কার্যকারিতা প্রদান করে। যদি আপনি ডেটাবেস ব্যবহার করেন, তাহলে spring-boot-starter-data-jpa এবং একটি ডেটাবেস ড্রাইভার (এখানে H2 ডাটাবেস ব্যবহৃত হচ্ছে) যুক্ত করতে হবে।

2. Spring Batch কনফিগারেশন

Spring Batch কনফিগারেশনে Job এবং Step তৈরি করা হয়। একটি Job একটি ব্যাচ প্রসেস এবং এক বা একাধিক Step দিয়ে গঠিত। প্রতিটি Step একটি নির্দিষ্ট কাজ সম্পাদন করে, যেমন ডেটা রিড করা, প্রোসেস করা, এবং রাইট করা।

2.1 Batch Job কনফিগারেশন ক্লাস

package com.example.helloworld.batch;

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.Job;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.batch.core.launch.JobExecutionException;
import org.springframework.batch.core.JobExecution;
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 helloWorldJob() {
        return jobBuilderFactory.get("helloWorldJob")
                .incrementer(new RunIdIncrementer())
                .start(helloWorldStep())
                .build();
    }

    @Bean
    public Step helloWorldStep() {
        return stepBuilderFactory.get("helloWorldStep")
                .<String, String>chunk(1)  // Process 1 item at a time
                .reader(new HelloWorldReader())
                .processor(new HelloWorldProcessor())
                .writer(new HelloWorldWriter())
                .build();
    }

    public static void main(String[] args) throws JobExecutionException {
        JobLauncher jobLauncher = new JobLauncher();  // Initialize JobLauncher
        JobExecution execution = jobLauncher.run(helloWorldJob(), new JobParameters());
        System.out.println("Job Status : " + execution.getStatus());
    }
}

এখানে:

• @EnableBatchProcessing: Spring Batch প্রসেসিং সক্ষম করে।
• Job: একটি ব্যাচ প্রসেস (এখানে helloWorldJob), যা একটি Step দিয়ে গঠিত।
• Step: helloWorldStep নামে একটি Step তৈরি করা হয়েছে, যা reader, processor, এবং writer এর মাধ্যমে কাজ সম্পন্ন করে।

3. Reader, Processor, এবং Writer তৈরি করা

Spring Batch এ প্রতিটি Step তিনটি প্রধান কম্পোনেন্ট দিয়ে গঠিত:

1. Reader: এটি ডেটা পড়ার কাজ করে (যেমন, ডেটাবেস বা ফাইল থেকে ডেটা রিড করা)।
2. Processor: এটি ডেটা প্রোসেসিং করে (যেমন, রূপান্তর বা ফিল্টার করা)।
3. Writer: এটি ডেটা সঞ্চয় (যেমন, ডেটাবেস বা ফাইলে ডেটা রাইট করা)।

3.1 Reader তৈরি করা

package com.example.helloworld.batch;

import org.springframework.batch.item.ItemReader;

public class HelloWorldReader implements ItemReader<String> {

    private String[] data = {"Hello", "World", "from", "Spring", "Batch"};
    private int count = 0;

    @Override
    public String read() {
        if (count < data.length) {
            return data[count++];
        }
        return null; // When data ends
    }
}

এখানে, HelloWorldReader একটি ইমপ্লিমেন্টেশন যা একটি অ্যারে থেকে ডেটা পড়ে।

3.2 Processor তৈরি করা

package com.example.helloworld.batch;

import org.springframework.batch.item.ItemProcessor;

public class HelloWorldProcessor implements ItemProcessor<String, String> {

    @Override
    public String process(String item) throws Exception {
        return item.toUpperCase();  // Convert to uppercase
    }
}

এখানে, HelloWorldProcessor প্রতিটি String কে uppercase তে রূপান্তরিত করে।

3.3 Writer তৈরি করা

package com.example.helloworld.batch;

import org.springframework.batch.item.ItemWriter;
import java.util.List;

public class HelloWorldWriter implements ItemWriter<String> {

    @Override
    public void write(List<? extends String> items) throws Exception {
        for (String item : items) {
            System.out.println(item);  // Print each item to console
        }
    }
}

এখানে, HelloWorldWriter প্রতিটি প্রোসেস করা String কনসোলে প্রিন্ট করে।

4. অ্যাপ্লিকেশন চালানো

Spring Batch অ্যাপ্লিকেশন চালাতে, BatchConfig ক্লাসে main() মেথড কল করে JobLauncher এবং JobExecution ব্যবহার করা হয়েছে। এইভাবে ব্যাচ প্রোগ্রামটি শুরু হবে এবং প্রতিটি String কে uppercase করে কনসোলে প্রিন্ট করা হবে।

4.1 JobExecution Console Output

যখন আপনি এই অ্যাপ্লিকেশনটি চালাবেন, কনসোলে এই ধরনের আউটপুট দেখাবে:

HELLO
WORLD
FROM
SPRING
BATCH

সারাংশ

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