CodeGym /Java Blog /यादृच्छिक /सर्व्हलेट्स आणि जेएसपी वापरून एक साधे वेब अॅप्लिकेशन तयार...

पातळी 41

San Francisco

21 July 2023
174 views
0 comments

सर्व्हलेट्स आणि जेएसपी वापरून एक साधे वेब अॅप्लिकेशन तयार करणे (भाग 1)

लेख समजून घेण्यासाठी आवश्यक ज्ञान: तुम्ही जावा कोर आधीच कमी-अधिक प्रमाणात शोधून काढला आहे आणि तुम्हाला JavaEE तंत्रज्ञान आणि वेब प्रोग्रामिंग पहायला आवडेल . तुमच्यासाठी सध्या जावा कलेक्शन क्वेस्टचा अभ्यास करणे सर्वात फायदेशीर ठरेल , जे लेखाच्या जवळच्या विषयांशी संबंधित आहे.

सर्व्हलेट्स आणि जेएसपी वापरून एक साधे वेब अॅप्लिकेशन तयार करणे (भाग १) - १

ही सामग्री माझ्या लेखाची तार्किक निरंतरता आहे IntelliJ Idea Enterprise मधील सर्वात सोपा वेब प्रकल्प तयार करणे . त्या लेखात, मी कार्यरत वेब प्रकल्प टेम्पलेट कसे तयार करावे हे दाखवले. यावेळी मी तुम्हाला Java Servlet API आणि JavaServer Pages API वापरून साधे पण पूर्णपणे आकर्षक वेब अॅप्लिकेशन कसे तयार करायचे ते दाखवणार आहे . आमच्या अर्जात दोन लिंक्स असलेले मुख्यपृष्ठ असेल:

वापरकर्ते जोडण्यासाठी पृष्ठाचा दुवा;
वापरकर्त्यांच्या यादीची लिंक.

पूर्वीप्रमाणे, मी IntelliJ Idea Enterprise Edition , Apache Maven (आम्ही फक्त काही अवलंबन जोडू) आणि Apache Tomcat वापरेन . शेवटी, आम्ही W3.CSS फ्रेमवर्क वापरून आमचा अनुप्रयोग "सुशोभित" करू. आम्ही असे गृहीत धरू की तुमच्याकडे आधीच एक रिकामा प्रकल्प आहे जो आम्ही आता जोडू. नसल्यास, पहिला लेख पहा आणि एक बनवा. यास फक्त काही मिनिटे लागतील :)

आमच्या भविष्यातील अनुप्रयोगाच्या संरचनेबद्दल थोडेसे

आमचे मुख्यपृष्ठ (/) हेडर आणि दोन लिंक्स/बटन्ससह सर्वात सामान्य स्थिर HTML पृष्ठ असेल :

एक नवीन वापरकर्ता जोडा (नॅव्हिगेट / जोडा );
वापरकर्त्यांची सूची पहा (नेव्हिगेट / सूची ).

टॉमकॅट या पत्त्यांसाठी विनंत्या पकडेल आणि आम्ही बनवणार आहोत त्या दोन सर्व्हलेटपैकी एकावर पाठवेल (आम्ही web.xml मध्ये मॅपिंग निर्दिष्ट करू ). सर्व्हलेट्स नंतर विनंत्यांवर प्रक्रिया करतील, डेटा तयार करतील (किंवा डेटा सेव्ह करतील, जर आम्ही वापरकर्ता जोडत असाल तर), आणि योग्य JSP फाइल्सवर नियंत्रण हस्तांतरित करतील , जे नंतर परिणाम "रेंडर" करेल. आम्ही डेटा एका साध्या व्हॅनिला सूचीमध्ये (सूची) संग्रहित करू.

एक स्थिर मुख्यपृष्ठ तयार करा

