सर्वलेट्स और JSPs का उपयोग करके एक साधारण वेब एप्लिकेशन बनाना (भाग 1)

लेख को समझने के लिए आवश्यक ज्ञान: आप पहले से ही कमोबेश Java Core का पता लगा चुके हैं और JavaEE प्रौद्योगिकियों और वेब प्रोग्रामिंग को देखना चाहेंगे । आपके लिए वर्तमान में जावा कलेक्शंस खोज का अध्ययन करना सबसे अधिक उपयोगी होगा , जो लेख के करीब के विषयों से संबंधित है।

सर्वलेट्स और जेएसपी (भाग 1) - 1 का उपयोग करके एक साधारण वेब एप्लिकेशन बनाना

यह सामग्री मेरे लेख IntelliJ Idea Enterprise में सबसे सरल वेब प्रोजेक्ट बनाना की तार्किक निरंतरता है । उस लेख में, मैंने प्रदर्शित किया कि एक वर्किंग वेब प्रोजेक्ट टेम्प्लेट कैसे बनाया जाता है। इस बार मैं आपको दिखाऊंगा कि जावा सर्वलेट एपीआई और जावा सर्वर पेज एपीआई का उपयोग करके एक सरल लेकिन पूरी तरह से आकर्षक वेब एप्लिकेशन कैसे बनाया जाता है । हमारे आवेदन में दो लिंक वाला एक होम पेज होगा:

उपयोगकर्ताओं को जोड़ने के लिए एक पृष्ठ का लिंक;
उपयोगकर्ताओं की सूची के लिए एक लिंक।

पहले की तरह, मैं IntelliJ Idea Enterprise Edition , Apache Maven (हम केवल कुछ निर्भरताओं को कनेक्ट करेंगे), और Apache Tomcat का उपयोग करेंगे । अंत में, हम W3.CSS फ्रेमवर्क का उपयोग करके अपने एप्लिकेशन को "सुशोभित" करेंगे। हम मान लेंगे कि आपके पास पहले से ही एक खाली प्रोजेक्ट है जिसे अब हम इसमें जोड़ेंगे। यदि नहीं, तो पहले लेख को पढ़ें और एक बनाएं। इसमें कुछ ही मिनट लगेंगे :)

हमारे भविष्य के एप्लिकेशन की संरचना के बारे में थोड़ा सा

हमारा होम पेज (/) एक हेडर और दो लिंक/बटन के साथ एक सबसे साधारण स्थिर HTML पेज होगा :

एक नया उपयोगकर्ता जोड़ें (नेविगेट करने / जोड़ने के लिए );
उपयोगकर्ताओं की सूची देखें (नेविगेट करने के लिए / सूची )।

टॉमकैट इन पतों के लिए अनुरोधों को पकड़ेगा और उन्हें उन दो सर्वलेट्स में से एक में भेजेगा जो हम बनाने जा रहे हैं (हम web.xml में मैपिंग निर्दिष्ट करेंगे )। सर्वलेट तब अनुरोधों को संसाधित करेगा, डेटा तैयार करेगा (या यदि हम उपयोगकर्ता जोड़ रहे हैं तो डेटा सहेजें), और उचित जेएसपी फाइलों पर नियंत्रण स्थानांतरित करें , जो परिणाम को "रेंडर" करते हैं। हम डेटा को एक सादे वेनिला सूची (सूची) में संग्रहीत करेंगे।

एक स्थिर होम पेज बनाएँ

यदि आप अपने वेब फ़ोल्डर में index.jsp करते हैं , तो उसे हटा दें। इसके बजाय, इस फ़ोल्डर में index.html नामक एक साधारण HTML फ़ाइल बनाएँ :


<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>My super project!</title>
</head>
<body>
    <!-- header -->
    <div>
        <h1>Super app!<//h1>
    </div>

    <div>       <!-- content -->
        <div>    <!-- button holder -->
            <button onclick="location.href='/list'">List users<//button>
            <button onclick="location.href='/add'">Add user<//button>
        </div>
    </div>
</body>
</html>

