जेएसपी जीवन चक्र: चरण और आरेख की व्याख्या

द्वारा: जेम्स हार्टमैन जेम्स हार्टमैन
Hours Updated

⚡ स्मार्ट सारांश

जेएसपी लाइफ साइकिल यह वर्णन करती है कि कैसे एक कंटेनर एक पेज को सर्वलेट में अनुवादित करता है, उसे कंपाइल करता है, क्लास को लोड करता है, एक इंस्टेंस बनाता है, उसे इनिशियलाइज़ करता है, जेनरेटेड सर्विस मेथड के माध्यम से प्रत्येक अनुरोध को सर्व करता है, और अंत में उसे नष्ट कर देता है।

  • 🔄 सात चरण: अनुवाद, संकलन, क्लास लोडिंग, इंस्टैंशिएशन, इनिशियलाइज़ेशन, अनुरोध प्रसंस्करण और विनाश उसी निश्चित क्रम में चलते हैं।
  • 📄 अनुवाद: कंटेनर पेज को वैलिडेट करता है, फिर लिखता है Java स्रोत फ़ाइल, इसलिए demo.jsp किसी भी निष्पादन से पहले demo_jsp.java बन जाती है।
  • ⚙️ संकलन: वह जनरेट किया गया सोर्स कोड demo_jsp.class में कंपाइल होता है, जिसे टॉमकैट अपनी वर्क डायरेक्टरी के अंतर्गत .java फ़ाइल के साथ रखता है।
  • 🚀 तीन विधियाँ: jspInit() पेज को एक बार तैयार करता है, _jspService() हर अनुरोध का जवाब देता है, और jspDestroy() अंत में संसाधनों को रिलीज़ करता है।
  • 🚫 एक नियम: _jspService() कंटेनर द्वारा उत्पन्न किया जाता है और इसे पृष्ठ लेखक द्वारा कभी भी लिखा या ओवरराइड नहीं किया जाना चाहिए।
  • 🗃️ सफाई हुक: jspDestroy() को ओवरराइड करना डेटाबेस कनेक्शन और खुली फाइलों को बंद करने का सही तरीका है।
विस्तार में पढ़ें

जेएसपी जीवन चक्र के चरण, अनुवाद से लेकर विनाश तक

जेएसपी लाइफ साइकिल क्या है?

जेएसपी जीवन चक्र इसे JSP पेज को सर्वलेट में रूपांतरित करने की प्रक्रिया के रूप में परिभाषित किया जाता है, क्योंकि सेवा अनुरोधों को संसाधित करने से पहले JSP पेज को सर्वलेट में परिवर्तित करना आवश्यक होता है। जीवन चक्र JSP के निर्माण से शुरू होता है और उससे उत्पन्न सर्वलेट इंस्टेंस के नष्ट होने के साथ समाप्त होता है।

क्योंकि जनरेट की गई क्लास एक साधारण सर्वलेट है, इसलिए सर्वलेट के बारे में आप जो कुछ भी पहले से जानते हैं, वह सब लागू होता है।tracयह अभी भी लागू होता है। Java कंटेनर द्वारा लिखा गया कोड ही वास्तव में चलता है; JSP फ़ाइल केवल वह स्रोत है जिसे आप बनाए रखते हैं।

जेएसपी जीवन चक्र के विभिन्न चरण

जब ब्राउज़र JSP फ़ाइल मांगता है, तो JSP इंजन सबसे पहले यह जांचता है कि क्या उसे पेज को कंपाइल करने की आवश्यकता है। यदि JSP फ़ाइल पहले कभी कंपाइल नहीं हुई है, या पिछली बार कंपाइल होने के बाद उसमें कोई बदलाव किया गया है, तो JSP इंजन पेज को कंपाइल करता है।

एक JSP पेज के संकलन की प्रक्रिया में तीन चरण शामिल होते हैं:

  • जेएसपी की पार्सिंग
  • JSP को सर्वलेट में बदलना
  • सर्वलेट संकलित करना

जेएसपी जीवन चक्र आरेख

नीचे दिए गए आरेख में जेएसपी जीवन चक्र को दर्शाया गया है, जो tracयह स्रोत फ़ाइल से लेकर कंटेनर द्वारा निष्पादित की जाने वाली क्लास तक एक ही पृष्ठ को प्रदर्शित करता है।