तुम्ही तुमच्या वेब फोल्डरमध्ये 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 आहेत: शीर्षलेख आणि सामग्री . सामग्री div मध्ये आमच्या बटणांसाठी एक धारक समाविष्ट आहे. आणि तिथे आमच्याकडे दोन बटणे आहेत जी तुम्हाला एका क्लिकवर संबंधित पत्त्यावर घेऊन जातात. तुम्ही प्रकल्प चालवू शकता आणि आता ते कसे दिसते ते पाहू शकता. तुम्ही बटणावर क्लिक केल्यास, तुम्हाला 404-त्रुटी पृष्ठे मिळतील, कारण आम्ही संबंधित पृष्ठे अद्याप अस्तित्वात नाही. परंतु बटणे कार्य करतात हे आपण सांगू शकतो. लक्षात घ्या की हा सर्वात सार्वत्रिक दृष्टीकोन नाही: जर ब्राउझरमध्ये JavaScript बंद असेल, तर ही बटणे कार्य करणार नाहीत. परंतु आम्ही असे गृहीत धरू की कोणीही JavaScript अक्षम करत नाही. :) साहजिकच, तुम्ही साध्या दुव्यांद्वारे मिळवू शकता, परंतु मी बटणांना प्राधान्य देतो. तुम्हाला आवडेल तसे तुम्ही करू शकता. आणि त्याबद्दल काळजी करू नका की माझ्या उदाहरणांमध्ये बरेच divs असतील . आम्ही त्यांना नंतर शैलींनी भरू, आणि सर्वकाही अधिक सुंदर दिसेल. :)

परिणाम रेंडर करण्यासाठी JSP फाइल्स तयार करा

त्याच वेब निर्देशिकेत, एक फोल्डर तयार करा जिथे आम्ही आमच्या JSP फाइल्स जोडू . मी त्याला ' दृश्ये ' म्हटले आहे, परंतु पुन्हा एकदा तुम्ही सुधारू शकता. या फोल्डरमध्ये, आम्ही दोन JSP फाइल्स तयार करू:

add.jsp — वापरकर्ते जोडण्यासाठी पृष्ठ;
list.jsp — वापरकर्त्यांची यादी प्रदर्शित करण्यासाठी पृष्ठ.

त्यांना योग्य पृष्ठ शीर्षलेख नियुक्त करा. " नवीन वापरकर्ता जोडा " आणि " वापरकर्ता सूची " सारखे काहीतरी , आणि आम्ही ते तसे सोडू.

दोन सर्व्हलेट तयार करा

सर्व्हलेट्स टॉमकॅटने पाठवलेल्या विनंत्या प्राप्त करतील आणि त्यावर प्रक्रिया करतील . src/main/java फोल्डरमध्ये , अॅप पॅकेज तयार करा, जिथे आम्ही आमचा सोर्स कोड ठेवू. इतर पॅकेजेसही तिथे जातील. त्यामुळे, ही पॅकेजेस एकमेकांमध्ये तयार होण्यापासून रोखण्यासाठी, आम्ही अॅप पॅकेजमध्ये काही वर्ग तयार करू (आम्ही ते नंतर हटवू). आता अॅप पॅकेजमध्ये तीन भिन्न पॅकेज तयार करा :

संस्था — आमच्या संस्था (वापरकर्त्याच्या वस्तूंचे वर्णन करणारा वर्ग) येथे जा;
मॉडेल - येथे आमचे मॉडेल जाते (आम्ही याबद्दल थोड्या वेळाने बोलू);
servlets — आणि इथेच आमचे servlets जातात.

एकदा तुम्ही हे पूर्ण केल्यावर, तुम्ही तो वर्ग अ‍ॅप पॅकेजमधून शांतपणे हटवू शकता (जर तुम्ही तो तयार केला असेल तर). सर्व्हलेट्स पॅकेजमध्ये , दोन वर्ग तयार करा:

AddServlet — कडे / जोडण्यासाठी पाठवलेल्या विनंत्या प्रक्रिया करते ;
ListServlet — / सूचीला पाठवलेल्या विनंत्यांवर प्रक्रिया करते .

