Spring Boot 4 की संपूर्ण मार्गदर्शिका · पाठ

जॉब, चरण और JobRepository मॉडल

निष्पादन ट्रैकिंग के लिए जॉब, चरण और मेटाडेटा स्थायित्व से बैच कार्यभार की संरचना कीजिए।

पाठ 1, कुल 4 में से13 चरण

जॉब, चरण और JobRepository मॉडल, CoddyKit पर Spring Boot 4 की संपूर्ण मार्गदर्शिका का एक निःशुल्क पाठ है। यह 4 में से 1वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह Spring Boot 4 की संपूर्ण मार्गदर्शिका सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Spring Boot 4 की संपूर्ण मार्गदर्शिका पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

Spring Batch की आवश्यकता क्यों है

वास्तविक दुनिया के कई कार्य अनुरोध/प्रतिक्रिया वाले नहीं होते: रात में चालान बनाना, CSV आयात, रिपोर्ट निर्यात और डेटा स्थानांतरण। ये बड़े रिकॉर्ड-समूहों को संसाधित करने वाले बैच कार्य के रूप में चलते हैं।

क्रैश के बाद इन्हें फिर से शुरू करने योग्य होना चाहिए।
इन्हें प्रगति दर्ज करनी चाहिए, ताकि आपको पता रहे कि क्या पहले ही चल चुका है।
इन्हें सब कुछ मेमोरी में लोड किए बिना लाखों पंक्तियों को संभालना चाहिए।

Spring Batch इसके लिए आपको एक सुव्यवस्थित मॉडल देता है। सबसे पहले जिन तीन मूल अमूर्त अवधारणाओं को समझना आवश्यक है, वे हैं Job, Step और JobRepository।

Job: कार्य की एक इकाई

Job पूरे बैच प्रक्रम के लिए शीर्ष-स्तरीय कंटेनर है। इसका एक नाम होता है और यह एक या अधिक क्रमबद्ध Step इंस्टेंस से बना होता है।

एक Job परिभाषा को कई बार चलाया जा सकता है — प्रत्येक रन एक JobInstance होता है।
किसी JobInstance को चलाने का प्रत्येक प्रयास एक JobExecution होता है (स्थिति, प्रारंभ समय और निकास कोड के साथ)।

Spring Boot 4 में आप नाम और JobRepository देकर JobBuilder से एक Job बनाते हैं।

@Bean
public Job importInvoicesJob(JobRepository jobRepository, Step readStep) {
    return new JobBuilder("importInvoicesJob", jobRepository)
            .start(readStep)
            .build();
}

JobInstance और JobExecution में अंतर

पुनःआरंभ करने की क्षमता का आधार यही अंतर है। मान लीजिए कि आप importInvoicesJob को 2026-06-10 तारीख के लिए चलाते हैं।

JobInstance की पहचान जॉब के नाम और उसके पहचान निर्धारित करने वाले जॉब पैरामीटरों से होती है (यहाँ तारीख से)। उसी तारीख के साथ दोबारा चलाने पर वही इंस्टेंस संदर्भित होता है।
हर रन एक नया JobExecution बनाता है। यदि पहला प्रयास विफल हो जाए और आप उसे फिर से शुरू करें, तो उसी JobInstance के लिए दूसरा JobExecution मिलता है।

पूरा हो चुका JobInstance उन्हीं पहचान निर्धारित करने वाले पैरामीटरों के साथ दोबारा नहीं चलाया जा सकता — Spring Batch JobInstanceAlreadyCompleteException उत्पन्न करता है। इससे गलती से दोबारा प्रसंस्करण होने से बचता है।

Step: Job का एक चरण

Step, Job का एक स्वतंत्र और क्रमिक चरण होता है। कोई Job आम तौर पर कई चरणों को क्रम से चलाता है: इनपुट की जाँच करना, फिर रिकॉर्ड संसाधित करना और अंत में सारांश ईमेल भेजना।

Step दो प्रकार के होते हैं:

Chunk-oriented: कॉन्फ़िगर किए जा सकने वाले समूहों में पढ़ना–संसाधित करना–लिखना। बड़े डेटा-समूहों के लिए आदर्श।
Tasklet: एक अकेली मनमानी कार्रवाई (किसी फ़ाइल को हटाना, संग्रहीत प्रक्रिया चलाना या किसी सेवा को पिंग करना)।

हर Step रन को एक StepExecution दर्ज करता है, जिसमें पढ़ने/लिखने की संख्या, कमिट की संख्या और स्थिति रहती है।

Chunk-अनुरूप Step

Chunk-अनुरूप Step में ItemReader, वैकल्पिक ItemProcessor और ItemWriter को एक साथ जोड़ा जाता है। chunk(n, transactionManager) कॉल कमिट अंतराल तय करती है: प्रत्येक n आइटम पढ़े और संसाधित किए जाने के बाद writer डेटा लिखता है और लेन-देन कमिट होता है।

छोटे chunks का अर्थ है अधिक बार कमिट (पुनःआरंभ का अधिक सुरक्षित बिंदु, लेकिन अधिक अतिरिक्त लागत); बड़े chunks का अर्थ है कम कमिट (तेज़, लेकिन रोलबैक होने पर अधिक काम खो सकता है)।

@Bean
public Step readStep(JobRepository jobRepository,
                     PlatformTransactionManager txManager,
                     ItemReader<Invoice> reader,
                     ItemProcessor<Invoice, Invoice> processor,
                     ItemWriter<Invoice> writer) {
    return new StepBuilder("readStep", jobRepository)
            .<Invoice, Invoice>chunk(100, txManager)
            .reader(reader)
            .processor(processor)
            .writer(writer)
            .build();
}

Tasklet Step

जब कोई चरण आइटमों की धारा के बजाय एक अकेली कार्रवाई हो, तब Tasklet का उपयोग करें। पूरा होने पर execute विधि RepeatStatus.FINISHED लौटाती है, या दोबारा चलाए जाने के लिए CONTINUABLE लौटाती है।

Tasklet, संसाधित फ़ाइल को संग्रहित करने या अस्थायी तालिका को खाली करने जैसे तैयारी/सफ़ाई चरणों के लिए बिल्कुल उपयुक्त हैं।

@Bean
public Step cleanupStep(JobRepository jobRepository,
                        PlatformTransactionManager txManager) {
    return new StepBuilder("cleanupStep", jobRepository)
            .tasklet((contribution, chunkContext) -> {
                Path staging = Path.of("/data/staging.csv");
                Files.deleteIfExists(staging);
                return RepeatStatus.FINISHED;
            }, txManager)
            .build();
}

Steps को Job में संयोजित करना

Steps उसी क्रम में चलते हैं जिस क्रम में आप उन्हें घोषित करते हैं। पहले Step के लिए start(...) और बाकी को जोड़ने के लिए next(...) का उपयोग करें। डिफ़ॉल्ट रूप से, यदि किसी Step की स्थिति FAILED हो, तो Job रुक जाता है।

यहाँ job जाँच करता है, फिर आयात करता है और अंत में सफ़ाई करता है। यदि आयात वाला Step विफल हो जाता है, तो cleanupStep नहीं चलता और दोबारा शुरू करने पर job विफल Step से आगे जारी रहता है।

@Bean
public Job invoiceJob(JobRepository jobRepository,
                      Step validateStep, Step readStep, Step cleanupStep) {
    return new JobBuilder("invoiceJob", jobRepository)
            .start(validateStep)
            .next(readStep)
            .next(cleanupStep)
            .build();
}

JobRepository: स्थायी स्मृति

JobRepository वह घटक है जो सभी बैच मेटाडेटा को स्थायी रूप से संग्रहीत करता है: कौन-से JobInstances मौजूद हैं, उनके JobExecutions, प्रत्येक StepExecution और निष्पादन संदर्भ।

इसी के माध्यम से Spring Batch जानता है कि कोई job पहले ही पूरा हो चुका है।
इसी के माध्यम से पुनःआरंभ यह तय करता है कि कहाँ से आगे बढ़ना है।
यह निगरानी के लिए पढ़ने/लिखने/कमिट की संख्याएँ संग्रहीत करता है।

डिफ़ॉल्ट रूप से यह BATCH_* तालिकाओं के एक समूह का उपयोग करके संबंधपरक डेटाबेस में लिखता है। कार्यशील JobRepository के बिना न तो पुनःआरंभ की सुविधा होती है और न ही निष्पादन इतिहास — यह वैकल्पिक नहीं है।

BATCH_ मेटाडेटा तालिकाएँ

JobRepository एक निश्चित स्कीमा में डेटा स्थायी रूप से रखता है। मुख्य तालिकाएँ हैं:

BATCH_JOB_INSTANCE — प्रत्येक JobInstance के लिए एक पंक्ति (नाम + पहचान हैश)।
BATCH_JOB_EXECUTION — प्रत्येक रन प्रयास के लिए एक पंक्ति, जिसमें स्थिति और निकास कोड होता है।
BATCH_STEP_EXECUTION — प्रत्येक Step के काउंटर (पढ़ने/लिखने/छोड़ने की संख्याएँ)।
BATCH_JOB_EXECUTION_CONTEXT / BATCH_STEP_EXECUTION_CONTEXT — आगे जारी रखने के लिए उपयोग की जाने वाली क्रमबद्ध स्थिति।
BATCH_*_SEQ — प्राथमिक कुंजियों के लिए अनुक्रम।

Spring Boot में DDL शामिल होता है और वह इन्हें अपने-आप बना सकता है। नीचे दी गई प्रॉपर्टी स्टार्टअप पर स्कीमा शुरू करती है।

# application.properties
spring.batch.jdbc.initialize-schema=always
# Prevent jobs from auto-running on app startup
spring.batch.job.enabled=false

Job शुरू करना

आप JobParameters देकर JobLauncher के माध्यम से कोई Job चलाते हैं। पहचान निर्धारित करने वाले पैरामीटर JobInstance तय करते हैं; यहाँ रन की तारीख प्रत्येक दिन के लिए अलग इंस्टेंस बनाती है।

लॉन्चर एक JobExecution लौटाता है, जिसकी स्थिति (COMPLETED, FAILED, STOPPED) रन का परिणाम दर्शाती है। यह सारी जानकारी JobRepository में दर्ज होती है।

@Component
public class InvoiceJobRunner {
    private final JobLauncher jobLauncher;
    private final Job invoiceJob;

    public InvoiceJobRunner(JobLauncher jobLauncher, Job invoiceJob) {
        this.jobLauncher = jobLauncher;
        this.invoiceJob = invoiceJob;
    }

    public void run(LocalDate date) throws Exception {
        JobParameters params = new JobParametersBuilder()
                .addLocalDate("runDate", date)
                .toJobParameters();
        JobExecution execution = jobLauncher.run(invoiceJob, params);
        System.out.println("Status: " + execution.getStatus());
    }
}

पुनःआरंभ में Repository का उपयोग कैसे होता है

सभी हिस्सों को एक साथ समझिए। जब कोई Job बीच में विफल हो जाती है:

विफल JobExecution को FAILED चिह्नित किया जाता है, लेकिन उसके JobInstance को पूर्ण चिह्नित नहीं किया जाता।
पूर्ण किए गए प्रत्येक Step का रिकॉर्ड रखा जाता है; chunk-आधारित स्टेप अपने ExecutionContext में यह भी सहेजता है कि उसने कितने आइटम संसाधित किए।
समान पहचान-निर्धारक पैरामीटर के साथ फिर से लॉन्च करने पर उसी इंस्टेंस पर नया JobExecution बनता है। Spring Batch पहले से पूर्ण किए गए स्टेप छोड़ देता है और विफल स्टेप को अंतिम कमिट किए गए chunk से फिर शुरू करता है।

इसीलिए पहचान-निर्धारक पैरामीटर और JobRepository स्थिर होने चाहिए: यही पुनरारंभ के निर्देशांक होते हैं।

त्वरित जाँच

Job/इंस्टेंस/एक्ज़ीक्यूशन मॉडल की अपनी समझ जाँचिए।

इंटरैक्टिव पाठ में इसका उत्तर दें

पुनरावलोकन

अब आपके पास Spring Batch का संरचनात्मक मॉडल है:

Job — सर्वोच्च-स्तरीय प्रक्रिया, जिसे JobBuilder से बनाया जाता है और जिसमें क्रमबद्ध Steps होते हैं।
JobInstance बनाम JobExecution — किसी इंस्टेंस की पहचान नाम और पहचान-निर्धारक पैरामीटर से होती है; चलाने का प्रत्येक प्रयास अलग एक्ज़ीक्यूशन होता है।
Step — एक चरण, जो या तो chunk-आधारित होता है (कमिट अंतराल के साथ पढ़ना/संसाधित करना/लिखना) या tasklet (एकल क्रिया); इसका ट्रैक StepExecution द्वारा रखा जाता है।
JobRepository — BATCH_* तालिकाओं में स्थायी मेटाडेटा, जो पुनः चलाने की क्षमता, फिर से शुरू करने के तर्क और निगरानी को संचालित करता है।

इनमें निपुण हो जाइए, फिर Spring Batch के बाकी हिस्से — रीडर, राइटर, लिस्नर, विभाजन — इनके ऊपर आसानी से व्यवस्थित हो जाते हैं।

शुरुआत निःशुल्क

एआई शिक्षक के साथ Java सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 21
पाठ: 84

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “जॉब, चरण और JobRepository मॉडल” पाठ निःशुल्क है?

हाँ — Spring Boot 4 की संपूर्ण मार्गदर्शिका अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “जॉब, चरण और JobRepository मॉडल” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। Spring Boot 4 की संपूर्ण मार्गदर्शिका पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“जॉब, चरण और JobRepository मॉडल” में मैं क्या सीखूँगा?

निष्पादन ट्रैकिंग के लिए जॉब, चरण और मेटाडेटा स्थायित्व से बैच कार्यभार की संरचना कीजिए। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Spring Boot 4 की संपूर्ण मार्गदर्शिका का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या Spring Boot 4 की संपूर्ण मार्गदर्शिका शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Spring Boot 4 की संपूर्ण मार्गदर्शिका शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 1वाँ पाठ है।

“जॉब, चरण और JobRepository मॉडल” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस Spring Boot 4 की संपूर्ण मार्गदर्शिका पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर Spring Boot 4 की संपूर्ण मार्गदर्शिका पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

जॉब, चरण और JobRepository मॉडल
खंड-आधारित रीडर-प्रोसेसर-राइटर प्रवाह
दोष-सहिष्णुता, स्किप और पुनःप्रयास नीतियाँ
विभाजन और समानांतर चरण निष्पादन

← Spring Boot 4 की संपूर्ण मार्गदर्शिका पर वापस जाएँ