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

क्लास डेटा साझाकरण और JVM स्टार्टअप ट्यूनिंग

CDS, आलसी आरंभीकरण और बीन इंस्टैंशिएशन ट्यूनिंग से JVM-मोड स्टार्टअप तेज कीजिए।

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

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

JVM स्टार्टअप अब भी महत्वपूर्ण क्यों है

GraalVM नेटिव इमेज लगभग तुरंत शुरू हो जाती हैं, लेकिन अधिकांश टीमें अब भी अपने अधिकांश परिनियोजनों के लिए नियमित JVM बिल्ड भेजती हैं। JVM को डीबग करना आसान है, यह पूर्ण प्रतिबिंब का समर्थन करता है और हर एजेंट तथा लाइब्रेरी के साथ बिना अतिरिक्त व्यवस्था के काम करता है।

अच्छी बात यह है कि JVM-मोड वाला Spring Boot 4 ऐप धीमी गति से शुरू होना आवश्यक नहीं है। तीन उपाय सबसे अधिक प्रभाव डालते हैं:

Class Data Sharing (CDS) — हर बार शुरू होने पर क्लास मेटाडेटा को फिर से पार्स करने से बचें।
आलसी आरंभीकरण — बीन्स को केवल पहली बार उपयोग किए जाने पर बनाएँ।
बीन इंस्टैंसिएशन का समायोजन — कंस्ट्रक्टरों और रिफ्रेश के समय महँगे काम से बचें।

यह पाठ्यक्रम इन तीनों विषयों को JVM मोड में समझाता है; नेटिव इमेज की आवश्यकता नहीं है।

Class Data Sharing वास्तव में क्या करता है

जब JVM शुरू होता है, तो वह सैकड़ों या हज़ारों क्लास लोड, पार्स और सत्यापित करता है। Class Data Sharing (CDS) एक बार पार्स किए गए इन-मेमोरी क्लास निरूपण को केवल-पठन आर्काइव फ़ाइल में लिखता है, फिर हर अगली शुरुआत में उस आर्काइव को मेमोरी-मैप करता है।

इसके लाभ:

हर बार शुरू होने पर क्लास लोड करने और सत्यापित करने का काम कम होता है।
आर्काइव को कई JVM प्रक्रियाओं के बीच साझा किया जा सकता है, यानी वही भौतिक मेमोरी पृष्ठ उपयोग होते हैं।

Spring Boot 4 के लिए दो रूप महत्वपूर्ण हैं:

Dynamic CDS (AppCDS) — केवल JDK क्लास नहीं, बल्कि अपने ऐप की क्लास भी आर्काइव करें।
Project Leyden / Ahead-of-Time cache — नए JDK में CDS पर आधारित विकसित रूप।

Spring Boot 4 का अंतर्निहित CDS समर्थन

Spring Boot AppCDS आर्काइव बनाने के लिए प्रथम-श्रेणी का समर्थन देता है। आप ऐप को एक बार विशेष प्रशिक्षण मोड में चलाते हैं; वह एप्लिकेशन संदर्भ को सक्रिय करता है, बाहर निकलता है और आर्काइव बना देता है। इसके बाद की शुरुआतों में JVM को उस आर्काइव की ओर निर्देशित किया जाता है।

प्रशिक्षण रन नीचे दी गई विशेष प्रॉपर्टी का उपयोग करता है। यह संदर्भ को रिफ्रेश करता है और फिर ट्रैफ़िक दिए बिना बंद हो जाता है:

-Dspring.context.exit=onRefresh संदर्भ तैयार होते ही ऐप को रोक देता है।
JVM फ़्लैग -XX:ArchiveClassesAtExit लोड की गई क्लास को कैप्चर करता है।

# Step 1: training run - refresh context, then exit, dumping the archive
java -XX:ArchiveClassesAtExit=app.jsa \
     -Dspring.context.exit=onRefresh \
     -jar target/myapp.jar

# Step 2: every production start reuses the archive
java -XX:SharedArchiveFile=app.jsa \
     -jar target/myapp.jar

CDS-अनुकूल JAR से लेआउट का अनुकूलन

मानक Spring Boot फैट JAR अपनी निर्भरता वाली JAR फ़ाइलों को अपने अंदर रखता है। CDS तब सबसे अच्छा काम करता है जब क्लास साधारण फ़ाइलों के रूप में ऐसे पथ पर हों जिसे JVM सीधे मैप कर सके। Spring Boot का tools layout ऐप को एक डायरेक्टरी में निकाल देता है, ताकि CDS उसे साफ़-सुथरे ढंग से अनुक्रमित कर सके।

अंतर्निहित JAR मोड से चलने योग्य संरचना निकालें, फिर निकाले गए लेआउट से चलाएँ:

-Djarmode=tools extract एक application/ डायरेक्टरी लिखता है, जिसमें समतल क्लासपाथ होता है।
निकाले गए रूप से चलाने पर प्रशिक्षण और प्रोडक्शन, दोनों की शुरुआत तेज़ और अधिक पुनरुत्पाद्य होती है।

# Explode the jar into a CDS-friendly directory structure
java -Djarmode=tools -jar target/myapp.jar extract --destination app

# Train against the exploded app
java -XX:ArchiveClassesAtExit=app/app.jsa \
     -Dspring.context.exit=onRefresh \
     -jar app/myapp.jar

# Production start
java -XX:SharedArchiveFile=app/app.jsa -jar app/myapp.jar

CDS सक्रिय है या नहीं, इसकी जाँच करना

हमेशा पुष्टि करें कि आर्काइव वास्तव में उपयोग हो रहा है; पथ में टाइपो होने पर CDS के बिना चुपचाप वैकल्पिक रूप से चलने लगता है। क्लास-लोड लॉगिंग जोड़ें, ताकि पता चल सके कि कौन-सी क्लास साझा आर्काइव से और कौन-सी सामान्य क्लासपाथ से आ रही हैं।

एक बार की जाँच के दौरान नैदानिक फ़्लैग का उपयोग करें:

-Xlog:class+load:file=cds.log आर्काइव से लोड होने पर प्रत्येक क्लास के साथ shared टैग लगाता है।
लॉग में खोजें: स्वस्थ आर्काइव में फ़्रेमवर्क की अधिकांश क्लास shared के रूप में चिह्नित दिखेंगी।

# Run with class-load logging and inspect the source of each class
java -XX:SharedArchiveFile=app/app.jsa \
     -Xlog:class+load:file=cds.log \
     -jar app/myapp.jar

# Count how many classes were served from the shared archive
grep -c 'source: shared objects file' cds.log

आलसी बीन आरंभीकरण

डिफ़ॉल्ट रूप से Spring संदर्भ रिफ्रेश के दौरान प्रत्येक सिंगलटन बीन को तुरंत बना देता है। बहुत-सी बीन्स होने पर यही काम स्टार्टअप के अधिकांश समय के लिए ज़िम्मेदार होता है। आलसी आरंभीकरण प्रत्येक बीन का निर्माण तब तक टाल देता है, जब तक उसे पहली बार इंजेक्ट या अनुरोधित न किया जाए।

इसे एक प्रॉपर्टी से वैश्विक रूप से चालू करें:

spring.main.lazy-initialization=true सभी बीन्स को आलसी बना देता है।
समझौता: बीन की वायरिंग से जुड़ी त्रुटियाँ बूट के समय के बजाय पहली बार उपयोग पर सामने आती हैं, और किसी निष्क्रिय बीन को छूने वाले पहले अनुरोध को उसके निर्माण की लागत उठानी पड़ती है।

इसे कम समय चलने वाले CLI कार्यों और विकास के स्टार्टअप के लिए प्राथमिकता दें; हमेशा चालू रहने वाली सेवाओं में सावधान रहें, जहाँ थोड़ा धीमा बूट, धीमे पहले अनुरोध से बेहतर हो सकता है।

spring.main.lazy-initialization=true

@Lazy से चुनिंदा आलस्य

वैश्विक आलस्य एक मोटा उपाय है। अक्सर आप चाहते हैं कि अधिकांश बीन्स तुरंत बनें, ताकि विफलताएँ बूट के समय पकड़ी जाएँ, लेकिन कुछ भारी बीन्स आलसी रहें—जैसे ऐसा क्लाइंट जो धीमा कनेक्शन खोलता है या ऐसा कैश जो बड़ा डेटासेट पहले से लोड करता है।

बीन या इंजेक्शन बिंदु पर @Lazy एनोटेशन लगाएँ। Spring तब एक प्रॉक्सी इंजेक्ट करता है और पहली कॉल पर वास्तविक बीन बनाता है।

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Lazy;

@Configuration
public class ReportingConfig {

    // Heavy bean: only built when something actually needs it
    @Bean
    @Lazy
    public ReportGenerator reportGenerator(DataWarehouse warehouse) {
        return new ReportGenerator(warehouse);
    }
}

बीन कंस्ट्रक्टरों को हल्का रखें

स्टार्टअप को स्वयं धीमा करने का सबसे बड़ा कारण कंस्ट्रक्टरों या @PostConstruct विधियों में वास्तविक काम करना है: कनेक्शन खोलना, कैश को गर्म करना या दूरस्थ सेवाओं को कॉल करना। यह सब रिफ्रेश के दौरान क्रमिक रूप से चलता है और स्टार्टअप को रोकता है।

सामान्य नियम:

कंस्ट्रक्टरों को केवल सहयोगी ऑब्जेक्ट सहेजने चाहिए; उनमें I/O कभी न करें।
महँगे वार्म-अप को ऐसे इवेंट तक टालें जो संदर्भ तैयार होने के बाद सक्रिय हो, या उसे अतुल्यकालिक रूप से चलाएँ।
ऐसे वार्म-अप के लिए ApplicationReadyEvent सुनें जिसे संदर्भ के तैयार होने में बाधा नहीं डालनी चाहिए।

import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.context.event.EventListener;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

@Component
public class CacheWarmer {

    private final ProductCache cache;

    public CacheWarmer(ProductCache cache) {
        // cheap: just hold the dependency
        this.cache = cache;
    }

    // Runs after startup, off the critical path
    @Async
    @EventListener(ApplicationReadyEvent.class)
    public void warmUp() {
        cache.preload();
    }
}

पृष्ठभूमि में बीन बनाना

Spring Boot योग्य बीन्स को पृष्ठभूमि के थ्रेड पूल पर बना सकता है, जबकि मुख्य थ्रेड रिफ्रेश जारी रखता है। इससे स्वतंत्र और धीरे बनने वाली बीन्स का काम समानांतर हो जाता है और कुल स्टार्टअप समय घटता है।

bootstrapExecutor बीन परिभाषित करें; Spring इसका उपयोग उन बीन्स को पृष्ठभूमि में बनाने के लिए करता है जो इसमें भाग लेने के लिए तैयार हों। जिन बीन्स की उन पर निर्भरता नहीं है, वे मुख्य थ्रेड पर आगे बढ़ती रहती हैं।

import java.util.concurrent.Executor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

@Configuration
public class BootstrapConfig {

    // Spring detects a bean named 'bootstrapExecutor' for background init
    @Bean
    public Executor bootstrapExecutor() {
        ThreadPoolTaskExecutor exec = new ThreadPoolTaskExecutor();
        exec.setCorePoolSize(4);
        exec.setThreadNamePrefix("bg-init-");
        exec.initialize();
        return exec;
    }
}

Startup Actuator से स्टार्टअप मापना

समय कहाँ जा रहा है, इसका अनुमान न लगाएँ—मापें। जब आप BufferingApplicationStartup देते हैं, तब Spring हर चरण—बीन निर्माण, पोस्ट-प्रोसेसिंग और ऑटो-कॉन्फ़िगरेशन—की स्टार्टअप समयरेखा दर्ज करता है।

इसे main() में जोड़ें, फिर सबसे धीमे चरण खोजने के लिए /actuator/startup एंडपॉइंट से बफ़र किए गए इवेंट पढ़ें। अवधि के अनुसार क्रमबद्ध करें और सबसे अधिक समय लेने वाले चरणों को पहले सुधारें।

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.metrics.buffering.BufferingApplicationStartup;

@SpringBootApplication
public class ShopApplication {

    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(ShopApplication.class);
        // capture up to 2048 startup steps for /actuator/startup
        app.setApplicationStartup(new BufferingApplicationStartup(2048));
        app.run(args);
    }
}

सबको जोड़ना: समायोजित स्टार्टअप विधि

Spring Boot 4 सेवा के लिए JVM-मोड में किया जाने वाला वास्तविक समायोजन, प्रभाव के क्रम में इन तकनीकों को मिलाता है:

1. JAR निकालें (jarmode=tools extract) और प्रशिक्षण रन से AppCDS आर्काइव बनाएँ।
2. सचमुच भारी कुछ बीन्स पर @Lazy लगाएँ; बाकी को तुरंत बनने दें, ताकि कॉन्फ़िगरेशन त्रुटियाँ तुरंत विफल हों।
3. सभी वार्म-अप और I/O को कंस्ट्रक्टरों से हटाकर ApplicationReadyEvent श्रोताओं में ले जाएँ।
4. यदि कई स्वतंत्र धीमी बीन्स हैं, तो bootstrapExecutor जोड़ें।
5. प्रत्येक बदलाव से लाभ हुआ या नहीं, इसकी पुष्टि करने के लिए BufferingApplicationStartup का उपयोग करें।

इसके बाद लॉन्च कमांड केवल आर्काइव की ओर निर्देशित होती है:

java -XX:SharedArchiveFile=app/app.jsa \
     -Dspring.threads.virtual.enabled=true \
     -jar app/myapp.jar

त्वरित जाँच: सही उपाय चुनना

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

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

पुनरावलोकन

JVM-मोड में Spring Boot 4, नेटिव हुए बिना भी तेज़ी से शुरू हो सकता है। मुख्य बातें:

CDS पहले से पार्स किए गए क्लास आर्काइव को मेमोरी-मैप करता है; इसे प्रशिक्षण रन (-XX:ArchiveClassesAtExit + spring.context.exit=onRefresh) से बनाएँ और -XX:SharedArchiveFile से उपयोग करें। CDS-अनुकूल लेआउट के लिए पहले jar को एक्सट्रैक्ट करें।
Lazy init बीन्स का निर्माण टालता है: spring.main.lazy-initialization से वैश्विक रूप से, या @Lazy से चुनिंदा रूप में। इसके बदले बूट तेज़ होता है, लेकिन तुरंत विफलता और पहले अनुरोध की विलंबता का लाभ कम हो जाता है।
Bean tuning: कंस्ट्रक्टर को हल्का रखें, वार्म-अप को ApplicationReadyEvent में ले जाएँ, और स्वतंत्र धीमे बीन्स को bootstrapExecutor से समानांतर चलाएँ।
मापन के लिए हर चीज़ को BufferingApplicationStartup और /actuator/startup से मापें — अपनी धारणाओं के बजाय सबसे धीमे चरणों को बेहतर बनाएँ।

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

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

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

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

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

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

क्या “क्लास डेटा साझाकरण और JVM स्टार्टअप ट्यूनिंग” पाठ निःशुल्क है?

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

“क्लास डेटा साझाकरण और JVM स्टार्टअप ट्यूनिंग” में मैं क्या सीखूँगा?

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

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

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

“क्लास डेटा साझाकरण और JVM स्टार्टअप ट्यूनिंग” पाठ पूरा करने में कितना समय लगता है?

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

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

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

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

AOT प्रोसेसिंग और नेटिव बिल्ड पाइपलाइन
रिफ्लेक्शन और संसाधनों के लिए रनटाइम संकेत
क्लास डेटा साझाकरण और JVM स्टार्टअप ट्यूनिंग
नेटिव संगतता समस्याओं का निदान और समाधान

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