Maven मध्ये अवलंबित्व कनेक्ट करणे

Tomcat 9 .* सर्व्हलेट 4.0 आणि JavaServer पृष्ठे 2.3 साठी तपशील लागू करते . टॉमकॅट 9 च्या अधिकृत दस्तऐवजीकरणाच्या पहिल्या परिच्छेदाच्या दुसऱ्या ओळीत तेच सांगितले आहे . याचा अर्थ असा की जर तुम्ही, माझ्याप्रमाणे, Tomcat ची ही आवृत्ती वापरत असाल , तर तुम्ही जो कोड लिहू आणि चालवाल तो या आवृत्त्या वापरेल. परंतु आम्हाला आमच्या प्रकल्पात ही वैशिष्ट्ये हवी आहेत, जेणेकरून आमचा कोड, जो त्यांचा वापर करतो, किमान यशस्वीरित्या संकलित होईल. आणि हे करण्यासाठी, आम्हाला ते आमच्या प्रकल्पात लोड करणे आवश्यक आहे. येथेच मावेन बचावासाठी येतो.

सामान्य नियम हा आहे: जर तुम्हाला Maven वापरून तुमच्या प्रोजेक्टशी काहीतरी जोडायचे असेल तर:

मावेन वरून रेपॉजिटरी वेबसाइटवर जा;
आवश्यक लायब्ररीच्या आवश्यक आवृत्तीसाठी शोधा;
अवलंबित्व कोड मिळवा जो तुमच्या pom.xml मध्ये पेस्ट करणे आवश्यक आहे;
पेस्ट करा :)

चला सुरवात करूया. प्रथम, POM फाइल तयार करा . /version एंट्री नंतर कुठेतरी , परंतु /project च्या आधी , खालील समाविष्ट करा:


<dependencies>

</dependencies>

आम्ही हे सूचित करण्यासाठी करतो की आम्ही या टॅगमध्ये आवश्यक अवलंबनांची यादी करू. आता mvnrepository.com वर जा . शीर्षस्थानी एक शोध फील्ड आहे. सुरू करण्यासाठी, ' servlet ' शोधा . पहिला निकाल, जो सात हजाराहून अधिक वेळा वापरला गेला आहे, तो आम्हाला अनुकूल आहे. लक्षात ठेवा, आम्हाला आवृत्ती 4.0 ( टॉमकॅट 9 साठी). इतर आवृत्त्या जुन्या अंमलबजावणीसाठी योग्य असू शकतात. ही बर्‍यापैकी अलीकडील आवृत्ती आहे, त्यामुळे इतके उपयोग नाहीत. पण आपल्याला त्याची गरज आहे. एक पृष्ठ उघडेल जिथे तुम्हाला विविध पॅकेज व्यवस्थापकांसाठी या अवलंबनासाठी कोड मिळेल किंवा तुम्ही ते डाउनलोड करू शकता. परंतु आम्हाला ते Maven वापरून कनेक्ट करायचे असल्याने, आम्ही Maven टॅबवरील कोड निवडू. आम्ही आमच्या POM फाइलच्या अवलंबन विभागात कॉपी आणि पेस्ट करतो. तुम्हाला IDEA च्या खालच्या उजव्या कोपर्यात स्वयं-इम्पोर्ट सक्षम करायचे आहे का असे विचारणारी सूचना मिळाल्यास , पुढे जा आणि त्यास सहमती द्या. तुम्ही चुकून नकार दिल्यास, " सेटिंग्ज " वर जा आणि स्वहस्ते स्वयं-आयात चालू करा: सेटिंग्ज (Ctrl + Alt + S) -> बिल्ड, एक्झिक्यूशन, डिप्लॉयमेंट -> मावेन -> इंपोर्टिंग .आणि या प्रकल्पासाठी IDEA कॉन्फिगरेशन फाइल्स समक्रमित आहेत. त्याच तत्त्वाचे अनुसरण करून, आम्ही JavaServer पृष्ठे 2.3 शोधू आणि कनेक्ट करू ("JSP" साठी शोधा). आणि आम्ही आधीच मावेन सुरू केल्यामुळे, आमच्या स्त्रोत फाइल्स Java 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>

आमच्या सर्व्हलेट्सना वास्तविक सर्व्हलेट्स बनवा

या क्षणी, आम्ही तयार केलेली सर्व्हलेटची जोडी प्रत्यक्षात सामान्य वर्ग आहेत. त्यांच्याकडे कोणतीही कार्यक्षमता नाही. पण आता आम्ही सर्व्हलेट API आमच्या प्रकल्पाशी जोडले आहे, आणि त्यानुसार आम्ही त्याचे वर्ग वापरू शकतो. आमची सर्व्हलेट्स "वास्तविक" बनवण्यासाठी, आम्हाला फक्त त्यांना 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>

तुम्ही बघू शकता, सर्वलेट-नाव दोन्ही प्रकरणांमध्ये समान आहे. परिणामी, Tomcat ला माहित आहे की/add साठी विनंती प्राप्त झाल्यास, ती 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 फाइल आहे जी फक्त दोन बटणे दाखवते. यात कोणतीही डायनॅमिक सामग्री नाही, त्यामुळे आम्हाला दोन बटणे काढण्यासाठी काही JSP (ज्याला तयार करावे लागेल) कडून केलेल्या विनंत्यांसाठी वेगळे सर्व्हलेट तयार करण्याची आवश्यकता नाही . आम्हाला याची गरज नाही. एक स्थिर पृष्ठ आम्हाला अनुकूल आहे. जेव्हा Tomcat ला विनंती प्राप्त होते, तेव्हा ते त्या पत्त्याच्या विनंतीवर प्रक्रिया करू शकणारे एकल सर्व्हलेट आहे की नाही हे तपासेल आणि नंतर या पत्त्यामध्ये आधीच तयार HTML फाइल आहे हे दिसेल., जे ते सर्व्ह करेल. आम्ही आमचा ऍप्लिकेशन पुन्हा चालवू शकतो (सर्व्हर रीस्टार्ट करा किंवा ते पुन्हा डिप्लॉय करू शकता—तुम्ही जे पसंत कराल ते) आणि होम पेज रेंडर केले आहे याची खात्री करा, काहीही तुटलेले नाही आणि जेव्हा आम्ही बटणे क्लिक करतो तेव्हा संक्रमणे होतात (जरी आम्हाला पुन्हा त्रुटी आली). तसे, पूर्वी आम्हाला 404 त्रुटी आली होती, आता आम्हाला 405 मिळते. याचा अर्थ मॅपिंगने कार्य केले आणि सर्व्हलेट्स सापडले, परंतु विनंती हाताळण्यासाठी त्यांच्याकडे कोणतीही योग्य पद्धत नव्हती.

लहान विषयांतर: "हुड अंतर्गत" काय होते?

आमचा अनुप्रयोग टॉमकॅटमध्ये कसा कार्य करतो याबद्दल आपण आधीच विचार केला असेल. तिथे काय होते? आणि main() पद्धत कुठे आहे? तुम्ही तुमच्या ब्राउझरमध्ये लोकलहोस्ट:8080 वर जाताच, ब्राउझर HTTP प्रोटोकॉल वापरून या पत्त्यावर विनंती पाठवतो. मला आशा आहे की तुम्हाला आधीच माहिती असेल की अनेक प्रकारच्या विनंत्या आहेत आणि सर्वात लोकप्रिय म्हणजे GET आणि POST. प्रत्येक विनंतीला उत्तर दिले पाहिजे. GET विनंतीला ब्राउझरवर परत आलेल्या, वापरण्यासाठी तयार HTML कोडचा प्रतिसाद मिळणे अपेक्षित आहे. ब्राउझर नंतर कोड बदलेल सर्व सुंदर अक्षरे, बटणे आणि फॉर्म. POST विनंती थोडी अधिक मनोरंजक आहे, कारण त्यात काही माहिती देखील असते. उदाहरणार्थ, समजा तुम्ही वेबसाइटवर नोंदणी किंवा साइन-इन फॉर्ममध्ये क्रेडेन्शियल एंटर केले आणि "पाठवा" क्लिक करा. यामुळे तुमच्या वैयक्तिक माहितीसह POST विनंती सर्व्हरला पाठवली जाते. सर्व्हर ही माहिती प्राप्त करतो, त्यावर प्रक्रिया करतो आणि काही प्रतिसाद देतो (उदाहरणार्थ, आपल्या प्रोफाइलसह HTML पृष्ठ). त्यांच्यातील मुख्य फरक असा आहे की GET विनंत्या फक्त सर्व्हरवरून डेटा पुनर्प्राप्त करण्यासाठी वापरल्या जातात, तर POST विनंत्यामध्ये काही माहिती असते (आणि सर्व्हरवरील डेटा बदलू शकतो). उदाहरणार्थ, जेव्हा तुम्ही तुमचे चित्र सर्व्हरवर अपलोड करता, तेव्हा ते POST विनंतीमध्ये नेले जाते आणि सर्व्हर ते डेटाबेसमध्ये जोडते, म्हणजे बदल होतो. आता टॉमकॅटकडे परत. जेव्हा त्याला क्लायंटकडून विनंती प्राप्त होते, तेव्हा तो पत्ता पाहतो. त्या पत्त्यासाठी विनंत्यांवर प्रक्रिया करण्यासाठी योग्य सर्व्हलेट आहे की नाही हे तपासते (किंवा उपलब्ध संसाधन जे त्वरित परत केले जाऊ शकते). परत करण्यासारखे काही सापडले नाही तर, मग ते HTML पृष्ठाऐवजी 404-त्रुटीसह प्रतिसाद देते. परंतु जर त्याला त्या पत्त्यावर एक योग्य सर्व्हलेट "बसलेले" आढळले, तर ते विनंती प्रकार (GET, POST किंवा दुसरे काहीतरी) पाहते आणि सर्व्हलेटला विचारते की या प्रकारची क्वेरी हाताळू शकेल अशी पद्धत आहे का. जर सर्व्हलेट म्हणत असेल की हा प्रकार कसा हाताळायचा हे माहित नाही, तरटॉमकॅट 405 कोड परत करतो. आणि आमच्या प्रकल्पात हेच घडले आहे. परंतु जर एक योग्य सर्व्हलेट सापडला आणि त्यात एक योग्य पद्धत असेल, तर टॉमकॅट एक सर्व्हलेट ऑब्जेक्ट तयार करतो, नवीन थ्रेडवर सुरू करतो.(जे ते स्वतः चालवू देते), आणि Tomcat स्वतःचे काम चालू ठेवते, विनंत्या स्वीकारणे आणि पाठवणे. याव्यतिरिक्त, Tomcat आणखी दोन ऑब्जेक्ट्स तयार करते: एक HttpServletRequest (ज्याला मी थोडक्यात "विनंती" म्हणेन), आणि एक HttpServletResponse (ज्याला मी "प्रतिसाद" म्हणेन). तो क्लायंटच्या विनंतीवरून प्राप्त झालेला सर्व डेटा पहिल्या ऑब्जेक्टमध्ये ठेवतो, जेणेकरून तो सर्व डेटा त्यातून काढला जाऊ शकतो. आणि मग हे सर्व केल्यानंतर, ते या दोन वस्तू वेगळ्या धाग्यावर सुरू केलेल्या सर्व्हलेटच्या योग्य पद्धतीकडे पाठवते. सर्व्हलेटने आपले काम पूर्ण केल्यावर आणि क्लायंटला पाठवण्‍यासाठी प्रतिसाद तयार होताच, ते "माझे पूर्ण झाले. सर्वकाही तयार आहे" असे म्हणत टॉमकॅटवर ध्वज फडकवते. टॉमकॅटला प्रतिसाद मिळतो आणि तो क्लायंटला पाठवतो. हे टॉमकॅटला विनंत्या प्राप्त करू देते आणि प्रतिसाद पाठवू देते, विचलित न होता, आणि सर्व काम वेगळ्या धाग्यांवर चालणाऱ्या सर्व्हलेट्सद्वारे केले जाते. याचा अर्थ असा की जेव्हा आपण सर्व्हलेट कोड लिहितो तेव्हा कोणते कार्य केले जाईल हे आपण ठरवतो. आणि तुम्ही main() पद्धतीचा विचार करू शकता की ती Tomcat मध्ये स्थित आहे (होय, ते Java मध्ये लिहिलेले आहे), आणि जेव्हा आम्ही Tomcat "लाँच" करतो तेव्हा main() पद्धत सुरू होते.

सर्व्हलेट्स आणि जेएसपी वापरून एक साधा वेब अॅप्लिकेशन तयार करणे (भाग 1) - 2

GET पद्धती पकडण्यासाठी सर्व्हलेट्स वापरा आणि अतिशय सोप्या प्रतिसाद पाठवा

याक्षणी, आमच्या सर्व्हलेट्समध्ये योग्य पद्धती नाहीत (GET), त्यामुळे Tomcat 405 त्रुटी परत करते. चला त्यांना तयार करूया! HttpServlet वर्ग, आमच्या सर्व्हलेट्स वारसा घेतो, विविध पद्धती घोषित करतो. पद्धतींना विशिष्ट कोड नियुक्त करण्यासाठी, आम्ही त्यांना फक्त ओव्हरराइड करतो. या प्रकरणात, आम्हाला doGet()दोन्ही सर्व्हलेट्समध्ये पद्धत ओव्हरराइड करणे आवश्यक आहे.


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

}

तुम्ही बघू शकता, ही पद्धत दोन युक्तिवाद घेते: req (विनंती) आणि resp (प्रतिसाद). या अशाच वस्तू आहेत ज्या टॉमकॅट आपल्यासाठी तयार करतो आणि पॉप्युलेट करतो जेव्हा तो सर्व्हलेटमध्ये योग्य पद्धत कॉल करतो. सुरू करण्यासाठी, आम्ही सर्वात सोपा प्रतिसाद तयार करू. हे करण्यासाठी, आम्ही 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 पेजचा पत्ता पास करतो ज्यावर आम्ही कंट्रोल ट्रान्सफर करू इच्छितो;
आम्ही या ऑब्जेक्टचा वापर निर्दिष्ट JSP पृष्ठावर नियंत्रण हस्तांतरित करण्यासाठी करतो, आम्हाला Tomcat कडून प्राप्त विनंती आणि प्रतिसाद ऑब्जेक्ट्स पास करण्यास विसरत नाही.


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

JSP पृष्ठांच्या मुख्य टॅगमध्ये, आपण काहीतरी जोडू शकता जेणेकरून कोणते पृष्ठ प्रदर्शित केले जात आहे ते आम्ही स्पष्टपणे पाहू शकतो. एकदा आपण ते पूर्ण केल्यावर, सर्व्हर रीस्टार्ट करा आणि तपासा. आम्ही मुख्य पृष्ठावरील बटणावर क्लिक करतो आणि पृष्ठे उघडतात, याचा अर्थ सर्व्हलेटवर विनंत्या पाठवल्या जात आहेत. नंतर नियंत्रण जेएसपी पृष्ठांवर पास केले जाते, जे आता प्रस्तुत केले जात आहे. सध्या एवढेच. या लेखाच्या पुढील भागात , आम्ही आमच्या अनुप्रयोगाच्या कार्यक्षमतेवर कार्य करू.

अधिक वाचन:
सर्व्हलेट्स आणि जेएसपी वापरून एक साधा वेब अॅप्लिकेशन तयार करणे (भाग 2) Java servlets वापरून तुमचा पहिला अनुप्रयोग

टिप्पण्या

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION