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

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

ItemProcessor এর ভূমিকা

ItemProcessor এর মাধ্যমে আমরা মূলত নিচের কাজগুলো করতে পারি:

• ডাটা ফিল্টারিং (Data Filtering): নির্দিষ্ট শর্ত পূরণ না করলে ডাটাকে ফিল্টার করা।
• ডাটা কনভার্সন (Data Conversion): ডাটাকে একটি ফরম্যাট থেকে অন্য ফরম্যাটে রূপান্তর করা (যেমন String থেকে Integer)।
• বিজনেস লজিক (Business Logic): ইনপুট ডাটার উপর নির্দিষ্ট লজিক প্রয়োগ করা।

Spring Batch এ ItemProcessor ইন্টারফেস ইমপ্লিমেন্ট করে আপনি যে কোনো ধরনের প্রসেসিং লজিক যুক্ত করতে পারেন।

Spring Batch ItemProcessor এর কনফিগারেশন

Spring Batch এ ItemProcessor কনফিগারেশন করতে হলে আপনাকে একটি ক্লাস তৈরি করতে হবে যা ItemProcessor ইন্টারফেস ইমপ্লিমেন্ট করবে। নিচে একটি উদাহরণ দেয়া হলো।

1. Simple ItemProcessor উদাহরণ

ধরা যাক, আমাদের একটি ডাটাবেস থেকে "Employee" তথ্য রিড করা হচ্ছে এবং আমাদের সেই ডাটাকে প্রসেস করতে হবে (যেমন, একটি নামের প্রথম অক্ষর বড় করে দেয়া)।

package com.example.demo;

import org.springframework.batch.item.ItemProcessor;
import org.springframework.stereotype.Component;

@Component
public class EmployeeItemProcessor implements ItemProcessor<Employee, Employee> {

    @Override
    public Employee process(Employee employee) throws Exception {
        String firstName = employee.getFirstName().toUpperCase();
        employee.setFirstName(firstName);
        return employee;  // প্রসেস করা Employee অবজেক্ট ফিরিয়ে দেয়া হচ্ছে
    }
}
Copy

এখানে, EmployeeItemProcessor ক্লাসে process() মেথডে Employee অবজেক্টের firstName কে uppercase করে দেওয়া হচ্ছে। এর মাধ্যমে ডাটা প্রসেস হচ্ছে।

2. Complex ItemProcessor উদাহরণ

ধরা যাক, আপনি চান কিছু বিশেষ শর্তে ডাটাকে ফিল্টার করতে এবং সেই ডাটা প্রসেস করে লিখতে। নিচে এমন একটি উদাহরণ দেয়া হলো যেখানে শুধু Salary > 5000 এমন কর্মচারীদের নির্বাচন করা হয়েছে।

package com.example.demo;

import org.springframework.batch.item.ItemProcessor;
import org.springframework.stereotype.Component;

@Component
public class EmployeeSalaryProcessor implements ItemProcessor<Employee, Employee> {

    @Override
    public Employee process(Employee employee) throws Exception {
        if (employee.getSalary() > 5000) {
            // যদি Salary > 5000 হয়, তাহলে প্রসেস করে ফেরত দাও
            return employee;
        } else {
            // Salary <= 5000 হলে null ফেরত দাও, যার মানে হচ্ছে এই আইটেমটি পরবর্তী স্টেপে লেখা হবে না
            return null;
        }
    }
}
Copy

এখানে, EmployeeSalaryProcessor ক্লাসে Salary 5000 এর বেশি না হলে null ফেরত দেয়া হচ্ছে, যার মানে এই আইটেমটি পরবর্তী ধাপে যাবে না এবং Writer এ লিখিত হবে না।

3. ItemProcessor ব্যবহার করা Step Configuration এ

এখন, যেহেতু ItemProcessor তৈরি করা হয়েছে, এটি Step Configuration এ ব্যবহার করা হবে। নিচে একটি উদাহরণ দেয়া হলো যেখানে ItemProcessor কে Step এ ইনজেক্ট করা হয়েছে।

package com.example.demo;

import org.springframework.batch.core.Step;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
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 Step step1(StepBuilderFactory stepBuilderFactory, 
                      ItemReader<Employee> reader, 
                      ItemProcessor<Employee, Employee> processor, 
                      ItemWriter<Employee> writer) {
        return stepBuilderFactory.get("step1")
                .<Employee, Employee>chunk(10)
                .reader(reader)
                .processor(processor)  // ItemProcessor এখানে ইনজেক্ট করা হচ্ছে
                .writer(writer)
                .build();
    }
}
Copy

এখানে, ItemProcessor কে Step এর মধ্যে ইনজেক্ট করা হয়েছে, যাতে ItemReader থেকে রিড করা ডাটা প্রসেস করতে পারে এবং ItemWriter এর মাধ্যমে আউটপুট লেখা যাবে।

ItemProcessor এর সুবিধা

• ডাটা প্রসেসিং ফ্লেক্সিবিলিটি: ItemProcessor দিয়ে আপনি যে কোনো ধরনের ডাটা প্রসেসিং লজিক প্রয়োগ করতে পারেন, যেমন ডাটা ফিল্টারিং, কনভার্সন, বা বিজনেস লজিক।
• কাস্টম প্রসেসিং: আপনি যদি কোনো কাস্টম প্রসেসিং করতে চান (যেমন ভ্যালিডেশন, কাস্টম ট্রান্সফরমেশন), তাহলে ItemProcessor খুবই উপকারী।
• প্রফরমেন্স বৃদ্ধি: Large-scale ডাটা প্রসেসিংয়ে, ItemProcessor ডাটা ফিল্টার বা কনভার্সনের জন্য কার্যকরী হতে পারে, যা সিস্টেমের পারফরম্যান্স বৃদ্ধি করে।

সারাংশ

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

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

ItemProcessor কি?

Spring Batch-এ ItemProcessor একটি ইন্টারফেস, যা একটি নির্দিষ্ট ডেটা প্রক্রিয়া বা পরিবর্তন করে। এটি ItemReader থেকে প্রাপ্ত ইনপুট ডেটাকে প্রসেস (যেমন: কাস্টম লজিক বা ডেটার মান পরিবর্তন) করে এবং পরিবর্তিত ডেটাকে ItemWriter এ পাঠায়। এর মূল উদ্দেশ্য হল রিড করা ডেটার ওপর নির্দিষ্ট প্রক্রিয়া প্রয়োগ করা এবং তার ফলাফল লিখতে দেওয়া।

ItemProcessor ইন্টারফেসটি একটি সাধারণ মেথডের মধ্যে প্রক্রিয়া করে:

T process(I item) throws Exception;
Copy

এখানে,

• I হল ইনপুট টাইপ (যেমন: ডেটার ধরনের ক্লাস),
• T হল আউটপুট টাইপ (যেমন: প্রক্রিয়া করা ডেটার নতুন ধরনের ক্লাস)।

এটি ItemReader থেকে রিড করা ডেটা গ্রহণ করে এবং তার ওপর কাস্টম লজিক প্রয়োগ করে ডেটাকে পরিবর্তন করে।

ItemProcessor এর কাজ

ItemProcessor এর কাজ হল রিড করা ডেটা প্রক্রিয়া করা। এটি বিভিন্ন ধরনের কাজ করতে পারে, যেমন:

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

ItemProcessor-এর প্রধান কাজ হল, ItemReader থেকে রিড করা ডেটা গ্রহণ করা এবং নির্দিষ্ট লজিক প্রয়োগ করে ডেটার মান পরিবর্তন বা ট্রান্সফর্ম করা, তারপর সেই পরিবর্তিত ডেটা ItemWriter-এ পাঠানো।

ItemProcessor এর উদাহরণ

ধরা যাক, আমাদের একটি অ্যাপ্লিকেশন আছে যেখানে বিভিন্ন পণ্য (product) তথ্য রয়েছে এবং আমরা সেই পণ্যের দাম ১০% বাড়াতে চাই। নিচে একটি উদাহরণ দেওয়া হলো যেখানে ItemProcessor ব্যবহার করে প্রতিটি পণ্যের দাম ১০% বৃদ্ধি করা হচ্ছে।

1. ItemProcessor ইন্টারফেস বাস্তবায়ন

public class ProductProcessor implements ItemProcessor<Product, Product> {

    @Override
    public Product process(Product product) throws Exception {
        // দাম ১০% বাড়ানো
        double increasedPrice = product.getPrice() * 1.10;
        product.setPrice(increasedPrice);
        
        return product;  // প্রক্রিয়া করা পণ্য
    }
}
Copy

এখানে, ProductProcessor ক্লাসে ItemProcessor ইন্টারফেসটি বাস্তবায়িত করা হয়েছে। process() মেথডে, পণ্যের দাম ১০% বাড়ানো হচ্ছে।

2. ItemReader এবং ItemWriter

এবার আমরা ItemReader এবং ItemWriter ব্যবহার করে এই প্রক্রিয়াটি সম্পন্ন করবো।

@Bean
public Step step1(ItemReader<Product> reader, ItemProcessor<Product, Product> processor, ItemWriter<Product> writer) {
    return stepBuilderFactory.get("step1")
            .<Product, Product>chunk(10)
            .reader(reader)  // ItemReader (Product ডেটা)
            .processor(processor)  // ItemProcessor (প্রক্রিয়া করা)
            .writer(writer)  // ItemWriter (ডেটা লিখতে)
            .build();
}
Copy

এখানে, reader পণ্য রিড করবে, processor পণ্যটির দাম বৃদ্ধি করবে এবং writer প্রক্রিয়া করা পণ্যগুলো লিখে দেবে।

ItemProcessor এর প্রয়োজনীয়তা

1. ডেটা ট্রান্সফরমেশন এবং কাস্টম লজিক প্রয়োগ

ItemProcessor ডেটাকে এক ফর্ম্যাট থেকে অন্য ফর্ম্যাটে পরিবর্তন করতে সাহায্য করে। এর মাধ্যমে ডেটার উপযোগিতা বৃদ্ধি পায় এবং ব্যাচ প্রসেসিংয়ের নির্দিষ্ট প্রক্রিয়া সম্পন্ন করা যায়।

2. ফিল্টারিং এবং ভ্যালিডেশন

ডেটা প্রক্রিয়ার সময়, আপনি কিছু নির্দিষ্ট শর্ত বা কন্ডিশন অনুযায়ী ডেটা ফিল্টার বা ভ্যালিডেট করতে পারেন। এর ফলে আপনি শুধু প্রয়োজনীয় ডেটাই প্রসেস করতে পারবেন, অবাঞ্ছিত ডেটা বাদ দিতে পারবেন।

3. ব্যবসায়িক লজিক প্রয়োগ

Spring Batch-এ ItemProcessor ব্যবহার করে আপনি সহজেই আপনার অ্যাপ্লিকেশনের ব্যবসায়িক লজিক প্রয়োগ করতে পারেন, যেমন কোনো পণ্য বা সার্ভিসের মূল্য বৃদ্ধি, ডিসকাউন্ট প্রক্রিয়া, অথবা কোনো নির্দিষ্ট শর্ত পূরণ হলে ডেটা পরিবর্তন করা।

4. এটা সহজে রিইউজেবল

ItemProcessor সাধারণত একটি আলাদা ক্লাসের মধ্যে থাকে, যা বিভিন্ন ব্যাচ প্রসেসিংয়ের জন্য পুনরায় ব্যবহার করা যায়। এটি Spring Batch-এ কাস্টম লজিকের পুনঃব্যবহারযোগ্যতা বৃদ্ধি করে।

সারাংশ

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

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

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

ItemProcessor এর কাজ

ItemProcessor ইন্টারফেসে একটি মেথড থাকে যার নাম process(), যেটি একটি ইনপুট আইটেম গ্রহণ করে এবং প্রক্রিয়াকৃত আইটেম রিটার্ন করে। এর মাধ্যমে ডেটা প্রসেস করা হয় এবং তারপর সেটি ItemWriter এ পাঠানো হয়, যেখানে এটি নির্দিষ্ট আউটপুট স্টোরেজে (যেমন ডেটাবেস, ফাইল, ইত্যাদি) সংরক্ষিত হয়।

public interface ItemProcessor<I, O> {
    O process(I item) throws Exception;
}
Copy

এখানে:

• I হল ইনপুট টাইপ (যেমন, Person অবজেক্ট)।
• O হল আউটপুট টাইপ (যেমন, ProcessedPerson অবজেক্ট)।

ItemProcessor এর process() মেথডটি ইনপুট আইটেম গ্রহণ করে এবং একটি নতুন আউটপুট আইটেম রিটার্ন করে। এতে আপনি ট্রান্সফরমেশন, কাস্টম ফিল্টারিং, অথবা ডেটা যাচাইয়ের মতো কাজ করতে পারেন।

ItemProcessor এর উদাহরণ

ধরা যাক, আমাদের একটি ব্যাচ প্রসেসিং অ্যাপ্লিকেশন রয়েছে যেখানে আমরা Person অবজেক্টগুলোর তথ্য প্রসেস করতে চাই এবং তার মধ্যে থাকা age প্রপার্টি অনুযায়ী Person অবজেক্টগুলো ফিল্টার করতে চাই। যদি একটি Person এর বয়স 18 এর কম হয়, তবে সেই Person অবজেক্টটি প্রসেস করার পর ফিল্টার করে সরিয়ে দেওয়া হবে।

Step 1: Model Class (Person)

public class Person {
    private String name;
    private int age;

    // Constructor, Getters, Setters
}
Copy

Step 2: ItemProcessor Implementation

public class PersonItemProcessor implements ItemProcessor<Person, Person> {

    @Override
    public Person process(Person item) throws Exception {
        // যদি বয়স 18 এর কম হয়, তবে অবজেক্টটি ফিল্টার করে সরিয়ে ফেলুন
        if (item.getAge() < 18) {
            return null; // null ফেরত দেওয়া হলে, Spring Batch ঐ আইটেমটি বাদ দিবে
        }

        // বয়স 18 বা তার বেশি হলে, নামটি ক্যাপিটালাইজ করা হবে
        item.setName(item.getName().toUpperCase());
        return item; // প্রসেস করা অবজেক্ট ফেরত দিন
    }
}
Copy

Step 3: Batch Step Configuration

এখন আমরা আমাদের ItemProcessor কে Spring Batch Step এর সাথে কনফিগার করব। এখানে chunk ভিত্তিক স্টেপ ব্যবহার করা হয়েছে যেখানে প্রতি 10টি আইটেম প্রসেস করা হবে:

@Bean
public Step step1() {
    return stepBuilderFactory.get("step1")
            .<Person, Person> chunk(10) // প্রতি 10টি আইটেমের পরে কমিট হবে
            .reader(personReader())   // Person Reader (যেখানে ডেটা পড়া হবে)
            .processor(personProcessor()) // Person Processor (যেখানে ডেটা প্রসেস করা হবে)
            .writer(personWriter())  // Person Writer (যেখানে ডেটা লিখা হবে)
            .build();
}

@Bean
public ItemReader<Person> personReader() {
    return new PersonItemReader(); // Person Reader
}

@Bean
public ItemProcessor<Person, Person> personProcessor() {
    return new PersonItemProcessor(); // ItemProcessor ব্যবহার করা হবে
}

@Bean
public ItemWriter<Person> personWriter() {
    return new PersonItemWriter(); // Person Writer
}
Copy

Step 4: Reader এবং Writer এর উদাহরণ

ItemReader এবং ItemWriter কিভাবে কাজ করে, তা দেখা যাক:

PersonItemReader (ItemReader)

public class PersonItemReader implements ItemReader<Person> {
    
    private List<Person> personList = Arrays.asList(
        new Person("John", 20),
        new Person("Mary", 17),
        new Person("Alex", 25)
    );
    private int index = 0;

    @Override
    public Person read() throws Exception {
        if (index < personList.size()) {
            return personList.get(index++);
        } else {
            return null; // No more items
        }
    }
}
Copy

PersonItemWriter (ItemWriter)

public class PersonItemWriter implements ItemWriter<Person> {

    @Override
    public void write(List<? extends Person> items) throws Exception {
        // এখানে ডেটা ফাইল বা ডাটাবেসে লেখা হবে
        for (Person person : items) {
            System.out.println("Writing person: " + person.getName() + ", Age: " + person.getAge());
        }
    }
}
Copy

ItemProcessor এর সুবিধা

1. Data Transformation: ItemProcessor ডেটার ট্রান্সফরমেশন বা মডিফিকেশন করতে ব্যবহৃত হয়। আপনি ডেটার বিভিন্ন ফিল্ড পরিবর্তন, যোগ বা বাদ দিতে পারেন।
2. Filtering: আপনি process() মেথডের মধ্যে null রিটার্ন করে ডেটা ফিল্টার করতে পারেন, অর্থাৎ কিছু আইটেম বাদ দিতে পারেন।
3. Validation: ItemProcessor ডেটা যাচাই করতে ব্যবহৃত হতে পারে, যেমন কোনো ডেটা অবৈধ হলে তা বাদ দেওয়া।
4. Flexibility: আপনি যে কোনো কাস্টম লজিক প্রয়োগ করতে পারেন, যেমন এনক্রিপশন, ফরম্যাটিং বা কাস্টম মেটা ডেটা যোগ করা।

সারাংশ

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

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

এখানে আমরা দেখব কিভাবে একটি Custom ItemProcessor তৈরি করা যায়, যা আপনার নির্দিষ্ট ডেটা প্রসেসিং চাহিদা পূরণ করতে সহায়তা করবে।

ItemProcessor এর ভূমিকা

ItemProcessor স্প্রিং ব্যাচের ItemProcessor<T, R> ইন্টারফেস ইমপ্লিমেন্ট করে কাজ করে, যেখানে:

• T হলো ইনপুট আইটেম টাইপ (যা আপনি রিড করবেন)।
• R হলো আউটপুট আইটেম টাইপ (যা আপনি প্রসেস করার পর রিটার্ন করবেন)।

এটি সাধারণত read এবং write অপারেশনের মধ্যে ব্যবহৃত হয়, যেখানে read অপারেশন ডেটা রিড করে এবং write অপারেশন প্রসেস করা ডেটা লেখা হয়।

Custom ItemProcessor তৈরি করার উদাহরণ

ধরা যাক, আমাদের একটি Employee নামক ক্লাস আছে, যা name, age, এবং salary ধারণ করে, এবং আমরা একটি কাস্টম প্রসেসর তৈরি করতে চাই যা প্রতিটি Employee এর বয়স ১৮ এর উপরে হলে তাদের বেতন দ্বিগুণ করে দেবে।

১. Employee ক্লাস তৈরি করা

public class Employee {

    private String name;
    private int age;
    private double salary;

    // Constructor, Getters and Setters

    public Employee(String name, int age, double salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
}
Copy

২. Custom ItemProcessor তৈরি করা

এখন, আমরা একটি কাস্টম ItemProcessor তৈরি করব যা Employee এর বেতন ১৮ বছরের উপরে বয়স হলে দ্বিগুণ করবে।

import org.springframework.batch.item.ItemProcessor;

public class EmployeeItemProcessor implements ItemProcessor<Employee, Employee> {

    @Override
    public Employee process(Employee employee) throws Exception {
        // যদি বয়স ১৮ বছরের উপরে হয়, তাহলে বেতন দ্বিগুণ করুন
        if (employee.getAge() > 18) {
            double newSalary = employee.getSalary() * 2;
            employee.setSalary(newSalary);
            System.out.println("Processed Employee: " + employee.getName() + ", New Salary: " + newSalary);
        }
        return employee;
    }
}
Copy

এখানে, process মেথডটি একটি Employee অবজেক্ট গ্রহণ করবে এবং যদি বয়স ১৮ বছরের বেশি হয়, তাহলে তার বেতন দ্বিগুণ করে সেট করবে।

৩. Spring Batch Configuration এ ItemProcessor যুক্ত করা

এখন আমাদের স্প্রিং ব্যাচ কনফিগারেশনে এই কাস্টম ItemProcessor যুক্ত করতে হবে।

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 job(JobBuilderFactory jobBuilderFactory, StepBuilderFactory stepBuilderFactory) {
        return jobBuilderFactory.get("employeeJob")
                .incrementer(new RunIdIncrementer())
                .flow(employeeStep(stepBuilderFactory))
                .end()
                .build();
    }

    @Bean
    public Step employeeStep(StepBuilderFactory stepBuilderFactory) {
        return stepBuilderFactory.get("employeeStep")
                .<Employee, Employee>chunk(10)
                .reader(employeeReader())
                .processor(employeeItemProcessor())
                .writer(employeeWriter())
                .build();
    }

    @Bean
    public ItemReader<Employee> employeeReader() {
        return new EmployeeReader(); // Implement this based on your input source (e.g., CSV, database, etc.)
    }

    @Bean
    public ItemProcessor<Employee, Employee> employeeItemProcessor() {
        return new EmployeeItemProcessor(); // Our custom processor
    }

    @Bean
    public ItemWriter<Employee> employeeWriter() {
        return new EmployeeWriter(); // Implement this to write processed data (e.g., save to database, output to file)
    }
}
Copy

এখানে employeeItemProcessor() মেথডে আমরা কাস্টম EmployeeItemProcessor যুক্ত করেছি।

৪. ItemReader এবং ItemWriter ক্লাস

এটি একটি উদাহরণ যেখানে EmployeeReader এবং EmployeeWriter কাস্টম ক্লাস তৈরি করতে হবে:

EmployeeReader (ItemReader):

import org.springframework.batch.item.ItemReader;

public class EmployeeReader implements ItemReader<Employee> {

    private int index = 0;
    private List<Employee> employees = Arrays.asList(
            new Employee("John", 25, 5000),
            new Employee("Doe", 17, 4000),
            new Employee("Jane", 22, 4500)
    );

    @Override
    public Employee read() throws Exception {
        if (index < employees.size()) {
            return employees.get(index++);
        }
        return null;
    }
}
Copy

EmployeeWriter (ItemWriter):

import org.springframework.batch.item.ItemWriter;

public class EmployeeWriter implements ItemWriter<Employee> {

    @Override
    public void write(List<? extends Employee> items) throws Exception {
        // Write the processed items to some output (e.g., database, file, etc.)
        for (Employee employee : items) {
            System.out.println("Writing Employee: " + employee.getName() + " with Salary: " + employee.getSalary());
        }
    }
}
Copy

৫. Batch Job রান করা

আপনি যখন অ্যাপ্লিকেশন চালাবেন, তখন স্প্রিং ব্যাচ আপনার EmployeeItemProcessor ক্লাসটি ব্যবহার করবে এবং সকল Employee এর তথ্য প্রসেস করে তাদের বেতন দ্বিগুণ করবে যদি বয়স ১৮ বছরের উপরে হয়।

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.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class BatchApplication implements CommandLineRunner {

    @Autowired
    private JobLauncher jobLauncher;

    @Autowired
    private Job job;

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

    @Override
    public void run(String... args) throws Exception {
        jobLauncher.run(job, new JobParameters());
    }
}
Copy

সারাংশ

এতে দেখানো হয়েছে কীভাবে একটি কাস্টম ItemProcessor তৈরি করা যায় যা ডেটা ট্রান্সফর্মেশন বা ফিল্টারিং করার জন্য ব্যবহৃত হয়। এখানে EmployeeItemProcessor ক্লাস তৈরি করা হয়েছে যা Employee অবজেক্টের salary মান পরিবর্তন করে যদি তার বয়স ১৮ বছরের বেশি হয়। স্প্রিং ব্যাচের সাথে ItemProcessor ব্যবহার করে আপনি সহজেই আপনার ডেটা প্রসেসিং এবং ট্রান্সফর্মেশন কার্যক্রম পরিচালনা করতে পারবেন।