यहाँ कुछ भी जटिल नहीं है। शीर्षक टैग में , हम अपने पृष्ठ का शीर्षक इंगित करते हैं। पेज बॉडी में, हमारे पास दो मुख्य divs हैं: हेडर और कंटेंट । सामग्री डिव में हमारे बटनों के लिए एक होल्डर शामिल है। और वहां हमारे पास दो बटन हैं जो आपको एक क्लिक के साथ संबंधित पते पर ले जाते हैं। आप प्रोजेक्ट चला सकते हैं और देख सकते हैं कि यह अब कैसा दिखता है। यदि आप बटनों पर क्लिक करते हैं, तो आपको 404-त्रुटि पृष्ठ मिलते हैं, क्योंकि हम संबंधित पृष्ठ अभी तक मौजूद नहीं हैं। लेकिन हम बता सकते हैं कि बटन काम करते हैं। ध्यान दें कि यह सबसे सार्वभौमिक दृष्टिकोण नहीं है: यदि ब्राउज़र में जावास्क्रिप्ट बंद है, तो ये बटन काम नहीं करेंगे। लेकिन हम मान लेंगे कि कोई भी जावास्क्रिप्ट को अक्षम नहीं करता है। :) जाहिर है, आप सरल लिंक के साथ प्राप्त कर सकते हैं, लेकिन मुझे बटन पसंद हैं। आप जैसा चाहें वैसा कर सकते हैं। और इस तथ्य के बारे में चिंता न करें कि मेरे उदाहरणों में बहुत सारे divs होंगे । हम उन्हें बाद में शैलियों से भर देंगे, और सब कुछ और सुंदर दिखाई देगा। :)

परिणाम प्रस्तुत करने के लिए जेएसपी फाइलें बनाएं

उसी वेब निर्देशिका में, एक फ़ोल्डर बनाएँ जहाँ हम अपनी JSP फ़ाइलें जोड़ेंगे । मैंने इसे ' विचार ' कहा , लेकिन एक बार फिर आप सुधार कर सकते हैं। इस फोल्डर में, हम दो JSP फाइलें बनाएंगे:

add.jsp — उपयोगकर्ताओं को जोड़ने के लिए एक पृष्ठ;
list.jsp — पृष्ठ उपयोगकर्ताओं की सूची प्रदर्शित करने के लिए।

उन्हें उपयुक्त पेज हेडर असाइन करें। कुछ इस तरह " नया उपयोगकर्ता जोड़ें " और " उपयोगकर्ता सूची ", और हम इसे ऐसे ही छोड़ देंगे।

दो सर्वलेट बनाएं

सर्वलेट टॉमकैट द्वारा भेजे गए अनुरोधों को प्राप्त और संसाधित करेगा । src/main/java फोल्डर में , ऐप पैकेज बनाएं , जहां हम अपना सोर्स कोड डालेंगे। अन्य पैकेज भी वहीं जाएंगे। इसलिए, इन पैकेजों को एक दूसरे के अंदर बनने से रोकने के लिए, हम ऐप पैकेज में कुछ क्लास बनाएंगे (हम इसे बाद में हटा देंगे)। अब ऐप पैकेज में तीन अलग-अलग पैकेज बनाएं :

संस्थाएँ - हमारी संस्थाएँ (वह वर्ग जो उपयोगकर्ता वस्तुओं का वर्णन करती है) यहाँ जाती हैं;
मॉडल - यह वह जगह है जहां हमारा मॉडल जाता है (हम इसके बारे में थोड़ी देर बाद बात करेंगे);
सर्वलेट्स - और यहीं पर हमारे सर्वलेट्स जाते हैं।

एक बार जब आप ऐसा कर लेते हैं, तो आप शांति से उस वर्ग को ऐप पैकेज से हटा सकते हैं (यदि आपने इसे बनाया है, तो निश्चित रूप से)। सर्वलेट्स पैकेज में , दो वर्ग बनाएँ:

AddServlet — भेजे गए अनुरोधों को संसाधित करता है / जोड़ता है ;
ListServlet — / सूची को भेजे गए अनुरोधों को संसाधित करता है ।

मावेन में निर्भरताएँ जोड़ना

टॉमकैट 9। * सर्वलेट 4.0 और जावा सर्वर पेज 2.3 के विनिर्देशों को लागू करता है । टॉमकैट 9 के आधिकारिक दस्तावेज के पहले पैराग्राफ की दूसरी पंक्ति में यही कहा गया है । इसका मतलब यह है कि यदि आप, मेरी तरह, टॉमकैट के इस संस्करण का उपयोग करते हैं , तो आप जो कोड लिखेंगे और चलाएंगे, वह इन संस्करणों का उपयोग करेगा। लेकिन हम इन विशिष्टताओं को अपनी परियोजना में रखना चाहते हैं, ताकि हमारा कोड, जो उनका उपयोग करता है, कम से कम सफलतापूर्वक संकलित हो। और ऐसा करने के लिए, हमें उन्हें अपने प्रोजेक्ट में लोड करना होगा। यहीं पर मावेन बचाव के लिए आता है।

सामान्य नियम यह है: यदि आपको मावेन का उपयोग करके अपनी परियोजना से कुछ जोड़ने की आवश्यकता है:

मावेन से रिपॉजिटरी वेबसाइट पर जाएं;
आवश्यक पुस्तकालय के आवश्यक संस्करण के लिए खोजें;
निर्भरता कोड प्राप्त करें जिसे आपके pom.xml में चिपकाने की आवश्यकता है;
चिपकाओ! :)

चलो शुरू करें। सबसे पहले पीओएम फाइल तैयार करें । कहीं / संस्करण प्रविष्टि के बाद, लेकिन / प्रोजेक्ट से पहले , निम्नलिखित डालें:


<dependencies>

</dependencies>

हम यह इंगित करने के लिए ऐसा करते हैं कि हम इन टैग्स के भीतर आवश्यक निर्भरताओं को सूचीबद्ध करेंगे। अब mvnrepository.com पर जाएं । शीर्ष पर एक खोज फ़ील्ड है। प्रारंभ करने के लिए, ' सर्वलेट ' खोजें । पहला परिणाम, जिसे सात हजार से अधिक बार उपयोग किया जा चुका है, हमें सूट करता है। याद रखें, हमें संस्करण 4.0 की आवश्यकता है ( टॉमकैट 9). पुराने कार्यान्वयन के लिए अन्य संस्करण उपयुक्त हो सकते हैं। यह काफी नया संस्करण है, इसलिए इसके इतने अधिक उपयोग नहीं हैं। लेकिन हमें इसकी जरूरत है। एक पृष्ठ खुलता है जहां आप इस निर्भरता के लिए विभिन्न प्रकार के पैकेज प्रबंधकों के लिए कोड प्राप्त कर सकते हैं, या आप इसे आसानी से डाउनलोड कर सकते हैं। लेकिन चूंकि हम इसे मेवेन का उपयोग करके कनेक्ट करना चाहते हैं, हम मेवेन टैब पर कोड का चयन करेंगे। हम अपनी पीओएम फाइल के डिपेंडेंसी सेक्शन में कॉपी और पेस्ट करते हैं। यदि आपको IDEA के निचले दाएं कोने में ऑटो-आयात को सक्षम करने के बारे में पूछने वाली सूचना मिलती है , तो आगे बढ़ें और इसके लिए सहमति दें। यदि आपने गलती से मना कर दिया है, तो " सेटिंग्स " पर जाएं और मैन्युअल रूप से ऑटो-आयात चालू करें: सेटिंग्स (Ctrl + Alt + S) -> Build, Execution, Deployment -> Maven -> Importing ।और इस प्रोजेक्ट के लिए IDEA कॉन्फ़िगरेशन फ़ाइलें सिंक में हैं। उसी सिद्धांत का पालन करते हुए, हम JavaServer Pages 2.3 ("JSP" के लिए खोजें) को खोजेंगे और कनेक्ट करेंगे। और चूंकि हमने पहले ही मेवेन शुरू कर दिया है, चलिए इसे बताते हैं कि हमारी स्रोत फाइलें जावा 8 सिंटैक्स का पालन करती हैं, और हमें उन्हें उस संस्करण के लिए बाइटकोड में संकलित करने की आवश्यकता है। इन सभी स्टेप्स के बाद हमारा pom.xml कुछ इस तरह दिखेगा:


<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>cc.codegym.info.fatfaggy</groupId>
    <artifactId>my-super-project</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compile.source>1.8</maven.compile.source>
        <maven.compile.target>1.8</maven.compile.target>
    </properties>

    <dependencies>
        <!-- Servlet API 4.0 for tomcat 9 -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.0</version>
            <scope>provided</scope>
        </dependency>

        <!-- JavaServer Pages API 2.3 for tomcat 9 -->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>javax.servlet.jsp-api</artifactId>
            <version>2.3.1</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

</project>

हमारे सर्वलेट्स को असली सर्वलेट्स में बदलें

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

मैपिंग या मार्कअप

अब किसी तरह टॉमकैट को बताना अच्छा होगा कि / ऐड एड्रेस के लिए अनुरोध हमारे AddServlet द्वारा संसाधित किए जाते हैं , और / लिस्ट एड्रेस के लिए अनुरोध ListServlet द्वारा हैंडल किए जाते हैं । इस प्रक्रिया को मैपिंग (मार्कअप) कहा जाता है। यह उसी सिद्धांत का उपयोग करके web.xml में किया जाता है:

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

सर्वलेट का वर्णन करें:


<servlet>
    <servlet-name>add</servlet-name>
    <servlet-class>app.servlets.AddServlet</servlet-class>
</servlet>

अब इसे पते से बांधें:


<servlet-mapping>
    <servlet-name>add</servlet-name>
    <url-pattern>/add</url-pattern>
</servlet-mapping>

जैसा कि आप देख सकते हैं, सर्वलेट-नाम दोनों मामलों में समान है। परिणामस्वरूप, टॉमकैट जानता है कि यदि / ऐड के लिए अनुरोध प्राप्त होता है, तो इसे app.servlets.AddServlet को भेजा जाना चाहिए। हम दूसरे सर्वलेट के साथ भी ऐसा ही करते हैं। अंत में, हमारे web.xml में लगभग निम्नलिखित सामग्री है:


<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">

    <!-- add servlet -->
    <servlet>
        <servlet-name>add</servlet-name>
        <servlet-class>app.servlets.AddServlet</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>add</servlet-name>
        <url-pattern>/add</url-pattern>
    </servlet-mapping>

    <!-- list servlet -->
    <servlet>
        <servlet-name>list</servlet-name>
        <servlet-class>app.servlets.ListServlet</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>list</servlet-name>
        <url-pattern>/list</url-pattern>
    </servlet-mapping>
</web-app>

वैसे, हमने होम पेज (/) के लिए मार्कअप नहीं बनाया। तथ्य यह है कि हमें इस मामले में इसकी आवश्यकता नहीं है। हमारा होम पेज एक साधारण HTML फाइल है जो सिर्फ दो बटन प्रदर्शित करता है। इसकी कोई गतिशील सामग्री नहीं है, इसलिए हमें अनुरोधों के लिए एक अलग सर्वलेट बनाने की आवश्यकता नहीं है / जो हमारे लिए दो बटन बनाने के लिए कुछ जेएसपी (जिसे भी बनाना होगा) के निष्पादन के अलावा कुछ नहीं करेगा। हमें इसकी आवश्यकता नहीं है। एक स्थिर पृष्ठ हमें सूट करता है। जब टॉमकैट एक अनुरोध प्राप्त करता है, तो यह जांच करेगा कि क्या एक सर्वलेट है जो उस पते के अनुरोध को संसाधित कर सकता है, और फिर देखेगा कि इस पते में वास्तव में पहले से ही तैयार HTML फ़ाइल है, जिसे यह सर्व करेगा। हम अपने एप्लिकेशन को फिर से चला सकते हैं (सर्वर को पुनरारंभ करें या इसे फिर से तैनात करें-जो भी आप पसंद करते हैं) और सुनिश्चित करें कि होम पेज प्रदान किया गया है, कुछ भी टूटा नहीं है, और संक्रमण तब होता है जब हम बटन क्लिक करते हैं (हालांकि हमें फिर से एक त्रुटि मिलती है)। वैसे, जबकि पहले हमें 404 त्रुटि मिलती थी, अब हमें 405 मिलती है। इसका मतलब है कि मैपिंग काम कर गई और सर्वलेट पाए गए, लेकिन अनुरोध को संभालने के लिए उनके पास कोई उपयुक्त तरीका नहीं था।

लघु विषयांतर: "हुड के नीचे" क्या होता है?

आप शायद पहले ही सोच चुके हैं कि हमारा एप्लिकेशन टॉमकैट में कैसे काम करता है। वहां क्या होता है? और मुख्य() विधि कहाँ है? जैसे ही आप अपने ब्राउज़र में लोकलहोस्ट: 8080 पर जाते हैं, ब्राउज़र HTTP प्रोटोकॉल का उपयोग करके इस पते पर एक अनुरोध भेजता है। मुझे आशा है कि आप पहले से ही जानते हैं कि कई अलग-अलग प्रकार के अनुरोध हैं, और सबसे लोकप्रिय GET और POST हैं। प्रत्येक अनुरोध का उत्तर दिया जाना चाहिए। एक GET अनुरोध से ब्राउज़र पर लौटाए गए उपयोग के लिए तैयार HTML कोड की प्रतिक्रिया प्राप्त होने की उम्मीद है। ब्राउज़र तब कोड को बदल देता है जो सभी सुंदर अक्षरों, बटनों और रूपों को बदल देगा। POST अनुरोध थोड़ा अधिक दिलचस्प है, क्योंकि इसमें कुछ जानकारी भी होती है। उदाहरण के लिए, मान लीजिए कि आप किसी वेबसाइट पर पंजीकरण या साइन-इन फॉर्म में क्रेडेंशियल दर्ज करते हैं और "भेजें" पर क्लिक करते हैं। यह आपकी व्यक्तिगत जानकारी के साथ सर्वर को भेजे जाने वाले POST अनुरोध का कारण बनता है। सर्वर यह जानकारी प्राप्त करता है, इसे संसाधित करता है, और कुछ प्रतिक्रिया देता है (उदाहरण के लिए, आपकी प्रोफ़ाइल वाला एक HTML पृष्ठ)। उनके बीच मुख्य अंतर यह है कि GET अनुरोधों का उपयोग केवल सर्वर से डेटा प्राप्त करने के लिए किया जाता है, जबकि POST अनुरोधों में कुछ जानकारी होती है (और सर्वर पर डेटा बदल सकता है)। उदाहरण के लिए, जब आप अपनी तस्वीर सर्वर पर अपलोड करते हैं, तो इसे वहां एक POST रिक्वेस्ट में ले जाया जाता है और सर्वर इसे डेटाबेस में जोड़ देता है, यानी एक बदलाव होता है। अब वापस टॉमकैट पर। जब इसे क्लाइंट से अनुरोध प्राप्त होता है, तो यह पता देखता है। यह जाँचता है कि क्या उस पते के अनुरोधों को संसाधित करने के लिए एक उपयुक्त सर्वलेट है (या एक उपलब्ध संसाधन जिसे तुरंत वापस किया जा सकता है)। अगर उसे वापस करने के लिए कुछ नहीं मिलता है, तब यह HTML पृष्ठ के बजाय 404-त्रुटि के साथ प्रतिक्रिया करता है। लेकिन अगर उसे उस पते पर "बैठे" उपयुक्त सर्वलेट मिलता है, तो यह अनुरोध प्रकार (जीईटी, पोस्ट, या कुछ और) को देखता है और सर्वलेट से पूछता है कि क्या उसके पास ऐसी विधि है जो इस प्रकार की क्वेरी को संभाल सकती है। अगर सर्वलेट कहता है कि उसे नहीं पता कि इस प्रकार को कैसे संभालना है, तोटॉमकैट 405 कोड लौटाता है। और हमारे प्रोजेक्ट में बस यही हुआ। लेकिन अगर एक उपयुक्त सर्वलेट पाया जाता है, और इसकी एक उपयुक्त विधि है, तो टॉमकैट सर्वलेट ऑब्जेक्ट बनाता है, इसे एक नए थ्रेड पर शुरू करता है(जो इसे अपने आप चलने देता है), और टॉमकैट अपना काम जारी रखता है, अनुरोध स्वीकार करता है और भेजता है। इसके अतिरिक्त, टॉमकैट दो और ऑब्जेक्ट बनाता है: एक HttpServletRequest (जिसे मैं संक्षेप में "अनुरोध" कहूंगा), और एक HttpServletResponse (जिसे मैं "प्रतिक्रिया" कहूंगा)। यह क्लाइंट के अनुरोध से प्राप्त सभी डेटा को पहले ऑब्जेक्ट में डालता है, ताकि वह सभी डेटा इससे निकाला जा सके। और फिर इस सब के बाद, यह इन दो वस्तुओं को सर्वलेट के उपयुक्त तरीके से पास करता है जो एक अलग थ्रेड पर शुरू किया गया था। जैसे ही सर्वलेट अपना काम पूरा करता है और क्लाइंट को भेजे जाने के लिए एक प्रतिक्रिया तैयार होती है, यह टॉमकैट पर एक झंडा लहराता है, "मैं कर रहा हूँ। सब कुछ तैयार है"। टॉमकैट प्रतिक्रिया प्राप्त करता है और इसे क्लाइंट को भेजता है। यह टॉमकैट को अनुरोध प्राप्त करने और प्रतिक्रिया भेजने की अनुमति देता है, बिना विचलित हुए, और सारा काम अलग-अलग धागों पर चलने वाले सर्वलेट्स द्वारा किया जाता है। इसका मतलब है कि जब हम सर्वलेट कोड लिखते हैं तो हम यह निर्धारित करते हैं कि कौन सा काम किया जाएगा। और आप मुख्य() विधि को टॉमकैट के अंदर स्थित होने के बारे में सोच सकते हैं (हां, यह जावा में लिखा गया है), और जब हम टॉमकैट को "लॉन्च" करते हैं, तो मुख्य() विधि शुरू हो जाती है।

सर्वलेट्स और जेएसपी (भाग 1) - 2 का उपयोग करके एक साधारण वेब एप्लिकेशन बनाना

जीईटी विधियों को पकड़ने और सुपर सरल प्रतिक्रिया भेजने के लिए सर्वलेट्स का उपयोग करें

फिलहाल, हमारे सर्वलेट्स के पास कोई उपयुक्त तरीका (GET) नहीं है, इसलिए टॉमकैट 405 एरर देता है। आइए उन्हें बनाएं! HttpServlet क्लास, जिसे हम अपने सर्वलेट इनहेरिट करते हैं, विभिन्न तरीकों की घोषणा करता है। विधियों को विशिष्ट कोड असाइन करने के लिए, हम उन्हें ओवरराइड करते हैं। इस स्थिति में, हमें doGet()दोनों सर्वलेट्स में विधि को ओवरराइड करने की आवश्यकता है।


@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

}

जैसा कि आप देख सकते हैं, यह विधि दो तर्क लेती है: अनुरोध (अनुरोध) और प्रतिक्रिया (प्रतिक्रिया)। ये वही वस्तुएं हैं जो टॉमकैट बनाता है और हमारे लिए पॉप्युलेट करता है जब यह सर्वलेट में उपयुक्त विधि को कॉल करता है। शुरू करने के लिए, हम सबसे सरल प्रतिक्रियाएँ बनाएंगे। ऐसा करने के लिए, हम resp ऑब्जेक्ट लेंगे और उससे PrintWriter ऑब्जेक्ट प्राप्त करेंगे। प्रतिक्रिया लिखने के लिए इस प्रकार की वस्तु का उपयोग किया जाता है। हम इसका उपयोग एक साधारण स्ट्रिंग को आउटपुट करने के लिए करेंगे।


@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    PrintWriter writer = resp.getWriter();
    writer.println("GET method from AddServlet");
}

हम ListServlet में कुछ ऐसा ही करेंगे, और फिर हम अपने सर्वर को पुनरारंभ करेंगे। जैसा कि आप देख सकते हैं, सब कुछ काम करता है! जब आप बटनों पर क्लिक करते हैं, तो आपको उस पाठ के साथ पृष्ठ मिलते हैं जिसे हमने PrintWriter के साथ "लिखा" था। लेकिन जिन जेएसपी फाइलों को हमने प्रतिक्रियाओं के साथ पेज बनाने के लिए तैयार किया है, उनका उपयोग नहीं किया जा रहा है। ऐसा केवल इसलिए है क्योंकि उन्हें कभी निष्पादित नहीं किया जाता है। हमारा सर्वलेट स्वयं प्रतिक्रिया बनाता है और चलना समाप्त करता है, टॉमकैट को संकेत देता है कि यह क्लाइंट को जवाब देने के लिए तैयार है। टॉमकैट केवल प्रतिक्रिया लेता है और इसे क्लाइंट को वापस भेजता है।

आइए सर्वलेट्स से जेएसपी फाइलों पर नियंत्रण पास करें। हम अपने तरीकों का कोड इस प्रकार बदलेंगे:

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


@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    RequestDispatcher requestDispatcher = req.getRequestDispatcher("views/add.jsp");
    requestDispatcher.forward(req, resp);
}

जेएसपी पृष्ठों के बॉडी टैग में, आप कुछ जोड़ सकते हैं ताकि हम स्पष्ट रूप से देख सकें कि कौन सा पृष्ठ प्रदर्शित किया जा रहा है। एक बार ऐसा करने के बाद, सर्वर को पुनरारंभ करें और जांचें। हम मुख्य पृष्ठ पर बटन क्लिक करते हैं और पृष्ठ खुलते हैं, जिसका अर्थ है कि अनुरोध सर्वलेट्स को भेजे जा रहे हैं। फिर JSP पेजों को नियंत्रण दिया जाता है, जो अब प्रदान किए जा रहे हैं। अभी के लिए इतना ही। इस लेख के अगले भाग में , हम अपने एप्लिकेशन की कार्यक्षमता पर काम करेंगे।

अधिक पढ़ना:
सर्वलेट्स और जेएसपी (भाग 2) का उपयोग करके एक साधारण वेब एप्लिकेशन बनाना जावा सर्वलेट्स का उपयोग करते हुए आपका पहला एप्लिकेशन