JSP जीवन चक्र आरेख अनुवाद, संकलन, लोडिंग, इंस्टेंशिएशन, आरंभीकरण, अनुरोध प्रसंस्करण और विनाश को दर्शाता है

निम्नलिखित चरण JSP के जीवन चक्र की व्याख्या करते हैं:

  1. जेएसपी पृष्ठ का अनुवाद
  2. JSP पेज का संकलन (JSP पेज को _jsp.java में संकलित करना)
  3. क्लास लोडिंग (_jsp.java को क्लास फ़ाइल _jsp.class में परिवर्तित किया जाता है)
  4. इंस्टैंशिएशन (जनरेट किए गए सर्वलेट का एक ऑब्जेक्ट बनाया जाता है)
  5. आरंभिकरण (कंटेनर द्वारा jspInit() विधि को कॉल किया जाता है)
  6. अनुरोध प्रसंस्करण (कंटेनर द्वारा _jspService() विधि को कॉल किया जाता है)
  7. नष्ट करें (कंटेनर द्वारा jspDestroy() विधि को कॉल किया जाता है)

जेएसपी जीवन चक्र के चरणों की व्याख्या

आइए उपरोक्त प्रत्येक बिंदु को और अधिक विस्तार से देखें।

1) जेएसपी पृष्ठ का अनुवाद:

A Java सर्वलेट फ़ाइल एक JSP स्रोत फ़ाइल से उत्पन्न होती है। यह JSP जीवन चक्र का पहला चरण है। अनुवाद चरण में, कंटेनर JSP पृष्ठ और टैग फ़ाइलों की वाक्य रचना संबंधी शुद्धता की जाँच करता है।

  • JSP कंटेनर मानक निर्देशों और क्रियाओं, और टैग लाइब्रेरी का संदर्भ देने वाली कस्टम क्रियाओं की व्याख्या करता है (ये सभी JSP पृष्ठ का हिस्सा हैं और इन्हें इसमें शामिल किया गया है)। जेएसपी तत्व इस जेएसपी पेज में ट्यूटोरियल का उपयोग किया गया है।
  • ऊपर दिए गए चित्रमय विवरण में, पहले चरण में demo.jsp को demo_jsp.java में अनुवादित किया गया है।

आइए नीचे दिखाए गए अनुसार “demo.jsp” का एक उदाहरण लेते हैं:

डेमो.jsp

<html>
<head>
<title>Demo JSP</title>
</head>
<%
int demvar=0;%>
<body>
Count is:
<% Out.println(demovar++); %>
<body>
</html>

ऊपर दी गई सूची पर ध्यान दें: इसे प्रकाशित रूप में हूबहू पुन: प्रस्तुत किया गया है ताकि यह नीचे दिए गए जनरेटेड सर्वलेट स्क्रीनशॉट से मेल खाए। इसमें दो वर्तनी ऐसी हैं जिन्हें हूबहू कॉपी करने पर कंपाइल नहीं किया जा सकेगा — वेरिएबल को इस प्रकार घोषित किया गया है: demvar लेकिन मुद्रित के रूप में demovarऔर अंतर्निहित आउटपुट ऑब्जेक्ट है out छोटे अक्षरों में, नहीं Outपेज को स्वयं चलाने से पहले दोनों को ठीक कर लें।

Code Demo.jsp के लिए स्पष्टीकरण

Code पंक्ति 1: एचटीएमएल प्रारंभ टैग

Code पंक्ति 2: हेड टैग

Code पंक्ति 3 – 4: शीर्षक टैग, यानी डेमो जेएसपी, और समापन हेड टैग

Code पंक्ति 5 – 6: स्क्रिप्टलेट टैग जिसमें वेरिएबल डेमो को इनिशियलाइज़ किया गया है

Code पंक्ति 7 – 8: बॉडी टैग में, आउटपुट में प्रिंट किया जाने वाला टेक्स्ट (गणना है: )

Code पंक्ति 9: स्क्रिप्टलेट टैग जहां हम वेरिएबल demovar को उसके बढ़े हुए मान के साथ प्रिंट करने का प्रयास करते हैं

Code पंक्ति 10 – 11: बॉडी और HTML टैग बंद

डेमो जेएसपी पेज को नीचे दिए गए कोड में दिखाए गए demo_jsp सर्वलेट में परिवर्तित किया जाता है।

अनुवाद के दौरान demo.jsp से उत्पन्न demo_jsp.java सर्वलेट स्रोत फ़ाइल का निर्माण हुआ।

Code Demo_jsp.java के लिए स्पष्टीकरण

Code पंक्ति 1: सर्वलेट क्लास demo_jsp पैरेंट क्लास HttpServlet का विस्तार कर रही है।

Code पंक्ति 2-3: JSP की सेवा विधि, यानी _jspService को ओवरराइड करना, जिसमें HttpServletRequest और HttpServletResponse ऑब्जेक्ट इसके पैरामीटर के रूप में हैं।

Code पंक्ति 4: खोलने की विधि

Code पंक्ति 5: गेट विधि को कॉल करनाWriterप्रिंट प्राप्त करने के लिए प्रतिक्रिया ऑब्जेक्ट का ()Writer ऑब्जेक्ट (ऑब्जेक्ट्स का स्वरूपित प्रतिनिधित्व टेक्स्ट आउटपुट स्ट्रीम में प्रिंट करता है)

Code पंक्ति 6: सामग्री प्रकार सेट करने के लिए प्रतिक्रिया ऑब्जेक्ट की setContentType विधि को कॉल करना

Code पंक्ति 7: प्रिंट फ़ंक्शन के write() मेथड का उपयोग करनाWriter एचटीएमएल को पार्स करने के लिए ऑब्जेक्ट

Code पंक्ति 8: डेमोवर वेरिएबल को 0 से इनिशियलाइज़ करना

Code पंक्ति 9: प्रिंट फ़ंक्शन के write() मेथड को कॉल करनाWriter पाठ को पार्स करने के लिए ऑब्जेक्ट

Code पंक्ति 10: प्रिंट फ़ंक्शन के प्रिंट() मेथड को कॉल करनाWriter ऑब्जेक्ट का उपयोग करके वेरिएबल demovar को 0 + 1 = 1 से बढ़ाएँ। अतः, आउटपुट 1 होगा।

Code पंक्ति 11: प्रिंट फ़ंक्शन के write() मेथड का उपयोग करनाWriter एचटीएमएल को पार्स करने के लिए ऑब्जेक्ट

आउटपुट:

इसके बाद ब्राउज़र काउंटर को प्रदर्शित करता है, जैसा कि नीचे दिए गए स्क्रीनशॉट में दिखाया गया है।

demo.jsp फ़ाइल का ब्राउज़र आउटपुट दिखाता है कि Count 1 है।

  • यहां आप स्क्रीनशॉट में देख सकते हैं कि आउटपुट 1 है, क्योंकि demvar को 0 से इनिशियलाइज़ किया गया है और फिर उसे 0 + 1 = 1 तक बढ़ाया गया है।

उपरोक्त उदाहरण में,

  • demo.jsp एक JSP फ़ाइल है जिसमें एक वेरिएबल को इनिशियलाइज़ और इंक्रीमेंट किया जाता है। इस JSP को सर्वलेट (demo_jsp.class) में परिवर्तित किया जाता है, जहाँ JSP इंजन JSP पेज को लोड करता है और उसे सर्वलेट कंटेंट में बदल देता है।
  • रूपांतरण होने पर, सभी टेम्पलेट टेक्स्ट को println() कथनों में और सभी JSP तत्वों को परिवर्तित कर दिया जाता है। Java कोड।

इस प्रकार एक सरल JSP पृष्ठ को सर्वलेट क्लास में अनुवादित किया जाता है।

संबंधित आलेख

2) जेएसपी पेज का संकलन

  • उत्पन्न हुआ Java सर्वलेट फ़ाइल को संकलित किया जाता है Java सर्वलेट क्लास
  • का अनुवाद Java स्रोत पृष्ठ से उसके कार्यान्वयन वर्ग में परिवर्तन, कंटेनर में जेएसपी पृष्ठ की तैनाती और जेएसपी पृष्ठ के प्रसंस्करण के बीच किसी भी समय हो सकता है।
  • ऊपर दिए गए चित्रमय विवरण में, demo_jsp.java को संकलित करके demo_jsp.class नामक एक क्लास फ़ाइल बनाई जाती है।
  • अपाचे टॉमकैट पर दोनों आर्टिफैक्ट सर्वर वर्क डायरेक्टरी के अंतर्गत लिखे जाते हैं, work/Catalina/localhost/<app>/org/apache/jspअनुवाद त्रुटि का निदान करते समय सबसे पहले यहीं देखना चाहिए।

3) क्लास लोडिंग

  • JSP स्रोत से जनरेट की गई सर्वलेट क्लास अब कंटेनर में लोड हो गई है।

4) इन्स्टेन्शियेशन

  • इस चरण में ऑब्जेक्ट, यानी क्लास का इंस्टेंस, जनरेट होता है।
  • यह कंटेनर अनुरोधों और अन्य घटनाओं के जवाब में इस क्लास के एक या अधिक इंस्टेंस को प्रबंधित करता है। आमतौर पर, एक JSP कंटेनर सर्वलेट कंटेनर का उपयोग करके बनाया जाता है। JSP कंटेनर सर्वलेट कंटेनर का ही एक विस्तार है, क्योंकि दोनों कंटेनर JSP और सर्वलेट दोनों को सपोर्ट करते हैं।
  • कंटेनर द्वारा प्रदान किया गया JspPage इंटरफ़ेस, jspInit() और jspDestroy() विधियों को घोषित करता है।
  • HttpJspPage नामक एक इंटरफ़ेस है जो HTTP अनुरोधों को संभालता है, और इसमें सर्विस मेथड भी शामिल है। इसका सिग्नेचर प्रोटोकॉल पर निर्भर करता है, इसलिए कंटेनर पेज लेखक से इसे घोषित करने के लिए कहने के बजाय इस मेथड को स्वयं उत्पन्न करता है।

5) आरंभीकरण

public void jspInit()
{
	//initializing the code
}
  • jspInit() विधि JSP से उत्पन्न सर्वलेट इंस्टेंस को आरंभ करती है, और इस चरण में कंटेनर द्वारा इसे कॉल किया जाता है।
  • इंस्टेंस बन जाने के तुरंत बाद init मेथड को कॉल किया जाता है।
  • इसे JSP जीवन चक्र के दौरान केवल एक बार कॉल किया जाता है, और आरंभीकरण के लिए विधि को ऊपर दिखाए अनुसार घोषित किया जाता है।

6) अनुरोध प्रसंस्करण

void _jspservice(HttpServletRequest request HttpServletResponse response)
{
	//handling all request and responses
}
  • _jspService() विधि को कंटेनर द्वारा JSP पेज के जीवन चक्र के दौरान उत्पन्न सभी अनुरोधों के लिए कॉल किया जाता है।
  • इस चरण के लिए, पृष्ठ को उपरोक्त सभी चरणों से गुजरना होगा, और उसके बाद ही सेवा विधि को लागू किया जा सकता है।
  • यह अनुरोध और प्रतिक्रिया ऑब्जेक्ट को पास करता है।
  • इस विधि को ओवरराइड नहीं किया जा सकता, क्योंकि कंटेनर इसे अनुवाद के दौरान लिखता है।
  • ऊपर विधि का उदाहरण दिया गया है। यह विधि सभी HTTP विधियों, जैसे कि GET, POST आदि को संभालने के लिए जिम्मेदार है।

7) नष्ट करें

public void _jspdestroy()
{
            //all clean up code
}
  • कंटेनर द्वारा jspDestroy() विधि को भी कॉल किया जाता है।
  • इस विधि को तब कॉल किया जाता है जब कंटेनर यह तय करता है कि उसे अनुरोधों को पूरा करने के लिए अब सर्वलेट इंस्टेंस की आवश्यकता नहीं है।
  • डिस्ट्रॉय मेथड को कॉल करने के बाद, सर्वलेट गार्बेज कलेक्शन के लिए तैयार हो जाता है।
  • यह जीवन चक्र का अंत है।
  • हम डेटाबेस कनेक्शन जारी करने या खुली फाइलों को बंद करने जैसे किसी भी सफाई कार्य को करते समय jspDestroy() को ओवरराइड कर सकते हैं।

एक नामकरण संबंधी महत्वपूर्ण बात जो आगे ध्यान देने योग्य है: जकार्ता ईई 9 से आगे ये प्रकार यहाँ पाए जाते हैं। jakarta.servlet.jsp पैकेज के बजाय javax.servlet.jspइसलिए, जब किसी एप्लिकेशन को वर्तमान सर्वर पर स्थानांतरित किया जाता है, तो पुराने आयात को अपडेट करना पड़ता है।

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

अनुवाद के बाद उनका जीवन चक्र समान होता है। एक JSP दो चरणों को पहले जोड़ता है: अनुवाद और संकलन, जो पृष्ठ को एक सर्वलेट स्रोत फ़ाइल और क्लास में बदल देते हैं। क्लास लोड होने के बाद से सर्वलेटtracयह नियम अपरिवर्तित रूप से लागू होता है।

सर्वर वर्क डायरेक्टरी के अंतर्गत, work/Catalina/localhost/ में /org/apache/jsp. जनरेट की गई .java सोर्स फ़ाइल और कंपाइल की गई .class फ़ाइल दोनों वहीं पहुँचती हैं, इसलिए home.jsp, home_jsp.java और home_jsp.class बन जाती हैं।

अनुवाद के दौरान कंटेनर इसे पेज बॉडी से उत्पन्न करता है। इसका सिग्नेचर अनुरोध प्रोटोकॉल पर निर्भर करता है, इसलिए विनिर्देश इसे JspPage इंटरफ़ेस से बाहर रखता है और पेज लेखकों को इसे स्वयं घोषित करने से रोकता है।

जनरेट किया गया सर्वलेट पहले से ही अपने सर्वलेटकॉन्फ़िग को स्टोर करने के लिए init() फ़ंक्शन को इम्प्लीमेंट करता है, फिर jspInit() को कॉल करता है। पेज लेखक jspInit() को ओवरराइड करते हैं ताकि कंटेनर सेटअप कभी भी स्किप न हो, जो कि हाथ से लिखे गए init() ओवरराइड का जोखिम होता है।

प्रीकंपाइलेशन हर पेज का अनुवाद और संकलन बिल्ड या डिप्लॉयमेंट के समय ही कर देता है, न कि पहले अनुरोध पर। इससे पहले आने वाली देरी दूर हो जाती है, रिलीज़ से पहले अनुवाद संबंधी त्रुटियाँ सामने आ जाती हैं, और सर्वर पर कंपाइलर के बिना डिप्लॉयमेंट संभव हो जाता है।

इसे जकार्ता सर्वर पेज के रूप में समर्थन प्राप्त है। मुख्य परिवर्तन पैकेज नेमस्पेस में है: जकार्ता EE 9 से API को javax.servlet.jsp से jakarta.servlet.jsp में स्थानांतरित कर दिया गया है, इसलिए वर्तमान सर्वर पर चलाने से पहले पुराने इंपोर्ट को फिर से लिखना होगा।

एआई सहायक जनरेट किए गए _jsp.java स्टैक को पढ़ते हैं। tracये स्क्रिप्टलेट संकलन त्रुटि को संबंधित स्क्रिप्टलेट पंक्ति से जोड़ते हैं, जो अनुवाद त्रुटियों का सबसे कठिन हिस्सा है। साथ ही, ये उन स्क्रिप्टलेट को भी चिह्नित करते हैं जो टैग फ़ाइल या सर्वलेट में होनी चाहिए।

जी हां। कोपायलट कमेंट से स्क्रिप्टलेट, जेएसटीएल ब्लॉक, फॉर्म हैंडलिंग और मैचिंग सर्वलेट क्लासेस तैयार करता है। Revjakarta पैकेज नेमस्पेस और उन स्क्रिप्टलेट्स के आउटपुट को देखें जो अभिव्यक्ति भाषा होनी चाहिए, क्योंकि सुझाव अक्सर पुराने ट्यूटोरियल का अनुसरण करते हैं।

इस पोस्ट को संक्षेप में इस प्रकार लिखें: