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

স্প্রিং ব্যাচে Exception Handling

স্প্রিং ব্যাচের মধ্যে Exception Handling এর জন্য কিছু প্রাথমিক কৌশল রয়েছে, যেমন Skip, Retry, এবং Listeners ব্যবহার করা, যা ব্যাচ জবের execution এর সময় ত্রুটি হ্যান্ডলিংকে সহজ করে তোলে।

১. Skip Policy (Skip Exceptions)

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

SkipPolicy ব্যবহার:

import org.springframework.batch.core.Step;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.StepExecutionListener;
import org.springframework.batch.core.job.flow.FlowExecutionException;
import org.springframework.batch.core.StepExecution;
import org.springframework.batch.core.explore.JobExplorer;
import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
import org.springframework.batch.core.repository.JobRepository;
import org.springframework.batch.core.partition.support.Partitioner;

import org.springframework.batch.core.listener.SkipListener;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Configuration
@EnableBatchProcessing
public class BatchConfig {

    @Autowired
    private StepBuilderFactory stepBuilderFactory;

    @Autowired
    private JobBuilderFactory jobBuilderFactory;

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

    @Bean
    public Step processStep() {
        return stepBuilderFactory.get("processStep")
                .<MyData, MyData>chunk(10)
                .reader(myItemReader())
                .processor(myItemProcessor())
                .writer(myItemWriter())
                .faultTolerant()
                .skip(Exception.class) // Skipping exceptions
                .skipLimit(5) // Skip limit (maximum number of times we allow skipping)
                .build();
    }
}
Copy

এখানে skip(Exception.class) ব্যবহার করা হয়েছে, যার মানে হল যে Exception ঘটলে স্কিপ করা হবে এবং ব্যাচ প্রক্রিয়া চলতে থাকবে। skipLimit(5) দ্বারা আমরা নির্ধারণ করছি যে সর্বাধিক কতবার ত্রুটি ঘটলে স্কিপ করা হবে।

Skip Listener:

SkipListener ব্যবহার করে আপনি যখন কোনো রেকর্ড স্কিপ করেন, তখন সেটি লগ করতে বা অন্য কোনো কাজ করতে পারেন।

import org.springframework.batch.core.listener.SkipListenerSupport;

public class CustomSkipListener extends SkipListenerSupport<MyData, MyData> {

    @Override
    public void onSkipInProcess(MyData item, Throwable t) {
        System.out.println("Skipping item: " + item + " due to exception: " + t.getMessage());
    }
}
Copy

এখানে, CustomSkipListener ব্যবহার করা হয়েছে যাতে ত্রুটি হলে, সেই আইটেমটি স্কিপ করে লগ করা হয়।

২. Retry Policy (Retry Exceptions)

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

RetryPolicy ব্যবহার:

import org.springframework.batch.core.Step;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.StepExecutionListener;
import org.springframework.batch.core.job.flow.FlowExecutionException;
import org.springframework.batch.core.StepExecution;

@Configuration
@EnableBatchProcessing
public class BatchConfig {

    @Autowired
    private StepBuilderFactory stepBuilderFactory;

    @Autowired
    private JobBuilderFactory jobBuilderFactory;

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

    @Bean
    public Step processStep() {
        return stepBuilderFactory.get("processStep")
                .<MyData, MyData>chunk(10)
                .reader(myItemReader())
                .processor(myItemProcessor())
                .writer(myItemWriter())
                .faultTolerant()
                .retry(Exception.class) // Retry on exception
                .retryLimit(3) // Retry limit (maximum number of retries)
                .build();
    }
}
Copy

এখানে, retry(Exception.class) ব্যবহার করা হয়েছে, যার মানে হল যে Exception ঘটলে পুনরায় প্রক্রিয়া করা হবে এবং retryLimit(3) দ্বারা নির্ধারণ করা হয়েছে যে সর্বাধিক ৩ বার চেষ্টা করা যাবে।

৩. JobExecutionListener এবং StepExecutionListener ব্যবহার করা

স্প্রিং ব্যাচে JobExecutionListener এবং StepExecutionListener ব্যবহার করে আপনি ব্যাচ জবের বা স্টেপের মধ্যে ত্রুটি হ্যান্ডলিং করতে পারেন। এই listeners আপনাকে ব্যাচের execution এর আগে, পরে এবং ত্রুটি ঘটলে বিশেষ কার্যকলাপ (ফাংশন) সম্পাদন করতে সাহায্য করে।

JobExecutionListener উদাহরণ:

import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.listener.JobExecutionListenerSupport;
import org.springframework.batch.core.JobExecutionListener;

public class CustomJobExecutionListener extends JobExecutionListenerSupport {

    @Override
    public void beforeJob(JobExecution jobExecution) {
        // Job শুরু হওয়ার আগে
        System.out.println("Job started...");
    }

    @Override
    public void afterJob(JobExecution jobExecution) {
        // Job শেষ হওয়ার পরে
        if (jobExecution.getStatus().isUnsuccessful()) {
            System.out.println("Job failed with exception: " + jobExecution.getExitStatus());
        } else {
            System.out.println("Job completed successfully");
        }
    }
}
Copy

৪. DefaultExceptionHandler

স্প্রিং ব্যাচে, আপনি DefaultExceptionHandler ব্যবহার করে, যে কোনো স্টেপের জন্য ডিফল্ট ত্রুটি হ্যান্ডলিং কনফিগারেশন করতে পারেন।

import org.springframework.batch.core.step.skip.DefaultSkipPolicy;

@Bean
public DefaultSkipPolicy defaultSkipPolicy() {
    DefaultSkipPolicy skipPolicy = new DefaultSkipPolicy();
    skipPolicy.setSkipLimit(5); // Maximum skip limit
    return skipPolicy;
}
Copy

সারাংশ

স্প্রিং ব্যাচে Exception Handling অত্যন্ত গুরুত্বপূর্ণ, কারণ ব্যাচ প্রসেসিংয়ে বিভিন্ন ধরনের ত্রুটি ঘটতে পারে। এই ত্রুটিগুলিকে কার্যকরীভাবে হ্যান্ডল করার জন্য স্প্রিং ব্যাচ Skip, Retry, Listeners ইত্যাদি কৌশল প্রদান করে।

• Skip কৌশলটি ব্যবহার করে আপনি ত্রুটিপূর্ণ আইটেমগুলো স্কিপ করতে পারেন।
• Retry কৌশলটি ব্যবহার করে আপনি ত্রুটিপূর্ণ আইটেম পুনরায় প্রক্রিয়া করার চেষ্টা করতে পারেন।
• Listeners ব্যবহার করে আপনি ব্যাচ প্রসেসের মধ্যে ঘটে যাওয়া ত্রুটির লগ রাখতে পারেন এবং ত্রুটির ভিত্তিতে সঠিক ব্যবস্থা নিতে পারেন।

স্প্রিং ব্যাচের এই ফিচারগুলি ব্যাচ প্রসেসিংকে আরও স্থিতিশীল এবং নির্ভরযোগ্য করে তোলে।

স্প্রিং ব্যাচ (Spring Batch) একটি শক্তিশালী ফ্রেমওয়ার্ক যা ব্যাচ প্রসেসিংয়ের জন্য ব্যবহৃত হয় এবং এতে Exception Handling অত্যন্ত গুরুত্বপূর্ণ। যখন বড় পরিমাণ ডেটা প্রসেস করা হয়, তখন ত্রুটি বা ভুল হতে পারে, যা ব্যাচ প্রক্রিয়াকে ব্যাহত করতে পারে। স্প্রিং ব্যাচে Exception Handling এর জন্য বেশ কিছু কৌশল রয়েছে যা ত্রুটির কারণে ব্যাচ কাজকে স্থগিত বা রোলব্যাক করার প্রক্রিয়া সহজ করে তোলে।

স্প্রিং ব্যাচে ত্রুটি পরিচালনার জন্য বিভিন্ন কৌশল রয়েছে, যেমন Skip Policy, Retry Policy, এবং Custom Exception Handling। এখানে আমরা এগুলোর বিস্তারিত উদাহরণ সহ আলোচনা করব।

১. Skip Policy (Skip Exceptions)

স্প্রিং ব্যাচে Skip Policy ব্যবহার করে আপনি নির্দিষ্ট কিছু ত্রুটি এড়িয়ে যেতে পারেন। অর্থাৎ, যদি কোনো ত্রুটি ঘটে, তাহলে সেগুলো স্কিপ করা যাবে এবং ব্যাচটি পরবর্তী রেকর্ডের জন্য চালু থাকবে।

SkipPolicy কনফিগারেশন

স্প্রিং ব্যাচে SkipPolicy কনফিগার করতে, আপনি SkipListener বা skipLimit ব্যবহার করতে পারেন। skipLimit সেট করলে, আপনি কতগুলো ত্রুটি স্কিপ করতে চান তা নির্ধারণ করতে পারবেন।

উদাহরণ: Skip Policy কনফিগারেশন

import org.springframework.batch.core.step.skip.LimitCheckingItemSkipPolicy;
import org.springframework.batch.item.ItemProcessor;
import org.springframework.batch.item.ItemReader;
import org.springframework.batch.item.ItemWriter;

@Bean
public Step step1() {
    return stepBuilderFactory.get("step1")
        .<User, User>chunk(2)
        .reader(itemReader())
        .processor(new UserItemProcessor())
        .writer(new UserItemWriter())
        .faultTolerant() // Fault tolerance enabled
        .skip(Exception.class) // Skip any Exception
        .skipLimit(5) // Skip up to 5 exceptions
        .build();
}
Copy

এখানে:

• skip(Exception.class): কোনো Exception ঘটলে সেটি স্কিপ করবে।
• skipLimit(5): সর্বাধিক ৫টি ত্রুটি স্কিপ করা যাবে।

SkipListener

যদি আপনি ব্যাচ প্রসেসিংয়ের সময় কোনো রেকর্ড স্কিপ হওয়া নিয়ে বিশেষ লগিং বা অ্যাকশন নিতে চান, তাহলে SkipListener ব্যবহার করতে পারেন।

import org.springframework.batch.core.listener.ItemSkipListenerSupport;
import org.springframework.batch.core.StepExecution;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.listener.JobExecutionListenerSupport;

@Bean
public SkipListener<User, User> skipListener() {
    return new ItemSkipListenerSupport<User, User>() {
        @Override
        public void onSkipInProcess(User item, Throwable t) {
            System.out.println("Skipping item: " + item + " due to: " + t.getMessage());
        }
    };
}
Copy

এখানে, onSkipInProcess মেথডে আপনি স্কিপ হওয়া রেকর্ড এবং ত্রুটির তথ্য লগ করতে পারেন।

২. Retry Policy (Retry on Exception)

Retry Policy ব্যবহার করে আপনি কিছু নির্দিষ্ট ত্রুটি পুনরায় চেষ্টা করতে পারেন। এই কৌশলের মাধ্যমে, নির্দিষ্ট ত্রুটি ঘটলে, ব্যাচ নির্দিষ্ট সংখ্যক বার পুনরায় চেষ্টা করবে।

RetryPolicy কনফিগারেশন

স্প্রিং ব্যাচে RetryPolicy কনফিগার করার জন্য RetryTemplate এবং SimpleRetryPolicy ব্যবহার করা হয়।

import org.springframework.batch.core.step.tasklet.Tasklet;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.retry.policy.SimpleRetryPolicy;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.beans.factory.annotation.Autowired;

@Bean
public Step step1() {
    return stepBuilderFactory.get("step1")
        .<User, User>chunk(10)
        .reader(itemReader())
        .processor(new UserItemProcessor())
        .writer(new UserItemWriter())
        .faultTolerant()
        .retry(Exception.class) // Retry on any Exception
        .retryLimit(3)  // Retry limit set to 3
        .build();
}
Copy

এখানে:

• retry(Exception.class): যদি কোনো Exception ঘটে, তবে তা পুনরায় চেষ্টা করবে।
• retryLimit(3): সর্বাধিক ৩ বার পুনরায় চেষ্টা করা হবে।

Custom Retry Policy

আপনি SimpleRetryPolicy ব্যবহার করে কাস্টমRetryPolicy তৈরি করতে পারেন। নিচে একটি কাস্টম RetryPolicy উদাহরণ দেয়া হলো:

import org.springframework.retry.policy.SimpleRetryPolicy;
import org.springframework.retry.support.RetryTemplate;

@Bean
public RetryTemplate retryTemplate() {
    SimpleRetryPolicy policy = new SimpleRetryPolicy();
    policy.setMaxAttempts(5);  // Maximum 5 attempts

    RetryTemplate retryTemplate = new RetryTemplate();
    retryTemplate.setRetryPolicy(policy);
    return retryTemplate;
}
Copy

এখানে, কাস্টম RetryPolicy তৈরি করা হয়েছে যা ৫ বার পর্যন্ত পুনরায় চেষ্টা করবে।

৩. Custom Exception Handling

স্প্রিং ব্যাচে Custom Exception Handling কাস্টম ব্যাচ প্রসেসিংয়ের জন্য একটি গুরুত্বপূর্ণ কৌশল। আপনি ব্যাচ কাজের সময় নির্দিষ্ট ত্রুটিগুলিকে কাস্টমভাবে হ্যান্ডল করতে পারেন। এর জন্য আপনি SkipListener, RetryListener, এবং ItemProcessor ব্যবহার করতে পারেন।

ItemProcessor ত্রুটি Handling

আপনি ItemProcessor ক্লাসে ত্রুটি হ্যান্ডলিং করতে পারেন। উদাহরণস্বরূপ, যদি কোনো ডেটা নাল হয়, তবে আপনি একটি কাস্টম এক্সেপশন তৈরি করে তা ফেলে দিতে পারেন।

import org.springframework.batch.item.ItemProcessor;

public class UserItemProcessor implements ItemProcessor<User, User> {

    @Override
    public User process(User user) throws Exception {
        if (user.getName() == null) {
            throw new CustomException("Name is missing");
        }
        return user;
    }
}
Copy

এখানে, যদি User অবজেক্টের name ফিল্ড নাল থাকে, তবে CustomException ফেলে দেওয়া হবে।

CustomException Class

public class CustomException extends Exception {
    public CustomException(String message) {
        super(message);
    }
}
Copy

এই কাস্টম এক্সেপশনটি ব্যাচ প্রসেসিংয়ের সময় নির্দিষ্ট ধরনের ত্রুটি হ্যান্ডলিং করতে ব্যবহার করা হবে।

৪. ব্যাচের ফলাফল লগিং (Logging Batch Execution Results)

স্প্রিং ব্যাচের মাধ্যমে আপনি ব্যাচের বিভিন্ন স্টেপের ফলাফল লগ করতে পারেন এবং বিভিন্ন ত্রুটি বা ব্যতিক্রমের ক্ষেত্রে এগুলোর প্রতি মনিটরিং করতে পারেন।

Batch Job Execution Listener

import org.springframework.batch.core.listener.JobExecutionListenerSupport;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobExecutionException;

@Bean
public JobExecutionListenerSupport listener() {
    return new JobExecutionListenerSupport() {
        @Override
        public void afterJob(JobExecution jobExecution) {
            if (jobExecution.getStatus().isUnsuccessful()) {
                System.out.println("Job failed with exception: " + jobExecution.getAllFailureExceptions());
            }
        }
    };
}
Copy

এখানে, JobExecutionListenerSupport ব্যবহার করে আমরা ব্যাচ কাজ শেষ হওয়ার পর ত্রুটি লগ করতে পারি।

সারাংশ

স্প্রিং ব্যাচে Exception Handling অত্যন্ত গুরুত্বপূর্ণ এবং এর জন্য কিছু শক্তিশালী কৌশল রয়েছে:

• Skip Policy: ত্রুটি হলে রেকর্ড স্কিপ করা।
• Retry Policy: নির্দিষ্ট ত্রুটির জন্য পুনরায় চেষ্টা করা।
• Custom Exception Handling: কাস্টম ত্রুটি হ্যান্ডলিং তৈরি করা।

এগুলো ব্যবহার করে আপনি ব্যাচ প্রসেসিংয়ের ক্ষেত্রে ত্রুটি হ্যান্ডলিং আরও কার্যকরী এবং নির্ভরযোগ্য করতে পারেন।

Spring Batch একটি শক্তিশালী ব্যাচ প্রসেসিং ফ্রেমওয়ার্ক যা বড় ডেটাসেট প্রক্রিয়া করতে ব্যবহৃত হয়। ব্যাচ প্রসেসিং এ কোনো কোনো ক্ষেত্রে ডাটা প্রসেসিংয়ে সমস্যা হতে পারে (যেমন ফাইলের ভুল ডাটা, ডাটাবেস কনফিগারেশন সমস্যা ইত্যাদি)। এর ফলে পুরো ব্যাচ জব ব্যর্থ হতে পারে। এই ধরনের পরিস্থিতি মোকাবেলা করার জন্য Spring Batch এ Skip Policy এবং Retry Policy প্রদান করা হয়।

• Skip Policy: কোনো নির্দিষ্ট শর্তে একটি আইটেম প্রক্রিয়ার সময় যদি কোনো ত্রুটি ঘটে, তবে সেই আইটেমটি বাদ দেওয়া (skip) যাবে, এবং বাকি আইটেমগুলো প্রক্রিয়া হতে থাকবে।
• Retry Policy: যদি কোনো আইটেম প্রক্রিয়ার সময় ত্রুটি ঘটে, তবে ত্রুটিটি কয়েকবার পুনরায় চেষ্টা করা (retry) হবে, যতক্ষণ না তা সফল হয়।

Spring Batch এ Skip Policy এবং Retry Policy এর মাধ্যমে আমরা ব্যাচ প্রক্রিয়ার নির্ভরযোগ্যতা এবং স্থায়িত্ব বৃদ্ধি করতে পারি।

Skip Policy

Skip Policy এমন একটি কৌশল যা কোনো নির্দিষ্ট ত্রুটির কারণে আইটেমটি প্রক্রিয়া করার সময় সমস্যা এলে, সেই আইটেমটি বাদ (skip) করে দেয় এবং প্রক্রিয়া অব্যাহত রাখে। এটি সাধারণত তখন ব্যবহার করা হয় যখন আইটেমটি কোনো কারণে প্রক্রিয়া করা সম্ভব না হয় (যেমন ডাটাবেসের নির্দিষ্ট রেকর্ড পাওয়া যায়নি)।

Skip Policy কনফিগারেশন

Spring Batch এ SkipPolicy কনফিগার করতে হলে আপনি SkipPolicy এবং skipLimit সেট করতে পারেন। এটি ItemProcessor বা ItemReader এ ব্যবহার করতে পারেন।

উদাহরণ ১: SkipPolicy কনফিগারেশন

package com.example.demo;

import org.springframework.batch.core.Step;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.core.step.skip.SkipPolicy;
import org.springframework.batch.core.step.skip.LimitSkippedItemCountException;
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 SkipPolicy skipPolicy() {
        return (throwable, skipCount) -> {
            // Example: Skip the item if it exceeds 5 retries
            return skipCount <= 5;
        };
    }

    @Bean
    public Step step1(StepBuilderFactory stepBuilderFactory, 
                      ItemReader<String> reader, 
                      ItemProcessor<String, String> processor, 
                      ItemWriter<String> writer, 
                      SkipPolicy skipPolicy) {
        return stepBuilderFactory.get("step1")
                .<String, String>chunk(10)
                .reader(reader)
                .processor(processor)
                .writer(writer)
                .faultTolerant() // Enable fault tolerance
                .skip(Exception.class) // Skip specific exceptions
                .skipLimit(5) // Skip up to 5 exceptions
                .skipPolicy(skipPolicy) // Set the custom skip policy
                .build();
    }
}
Copy

এখানে, skipPolicy() মেথডটি একটি কাস্টম SkipPolicy প্রদান করে যা নির্দিষ্ট ত্রুটির জন্য ৫টি আইটেম পর্যন্ত সঠিকভাবে প্রক্রিয়া না হলে সেগুলো বাদ (skip) করতে বলে।

• skip(Exception.class): কোন ধরনের ত্রুটি ঘটলে সেই ত্রুটি জন্য skip করতে বলা হয়।
• skipLimit(5): ৫টি ত্রুটি পরবর্তী সময়ে সেগুলো skip হবে।

উদাহরণ ২: SkipPolicy কাস্টমাইজেশন

package com.example.demo;

import org.springframework.batch.core.step.skip.SkipPolicy;
import org.springframework.batch.core.step.skip.LimitSkippedItemCountException;
import org.springframework.stereotype.Component;

@Component
public class CustomSkipPolicy implements SkipPolicy {

    @Override
    public boolean shouldSkip(Throwable throwable, int skipCount) throws LimitSkippedItemCountException {
        // Skip only certain exceptions like DataAccessException
        if (throwable instanceof SomeSpecificException) {
            return true;
        }
        return skipCount < 3; // Skip up to 3 times for other exceptions
    }
}
Copy

এখানে CustomSkipPolicy তে নির্দিষ্ট ধরনের ত্রুটি (যেমন SomeSpecificException) পাওয়ার পরে সেটি skip করতে বলা হয়েছে। অন্য ত্রুটির জন্য ৩টি পর্যন্ত retry করার সুযোগ দেওয়া হচ্ছে।

Retry Policy

Retry Policy একটি কৌশল যা কোনো আইটেম প্রক্রিয়ার সময় ত্রুটি হলে, সেটি পুনরায় চেষ্টা করতে (retry) সাহায্য করে। যখন কোনো আইটেমে ত্রুটি ঘটে, তখন RetryTemplate ব্যবহার করে আইটেমটি পুনরায় প্রক্রিয়া করার চেষ্টা করা হয়। Spring Batch এ আপনি retry এর জন্য কাস্টম RetryPolicy তৈরি করতে পারেন।

Retry Policy কনফিগারেশন

Spring Batch এ RetryPolicy কনফিগার করার জন্য RetryTemplate ব্যবহার করা হয় এবং এতে retry এর সংখ্যা এবং শর্ত নির্ধারণ করা হয়।

উদাহরণ ১: RetryPolicy কনফিগারেশন

package com.example.demo;

import org.springframework.batch.core.Step;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.core.step.tasklet.Tasklet;
import org.springframework.batch.core.step.tasklet.TaskletStep;
import org.springframework.batch.core.retry.policy.SimpleRetryPolicy;
import org.springframework.batch.core.retry.support.RetryTemplate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class BatchConfig {

    @Bean
    public RetryTemplate retryTemplate() {
        RetryTemplate retryTemplate = new RetryTemplate();
        SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy();
        retryPolicy.setMaxAttempts(3); // Retry up to 3 times
        retryTemplate.setRetryPolicy(retryPolicy);
        return retryTemplate;
    }

    @Bean
    public Step retryStep(StepBuilderFactory stepBuilderFactory, Tasklet tasklet, RetryTemplate retryTemplate) {
        TaskletStep step = stepBuilderFactory.get("retryStep")
                .tasklet(tasklet)
                .retryLimit(3) // Retry 3 times
                .retryPolicy(retryTemplate.getRetryPolicy()) // Attach retry policy
                .build();
        return step;
    }
}
Copy

এখানে, RetryTemplate ব্যবহৃত হচ্ছে যা SimpleRetryPolicy সেট করে, যার মাধ্যমে ৩ বার পর্যন্ত পুনরায় চেষ্টা (retry) করা হবে।

উদাহরণ ২: RetryPolicy কাস্টমাইজেশন

package com.example.demo;

import org.springframework.batch.core.retry.policy.RetryPolicy;
import org.springframework.batch.core.retry.policy.SimpleRetryPolicy;
import org.springframework.stereotype.Component;

@Component
public class CustomRetryPolicy extends SimpleRetryPolicy {

    @Override
    public boolean canRetry(Throwable throwable) {
        if (throwable instanceof SomeSpecificException) {
            return true; // Retry on specific exception
        }
        return super.canRetry(throwable); // Default retry policy
    }
}
Copy

এখানে CustomRetryPolicy ব্যবহার করে নির্দিষ্ট একটি ত্রুটির জন্য পুনরায় চেষ্টা করা হচ্ছে। যদি এটি অন্য ত্রুটি হয়, তাহলে ডিফল্ট রিটার্ন কন্ডিশন অনুযায়ী কাজ করবে।

Skip Policy এবং Retry Policy এর সুবিধা

• Fault Tolerance: ব্যাচ প্রসেসিংয়ে ত্রুটি হওয়া সত্ত্বেও প্রসেসিং অব্যাহত রাখা সম্ভব হয়।
• Reliability: ব্যাচ প্রক্রিয়া আরও নির্ভরযোগ্য হয় কারণ আপনি Skip বা Retry পলিসি ব্যবহার করে সঠিকভাবে ডাটা প্রসেস করতে পারেন।
• Customization: আপনার প্রক্রিয়া অনুযায়ী আপনি Skip বা Retry পলিসি কাস্টমাইজ করতে পারেন, যেমন নির্দিষ্ট ত্রুটি, retry সংখ্যা, এবং skip এর সীমা নির্ধারণ করা।

সারাংশ

Spring Batch এ Skip Policy এবং Retry Policy ব্যবহারের মাধ্যমে আপনি ব্যাচ প্রসেসিংয়ের নির্ভরযোগ্যতা ও স্থায়িত্ব বৃদ্ধি করতে পারেন। Skip Policy ত্রুটি ঘটলে আইটেমটি বাদ দেয় এবং বাকি আইটেমগুলি প্রসেস করতে থাকে, আর Retry Policy ত্রুটি ঘটলে পুনরায় চেষ্টা করতে দেয়। এই পলিসিগুলি ব্যাচ প্রক্রিয়াকে আরও স্থিতিশীল এবং ত্রুটি সুরক্ষিত করে তোলে।

Spring Batch তে Exception Handling একটি গুরুত্বপূর্ণ দিক, কারণ ব্যাচ প্রসেসিংয়ে ডেটা প্রক্রিয়া করার সময় বিভিন্ন ধরনের সমস্যা হতে পারে যেমন: ডেটা ফরম্যাটের ভুল, ইনপুট ফাইলের অভাব, ডেটাবেস কানেকশন ইস্যু ইত্যাদি। Spring Batch আপনাকে custom exception handling করার সুযোগ দেয়, যাতে আপনি এই ধরনের ত্রুটিগুলো ঠিকভাবে মোকাবিলা করতে পারেন এবং ব্যাচ প্রসেসিং চলাকালীন ব্যর্থতার জন্য কাস্টম সমাধান প্রদান করতে পারেন।

এখানে Custom Exception Handling এর একটি উদাহরণ দেওয়া হচ্ছে যেখানে Spring Batch কাজ করার সময় ItemProcessor বা ItemReader তে ত্রুটি সনাক্ত হলে কাস্টম এক্সেপশন তৈরি করা হবে এবং এর মাধ্যমে সেই ত্রুটি সঠিকভাবে হ্যান্ডেল করা হবে।

1. Custom Exception Class তৈরি করা

প্রথমে একটি কাস্টম এক্সেপশন ক্লাস তৈরি করতে হবে যা ব্যাচ প্রসেসিংয়ের সময় যে কোনো ত্রুটি ঘটলে তা কাস্টমাইজড তথ্য প্রদান করবে।

public class CustomBatchException extends RuntimeException {
    public CustomBatchException(String message) {
        super(message);
    }

    public CustomBatchException(String message, Throwable cause) {
        super(message, cause);
    }
}
Copy

এই CustomBatchException ক্লাসটি একটি কাস্টম RuntimeException যা ব্যাচ প্রসেসিংয়ের সময় ত্রুটি ঘটলে ব্যবহার করা হবে।

2. ItemProcessor বা ItemReader তে Custom Exception Handling

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

Example: ItemProcessor তে Custom Exception Handling

public class MyItemProcessor implements ItemProcessor<MyItem, MyProcessedItem> {

    @Override
    public MyProcessedItem process(MyItem item) throws Exception {
        try {
            // কিছু প্রক্রিয়া
            if (item.getValue() < 0) {
                // যদি কোনো অস্বাভাবিক ডেটা পাওয়া যায়, তাহলে কাস্টম এক্সেপশন ছোড়া হবে
                throw new CustomBatchException("Invalid value found in item: " + item);
            }

            // যদি সবকিছু ঠিক থাকে, তাহলে প্রক্রিয়া করা আইটেম রিটার্ন করা হবে
            return new MyProcessedItem(item.getValue() * 2);  // উদাহরণস্বরূপ মান বৃদ্ধি করা
        } catch (Exception e) {
            // এক্সেপশন হ্যান্ডলিং
            throw new CustomBatchException("Error processing item: " + item, e);
        }
    }
}
Copy

এখানে, MyItemProcessor ক্লাসে আমরা চেক করছি যদি ইনপুট item.getValue() নেগেটিভ হয়, তাহলে একটি কাস্টম এক্সেপশন CustomBatchException ছোড়া হচ্ছে।

Example: ItemReader তে Custom Exception Handling

public class MyItemReader implements ItemReader<MyItem> {

    @Override
    public MyItem read() throws Exception {
        try {
            MyItem item = fetchItemFromDataSource();  // ডেটা সোর্স থেকে আইটেম পড়া

            if (item == null) {
                // যদি আইটেম না পাওয়া যায়, তাহলে কাস্টম এক্সেপশন ছোড়া হবে
                throw new CustomBatchException("No valid item found in the data source.");
            }

            return item;
        } catch (Exception e) {
            throw new CustomBatchException("Error reading item from data source", e);
        }
    }
}
Copy

এখানে, MyItemReader ক্লাসে, আমরা ডেটা সোর্স থেকে একটি আইটেম পড়ছি, কিন্তু যদি কোনো আইটেম পাওয়া না যায় বা কোনো সমস্যা ঘটে, তখন কাস্টম এক্সেপশন ছোড়া হবে।

3. Step Listener ব্যবহার করে Exception Handling

Spring Batch-এ ItemProcessor, ItemReader বা অন্যান্য প্রসেসিং কম্পোনেন্টগুলোর মধ্যে ঘটে যাওয়া ত্রুটি মোকাবিলা করার জন্য Step Listener ব্যবহার করা যেতে পারে। StepExecutionListener একটি ইন্টারফেস যা beforeStep() এবং afterStep() মেথড দিয়ে Step-এর আগে এবং পরে কিছু কার্যক্রম করতে সাহায্য করে, এবং ত্রুটি ঘটলে এর মাধ্যমে কাস্টম এক্সেপশন হ্যান্ডলিং করা যায়।

@Component
public class CustomStepListener implements StepExecutionListener {

    @Override
    public void beforeStep(StepExecution stepExecution) {
        // Step শুরু হওয়ার আগে কোনো কার্যকলাপ করা যেতে পারে
        System.out.println("Starting step: " + stepExecution.getStepName());
    }

    @Override
    public ExitStatus afterStep(StepExecution stepExecution) {
        // Step শেষ হওয়ার পরে ত্রুটি থাকলে কাস্টম এক্সেপশন হ্যান্ডলিং
        if (stepExecution.getStatus() == BatchStatus.FAILED) {
            Throwable exception = stepExecution.getFailureExceptions().get(0);
            if (exception instanceof CustomBatchException) {
                System.err.println("Custom Exception occurred: " + exception.getMessage());
            }
        }
        return null;
    }
}
Copy

এখানে, CustomStepListener ক্লাসে afterStep মেথডে, যদি Step এর execution ব্যর্থ হয় এবং কাস্টম এক্সেপশন ঘটে, তখন তা লোগ করা হচ্ছে।

4. Job Configuration এ Listener যোগ করা

এখন, আমরা Step বা Job কনফিগারেশনে Listener যোগ করতে পারি, যাতে Exception Handling সঠিকভাবে কাজ করে।

@Bean
public Job job(JobBuilderFactory jobBuilderFactory, StepBuilderFactory stepBuilderFactory,
               CustomStepListener listener) {
    return jobBuilderFactory.get("myJob")
            .start(step1())
            .listener(listener)  // Listener যোগ করা
            .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();
}
Copy

এখানে, CustomStepListener কে Step-এ যোগ করা হয়েছে, যা Step-এর শেষ হওয়ার পরে কাস্টম এক্সেপশন হ্যান্ডলিং করতে সাহায্য করবে।

সারাংশ

Spring Batch-এ Custom Exception Handling একটি গুরুত্বপূর্ণ প্রক্রিয়া যা ব্যাচ প্রসেসিংয়ের সময় ত্রুটি সনাক্ত এবং সঠিকভাবে মোকাবিলা করতে সাহায্য করে। আপনি কাস্টম এক্সেপশন তৈরি করে ব্যাচ প্রসেসিংয়ের মধ্যে বিভিন্ন কাজের জন্য ত্রুটি পরিচালনা করতে পারেন, যেমন ItemReader, ItemProcessor, এবং ItemWriter-এ ত্রুটি হ্যান্ডলিং। Step Listener এবং Job Listener ব্যবহার করে আপনি Step এবং Job এর কার্যক্রমের সময়ে ত্রুটি হ্যান্ডলিং করতে পারেন। এটি ব্যাচ প্রসেসিংয়ে দ্রুত এবং কার্যকরী ত্রুটি মোকাবিলা নিশ্চিত করে।

Spring Batch একটি শক্তিশালী ফ্রেমওয়ার্ক যা বড় ডেটাসেটের ব্যাচ প্রসেসিংয়ের জন্য ব্যবহৃত হয়। তবে, যেহেতু ব্যাচ প্রক্রিয়াগুলিতে অনেক সময় ডেটা ট্রান্সফরমেশন, ডেটা রিডিং এবং রাইটিংয়ের মধ্যে ব্যতিক্রমী অবস্থা (exception) ঘটতে পারে, তাই Spring Batch এ Exception Handling খুবই গুরুত্বপূর্ণ।

Spring Batch এর মধ্যে বিভিন্ন ধরনের exception handling কৌশল রয়েছে, যা ব্যাচ প্রক্রিয়া চলাকালে ঘটতে থাকা ত্রুটিগুলো সঠিকভাবে মোকাবেলা করতে সাহায্য করে। সাধারণত, Step এবং Job এর মধ্যে exception handling এর কৌশলগুলি ব্যবহৃত হয়। Spring Batch এ exception handling-এর জন্য SkipPolicy, RetryPolicy, এবং Fault Tolerance (ত্রুটি সহনশীলতা) ব্যবহৃত হতে পারে।

Spring Batch Exception Handling: উদাহরণ সহ

১. SkipPolicy ব্যবহার করে Exception Handling

Spring Batch এ SkipPolicy ব্যবহার করা হয় যা ডেটা প্রসেসিংয়ের সময় কোনো নির্দিষ্ট exception ঘটলে সেই exception গুলি বাদ (skip) করার জন্য ব্যবহার করা হয়। এর মাধ্যমে আপনি নির্দিষ্ট exception গুলি অগ্রাহ্য করতে পারেন এবং অন্য আইটেমগুলো প্রসেস চালিয়ে যেতে পারেন।

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

1. ItemProcessor তে exception handling এর জন্য SkipPolicy প্রয়োগ করা হয়।
2. SkipPolicy ব্যবহার করার জন্য Spring Batch Step কনফিগারেশনে faultTolerant().skip() মেথড ব্যবহার করা হয়।

উদাহরণ:

ধরা যাক, একটি ItemProcessor রয়েছে যেখানে কিছু ডেটা প্রক্রিয়াকরণের সময় NumberFormatException বা NullPointerException হতে পারে। এই ক্ষেত্রে আমরা SkipPolicy ব্যবহার করব যা শুধুমাত্র নির্দিষ্ট exception গুলি skip করবে।

@Bean
public Step step1() {
    return stepBuilderFactory.get("step1")
            .<Person, Person> chunk(10)
            .reader(personReader())
            .processor(personProcessor())
            .writer(personWriter())
            .faultTolerant()
            .skip(NumberFormatException.class)  // NumberFormatException ঘটলে, ঐ আইটেমটি স্কিপ হবে
            .skipLimit(5)  // সর্বাধিক 5টি আইটেম স্কিপ করা যাবে
            .build();
}

@Bean
public ItemProcessor<Person, Person> personProcessor() {
    return new ItemProcessor<Person, Person>() {
        @Override
        public Person process(Person person) throws Exception {
            if (person.getAge() < 0) {
                throw new NumberFormatException("Invalid age value: " + person.getAge());  // যদি বয়স নেতিবাচক হয়, ত্রুটি ঘটবে
            }
            return person;
        }
    };
}
Copy

ব্যাখ্যা:

• skip(NumberFormatException.class): এই লাইনটি নির্দিষ্ট করে যে NumberFormatException ঘটলে ঐ আইটেমটি স্কিপ করা হবে এবং প্রসেসিং চালিয়ে যাওয়া হবে।
• skipLimit(5): সর্বাধিক 5টি আইটেম স্কিপ করা যাবে, এর বেশি হলে পুরো ব্যাচ প্রক্রিয়া ব্যর্থ হবে।

২. RetryPolicy ব্যবহার করে Exception Handling

RetryPolicy ব্যবহার করে আমরা কোনো নির্দিষ্ট exception ঘটলে সেই exception পুনরায় retry করতে পারি। Spring Batch এর @Retryable অ্যানোটেশন বা retry() মেথড ব্যবহার করে retry কৌশল প্রয়োগ করা হয়। এটি ত্রুটি ঘটলে একাধিক বার একটি নির্দিষ্ট কাজ করার জন্য ব্যবহৃত হয়।

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

@Bean
public Step step2() {
    return stepBuilderFactory.get("step2")
            .<Person, Person> chunk(10)
            .reader(personReader())
            .processor(personProcessor())
            .writer(personWriter())
            .faultTolerant()
            .retry(Exception.class)  // কোনো exception ঘটলে retry করা হবে
            .retryLimit(3)  // 3 বার retry হবে
            .build();
}
Copy

ব্যাখ্যা:

• retry(Exception.class): কোন exception ঘটলে এটি retry করবে।
• retryLimit(3): সর্বাধিক 3 বার retry করা হবে, এর পরে ব্যাচ প্রক্রিয়া ব্যর্থ হবে।

৩. Exception Handling in ItemWriter

Spring Batch এ ItemWriter এর মধ্যেও exception handling করা সম্ভব, যেখানে ডেটা রাইটিংয়ের সময় কোনো ত্রুটি ঘটলে সেটি ক্যাচ এবং প্রক্রিয়া করা হয়। উদাহরণস্বরূপ, যদি ফাইল লেখার সময় কোনো সমস্যা হয়, তবে exception handling ব্যবহার করে আমরা সেই সমস্যা মোকাবেলা করতে পারি।

উদাহরণ:

@Bean
public ItemWriter<Person> personWriter() {
    return new ItemWriter<Person>() {
        @Override
        public void write(List<? extends Person> items) throws Exception {
            try {
                // Write items to the database or file
                for (Person person : items) {
                    // Some operation, e.g., writing to a file
                    if (person.getName() == null) {
                        throw new Exception("Name is null");  // Example exception
                    }
                    System.out.println("Writing person: " + person.getName());
                }
            } catch (Exception e) {
                // Log or handle exception as needed
                System.out.println("Error writing items: " + e.getMessage());
                throw e;  // Rethrow exception if needed
            }
        }
    };
}
Copy

এখানে, যদি person.getName() null থাকে, তবে একটি exception হবে এবং সেই exception ক্যাচ করে আমরা উপযুক্ত বার্তা লগ করতে পারব।

৪. Step Level Exception Handling

Spring Batch এ Step এর মধ্যে exception handling করা যায় যাতে পুরো Step চালানোর সময় কোনো ত্রুটি ঘটলে সেগুলো সঠিকভাবে মোকাবেলা করা যায়।

উদাহরণ:

@Bean
public Step step3() {
    return stepBuilderFactory.get("step3")
            .<Person, Person> chunk(10)
            .reader(personReader())
            .processor(personProcessor())
            .writer(personWriter())
            .listener(new StepExecutionListener() {
                @Override
                public void beforeStep(StepExecution stepExecution) {
                    // Step শুরু হওয়ার আগে কিছু কাজ করা যাবে
                }

                @Override
                public ExitStatus afterStep(StepExecution stepExecution) {
                    if (stepExecution.getExitStatus().equals(ExitStatus.FAILED)) {
                        // Error Handling: Step ব্যর্থ হলে
                        System.out.println("Step failed with error: " + stepExecution.getFailureExceptions());
                    }
                    return null;
                }
            })
            .build();
}
Copy

এখানে, afterStep মেথডের মধ্যে আপনি Step এর ফলাফল চেক করতে পারেন এবং যদি Step ব্যর্থ হয়, তাহলে সেই error গুলো লগ করতে পারেন।

সারাংশ

Spring Batch এ exception handling খুবই গুরুত্বপূর্ণ, বিশেষ করে ব্যাচ প্রসেসিংয়ের সময় যখন ডেটা রিডিং, প্রসেসিং, বা রাইটিংয়ে ত্রুটি ঘটতে পারে। SkipPolicy এবং RetryPolicy এর মাধ্যমে আমরা নির্দিষ্ট exception গুলি skip করতে বা retry করতে পারি, যা ব্যাচ প্রক্রিয়ার নিরবচ্ছিন্ন চলমানতা নিশ্চিত করে। এছাড়া, ItemWriter এবং Step এর মধ্যে exception handling প্রক্রিয়াগুলি ব্যবহৃত হয়, যা ব্যাচ প্রক্রিয়ার বিভিন্ন ধাপে ত্রুটি মোকাবেলায় সহায়তা করে। Spring Batch এর exception handling কৌশলগুলো ব্যাচ প্রসেসিংয়ের কার্যকারিতা এবং নির্ভরযোগ্যতা বাড়াতে সাহায্য করে।