CodeGym /جاوا بلاگ /Random-SD /servlets ۽ JSPs استعمال ڪندي هڪ سادي ويب ايپليڪيشن ٺاهڻ (...

سطح

San Francisco

14 February 2023
40 views
0 comments

servlets ۽ JSPs استعمال ڪندي هڪ سادي ويب ايپليڪيشن ٺاهڻ (حصو 1)

مضمون کي سمجھڻ لاءِ علم جي ضرورت آھي: توھان اڳ ۾ ئي جاوا ڪور کي وڌيڪ يا گھٽ ڄاڻايو آھي ۽ توھان کي ڏسڻ چاھيو ٿا JavaEE ٽيڪنالاجيز ۽ ويب پروگرامنگ . اهو توهان لاءِ سڀ کان وڌيڪ معنيٰ رکي ٿو ته توهان هن وقت جاوا ڪليڪشن جي ڳولا جو مطالعو ڪري رهيا آهيو ، جيڪو مضمون جي ويجهو موضوعن سان واسطو رکي ٿو.

هي مواد منهنجي آرٽيڪل جو منطقي تسلسل آهي IntelliJ Idea Enterprise ۾ آسان ويب پروجيڪٽ ٺاهڻ . انهي آرٽيڪل ۾، مون ڏيکاريو ته ڪم ڪندڙ ويب پروجيڪٽ ٽيمپليٽ ڪيئن ٺاهيو. هن ڀيري مان توهان کي ڏيکاريندس ته ڪيئن ٺاهيو هڪ سادي پر مڪمل طور تي پرڪشش ويب ايپليڪيشن استعمال ڪندي Java Servlet API ۽ JavaServer Pages API . اسان جي ائپليڪيشن ۾ ٻه لنڪس سان گڏ هڪ هوم پيج هوندو:

صارفين کي شامل ڪرڻ لاء هڪ صفحي جي لنڪ؛
استعمال ڪندڙن جي فهرست جي لنڪ.

جيئن اڳ ۾، مان استعمال ڪندس IntelliJ Idea Enterprise Edition ، Apache Maven (اسان صرف ڪجهه انحصار کي ڳنڍينداسين)، ۽ Apache Tomcat . آخر ۾، اسان W3.CSS فريم ورڪ کي استعمال ڪندي اسان جي ايپليڪيشن کي "خوبصورت" ڪنداسين. اسان فرض ڪنداسين ته توهان وٽ اڳ ۾ ئي هڪ خالي منصوبو آهي جيڪو اسان هاڻي شامل ڪنداسين. جيڪڏهن نه، پهرين آرٽيڪل ذريعي هلائي ۽ هڪ ٺاهيو. اهو صرف چند منٽ وٺندو :)

اسان جي مستقبل جي ايپليڪيشن جي جوڙجڪ بابت ٿورو

اسان جو هوم پيج (/) هڪ تمام عام جامد HTML صفحو هوندو جنهن ۾ هيڊر ۽ ٻه لنڪس/بٽن:

نئون استعمال ڪندڙ شامل ڪريو (نيويگيٽ ڪرڻ / شامل ڪريو )؛
استعمال ڪندڙن جي لسٽ ڏسو (نويگيٽس ڏانھن / فهرست ).

Tomcat انهن ايڊريس لاءِ درخواستون پڪڙيندو ۽ انهن کي انهن ٻن سرورن مان هڪ ڏانهن موڪليندو جيڪي اسان ٺاهڻ وارا آهيون (اسين ميپنگ کي web.xml ۾ بيان ڪنداسين ). سرورٽ پوءِ درخواستن تي عمل ڪندا، ڊيٽا تيار ڪندا (يا ڊيٽا محفوظ ڪندا، جيڪڏھن اسان صارف شامل ڪري رھيا آھيون)، ۽ ڪنٽرول کي مناسب JSP فائلن ڏانھن منتقل ڪندا ، جيڪي پوءِ نتيجو "render" ڪندا. اسان ڊيٽا کي هڪ سادي وينلا لسٽ (فهرست) ۾ ذخيرو ڪنداسين.

هڪ مستحڪم هوم صفحو ٺاهيو

جيڪڏهن توهان پنهنجي ويب فولڊر ۾ 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>

هتي ڪجھ به پيچيده ناهي. عنوان جي ٽيگ ۾ ، اسان اسان جي صفحي جو عنوان ظاهر ڪندا آهيون. صفحي جي جسم ۾، اسان وٽ ٻه مکيه ڊويزنون آهن: هيڊر ۽ مواد . مواد ڊيو ۾ اسان جي بٽڻ لاء هڪ هولڊر شامل آهي. ۽ اتي اسان وٽ ٻه بٽڻ آھن جيڪي توھان کي ھڪڙي ڪلڪ سان لاڳاپيل ايڊريس ڏانھن وٺي ويندا آھن. توهان پروجيڪٽ کي هلائي سگهو ٿا ۽ ڏسو ته اهو ڪيئن ڏسڻ ۾ اچي ٿو. جيڪڏھن توھان بٽڻ تي ڪلڪ ڪندا، توھان کي 404-غلطي وارا صفحا ملندا ، ڇاڪاڻ ته اسان سان لاڳاپيل صفحا اڃا موجود نه آھن. پر اسان ٻڌائي سگهون ٿا ته بٽڻ ڪم ڪن ٿا. نوٽ ڪريو ته هي سڀ کان وڌيڪ آفاقي طريقو ناهي: جيڪڏهن برائوزر ۾ JavaScript بند آهي ته پوءِ اهي بٽڻ ڪم نه ڪندا. پر اسان فرض ڪنداسين ته ڪو به جاوا اسڪرپٽ کي غير فعال نٿو ڪري. :) ظاهر آهي، توهان حاصل ڪري سگهو ٿا سادو لنڪس سان، پر مان ترجيح ڏيان ٿو بٽڻن سان. توهان اهو ڪري سگهو ٿا جڏهن توهان چاهيو ٿا. ۽ انهي حقيقت جي باري ۾ پريشان نه ڪريو ته منهنجي مثالن ۾ تمام گهڻو divs هوندو . اسان انهن کي بعد ۾ انداز سان ڀرينداسين، ۽ هر شيء وڌيڪ خوبصورت نظر ايندي. :)

نتيجو پيش ڪرڻ لاءِ JSP فائلون ٺاھيو

ساڳئي ويب ڊاريڪٽري ۾، هڪ فولڊر ٺاهيو جتي اسان شامل ڪنداسين JSP فائلون . مون ان کي سڏيو ' نظريا '، پر هڪ ڀيرو ٻيهر توهان بهتر ڪري سگهو ٿا. هن فولڊر ۾، اسان ٻه JSP فائلون ٺاهي سگهون ٿا:

add.jsp - صارفين کي شامل ڪرڻ لاء هڪ صفحو؛
list.jsp - صفحو استعمال ڪندڙن جي لسٽ ڏيکارڻ لاءِ.

انهن کي مناسب صفحو هيڊر ڏيو. ڪجھ " نئون يوزر شامل ڪريو " ۽ " يوزر لسٽ " وانگر، ۽ اسان ان کي ڇڏي ڏينداسين.

ٻه servlets ٺاهيو

Servlets وصول ڪندا ۽ درخواستن تي عمل ڪندا جيڪي Tomcat موڪليندا آھن. src/main/java فولڊر ۾ ، ايپ پيڪيج ٺاهيو ، جتي اسان پنهنجو سورس ڪوڊ رکون ٿا. ٻيا پيڪيج به اتي ويندا. تنهن ڪري، انهن پيڪيجز کي هڪ ٻئي جي اندر پيدا ٿيڻ کان روڪڻ لاء، اسان ايپ پيڪيج ۾ ڪجهه ڪلاس ٺاهينداسين (اسان ان کي بعد ۾ حذف ڪنداسين). ھاڻي ٺاھيو ٽي مختلف پيڪيجز ايپ پيڪيج ۾:

entities - اسان جا ادارا (جنهن طبقي کي بيان ڪري ٿو استعمال ڪندڙ شيون) هتي وڃو؛
ماڊل - هي آهي جتي اسان جو ماڊل وڃي ٿو (اسان ان بابت ٿوري دير بعد ڳالهائينداسين)؛
servlets - ۽ هي آهي جتي اسان جي servlets وڃو.

هڪ دفعو توهان اهو ڪيو آهي، توهان آرام سان ان ڪلاس کي ايپ پيڪيج مان حذف ڪري سگهو ٿا (جيڪڏهن توهان ان کي ٺاهيو، يقينا). servlets پيڪيج ۾ ، ٻه طبقو ٺاهيو:

AddServlet - پروسيس جي درخواستن کي موڪليو ويو / شامل ڪريو ؛
ListServlet - / فهرست ڏانهن موڪليل درخواستن تي عمل ڪري ٿو .

Maven ۾ انحصار کي ڳنڍڻ

Tomcat 9 . * سرورليٽ 4.0 ۽ جاوا سرور صفحا 2.3 لاءِ وضاحتون لاڳو ڪري ٿو اھو اھو آھي جيڪو Tomcat 9 جي سرڪاري دستاويزن جي پھرين پيراگراف جي ٻئي لائن ۾ بيان ڪيو ويو آھي . هن جو مطلب اهو آهي ته جيڪڏهن توهان، مون وانگر، استعمال ڪريو Tomcat جو هي نسخو ، پوء ڪوڊ جيڪو توهان لکندا ۽ هلائيندا اهي نسخو استعمال ڪندا. پر اسان چاهيون ٿا ته اهي وضاحتون اسان جي پروجيڪٽ ۾ هجن، ته جيئن اسان جو ڪوڊ، جيڪو انهن کي استعمال ڪري، گهٽ ۾ گهٽ ڪاميابيءَ سان مرتب ڪري. ۽ هن کي ڪرڻ لاء، اسان کي انهن کي اسان جي منصوبي ۾ لوڊ ڪرڻو پوندو. هي آهي جتي Maven بچاء لاء اچي ٿو.

عام اصول هي آهي: جيڪڏهن توهان کي پنهنجي منصوبي سان ڪجهه ڳنڍڻ جي ضرورت آهي Maven استعمال ڪندي:

Maven کان مخزن جي ويب سائيٽ ڏانهن وڃو؛
گھربل لائبريري جي گھربل ورجن لاءِ ڳولھيو؛
انحصار ڪوڊ حاصل ڪريو جيڪو توهان جي pom.xml ۾ پيسٽ ڪرڻ جي ضرورت آهي؛
پيسٽ ڪريو :)

اچو ته شروع ڪريون. پهرين، POM فائل تيار ڪريو . /version جي داخلا کان پوءِ ڪٿي ، پر /project کان اڳ ، ھيٺيون داخل ڪريو:

<dependencies>

</dependencies>

اسان اهو ظاهر ڪرڻ لاءِ ڪندا آهيون ته اسان انهن ٽيگ اندر گهربل انحصار کي لسٽ ڪنداسين. ھاڻي وڃو mvnrepository.com تي . مٿي تي هڪ ڳولا جو ميدان آهي. شروع ڪرڻ لاءِ، ڳولھيو ' servlet '. پهريون نتيجو، جيڪو ست هزار ڀيرا استعمال ڪيو ويو آهي، اسان کي مناسب آهي. ياد رکو، اسان کي نسخو 4.0 جي ضرورت آهي ( Tomcat 9 لاءِ ). ٻيا نسخا شايد پراڻن عملن لاءِ مناسب هوندا. اھو ھڪڙو تازو نسخو آھي، تنھنڪري اتي ڪيترائي استعمال نه آھن. پر اسان کي ان جي ضرورت آهي. ھڪڙو صفحو کوليندو آھي جتي توھان حاصل ڪري سگھوٿا ھن انحصار لاءِ ڪوڊ مختلف پيڪيج مينيجرز لاءِ، يا توھان ان کي ڊائون لوڊ ڪري سگھوٿا. پر جيئن ته اسان ان کي Maven استعمال ڪندي ڳنڍڻ چاهيون ٿا، اسان Maven ٽيب تي ڪوڊ چونڊيندا سين. اسان پنهنجي POM فائل جي انحصار واري حصي ۾ ڪاپي ۽ پيسٽ ڪريون ٿا. جيڪڏهن توهان هڪ نوٽيفڪيشن حاصل ڪيو ته پڇو ته ڇا توهان IDEA جي هيٺئين ساڄي ڪنڊ ۾ خودڪار درآمد کي فعال ڪرڻ چاهيو ٿا ، اڳتي وڌو ۽ ان سان متفق ٿيو. جيڪڏهن توهان اتفاقي طور تي انڪار ڪيو، " سيٽنگون " ڏانهن وڃو ۽ خودڪار درآمد کي دستي طور تي چالو ڪريو: سيٽنگون (Ctrl + Alt + S) -> تعمير، عمل، ترتيب -> Maven -> درآمد . هي توهان کي اجازت ڏيندو POM فائل ۽ IDEA ڪنفيگريشن فائلن کي هن پروجيڪٽ لاءِ هم وقت سازي ۾. ساڳئي اصول تي عمل ڪندي، اسان جاوا سرور صفحا 2.3 ڳوليندا ۽ ڳنڍيندا سين (جي ايس پي جي ڳولا). ۽ جيئن ته اسان اڳ ۾ ئي Maven شروع ڪري ڇڏيو آهي، اچو ته صرف ان کي ٻڌايو ته اسان جا سورس فائلون جاوا 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>

اسان جي servlets کي حقيقي servlets ۾ ٺاهيو

هن وقت، اسان ٺاهيل سروليٽ جو جوڙو اصل ۾ عام طبقو آهي. انهن وٽ ڪا به ڪارڪردگي نه آهي. پر ھاڻي اسان Servlet API کي پنھنجي پروجيڪٽ سان ڳنڍيو آھي، ۽ ان مطابق اسين ان جا ڪلاس استعمال ڪري سگھون ٿا. اسان جي servlets کي "حقيقي" بنائڻ لاء، اسان کي صرف انهن کي HttpServlet ڪلاس جو وارث بڻائڻ جي ضرورت آهي .

ميپنگ يا مارڪ اپ

ھاڻي اھو سٺو لڳندو ته ڪنھن طرح Tomcat کي ٻڌايان ته / add ايڊريس لاءِ درخواستون اسان جي AddServlet پاران پروسيس ڪيون وينديون آھن ، ۽ / لسٽ ايڊريس لاءِ درخواستون لسٽ سرورٽ پاران سنڀاليون وينديون آھن . انهي عمل کي ميپنگ (مارڪ اپ) سڏيو ويندو آهي. اهو ساڳيو اصول استعمال ڪندي web.xml ۾ ڪيو ويندو آهي:

شروع ڪرڻ لاءِ، بيان ڪريو servlet (ڪجهه نالو ڏيو ۽ ڪلاس ڏانهن رستو بيان ڪريو)؛
پوءِ ھن servlet کي ھڪڙي مخصوص ايڊريس تي پابند ڪريو (سروليٽ جو نالو بيان ڪريو، جيڪو اسان صرف ڏنو آھي، ۽ پتو بيان ڪريو جنھن جون درخواستون ھن سرورليٽ ڏانھن موڪليون وڃن).

بيان ڪريو 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>

جئين توهان ڏسي سگهو ٿا، servlet-name ٻنهي صورتن ۾ ساڳيو آهي. نتيجي طور، Tomcat ڄاڻي ٿو ته جيڪڏهن /add لاءِ درخواست ملي ٿي، ان کي موڪليو وڃي app.servlets.AddServlet. اسان ٻئي servlet سان ساڳيو ڪم ڪندا آهيون. آخر ۾، اسان جي 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 ملي ٿو. مطلب ته نقشي تي ڪم ڪيو ويو ۽ سرور لڌو ويو، پر انهن وٽ درخواست کي سنڀالڻ لاء ڪو مناسب طريقو نه هو.

مختصر تڪرار: ڇا ٿيندو "هوڊ هيٺ"؟

توهان شايد اڳ ۾ ئي سوچيو هوندو ته ڪيئن اسان جي ايپليڪيشن Tomcat ۾ ڪم ڪري ٿي. اتي ڇا ٿو ٿئي؟ ۽ مکيه () طريقو ڪٿي آهي؟ جيئن ئي توهان وڃو localhost:8080 توهان جي برائوزر ۾، برائوزر هن ايڊريس تي HTTP پروٽوڪول استعمال ڪندي هڪ درخواست موڪلي ٿو. مون کي اميد آهي ته توهان اڳ ۾ ئي واقف آهيو ته درخواستن جا ڪيترائي مختلف قسم آهن، ۽ سڀ کان وڌيڪ مشهور آهن GET ۽ POST. هر درخواست جو جواب ڏنو وڃي. هڪ GET درخواست جي توقع ڪئي وئي آهي ته جواب حاصل ڪرڻ لاءِ تيار ڪيل HTML ڪوڊ، برائوزر ڏانهن واپس. برائوزر وري ڪوڊ کي تبديل ڪري ٿو تمام خوبصورت اکر، بٽڻ، ۽ فارم. پوسٽ جي درخواست ٿورو وڌيڪ دلچسپ آهي، ڇاڪاڻ ته اهو پڻ ڪجهه معلومات رکي ٿو. مثال طور، فرض ڪريو ته توهان ويب سائيٽ تي رجسٽريشن يا سائن ان فارم ۾ سندون داخل ڪريو، ۽ "موڪليو" تي ڪلڪ ڪريو. اهو توهان جي ذاتي معلومات سان گڏ پوسٽ جي درخواست ڪري ٿو سرور ڏانهن موڪليو وڃي. سرور هي معلومات حاصل ڪري ٿو، ان کي پروسيس ڪري ٿو، ۽ ڪجهه جواب ڏي ٿو (مثال طور، توهان جي پروفائل سان هڪ HTML صفحو). انهن جي وچ ۾ بنيادي فرق اهو آهي ته GET درخواستون صرف سرور مان ڊيٽا حاصل ڪرڻ لاء استعمال ڪيا ويا آهن، جڏهن ته پوسٽ درخواستون ڪجهه معلومات کڻندا آهن (۽ سرور تي ڊيٽا تبديل ٿي سگهي ٿي). مثال طور، جڏهن توهان پنهنجي تصوير سرور تي اپلوڊ ڪندا آهيو، اها اتي پوسٽ جي درخواست ۾ کڻي ويندي آهي ۽ سرور ان کي ڊيٽابيس ۾ شامل ڪري ٿو، يعني هڪ تبديلي ٿئي ٿي. هاڻي واپس Tomcat ڏانهن. جڏهن اهو هڪ ڪلائنٽ کان درخواست وصول ڪري ٿو، اهو پتو ڏسي ٿو. اهو چيڪ ڪري ٿو ته ڇا ان پتي لاءِ درخواستن تي عمل ڪرڻ لاءِ هڪ مناسب سروليٽ آهي (يا هڪ دستياب وسيلو جيڪو فوري طور تي واپس ڪري سگهجي ٿو). جيڪڏهن اهو واپسي لاءِ ڪجهه نٿو ملي ته پوءِ اهو HTML صفحي جي بجاءِ 404-غلطي سان جواب ڏئي ٿو. پر جيڪڏهن اهو ان ايڊريس تي هڪ موزون سروليٽ ”سيٽنگ“ ڳولي ٿو ته پوءِ اهو درخواست جي قسم کي ڏسي ٿو (GET، POST، يا ٻيو ڪجهه) ۽ سرورٽ کان پڇي ٿو ته ڇا ان وٽ ڪو طريقو آهي جيڪو هن قسم جي سوال کي سنڀالي سگهي. جيڪڏهن servlet چوي ٿو ته اها خبر ناهي ته هن قسم کي ڪيئن سنڀاليو، پوء Tomcat هڪ 405 ڪوڊ واپس ڪري ٿو. ۽ اهو ئي آهي جيڪو اسان جي منصوبي ۾ ٿيو. پر جيڪڏهن ڪو مناسب سروليٽ ملي وڃي، ۽ ان ۾ ڪو مناسب طريقو هجي، ته پوءِ Tomcat هڪ servlet شئي ٺاهي، ان کي نئين ٿريڊ تي شروع ڪري.(جيڪو ان کي پاڻ تي هلائڻ جي اجازت ڏئي ٿو)، ۽ Tomcat پنهنجو ڪم جاري رکي، درخواستون قبول ڪرڻ ۽ موڪلڻ. اضافي طور تي، Tomcat ٻه وڌيڪ شيون ٺاهي ٿو: هڪ HttpServletRequest (جنهن کي آئون مختصر طور تي "درخواست" سڏيندس)، ۽ هڪ HttpServletResponse (جنهن کي مان "جواب" سڏيندس). اهو ڪلائنٽ جي درخواست مان حاصل ڪيل سڀني ڊيٽا کي پهرين اعتراض ۾ رکي ٿو، تنهنڪري اهو سڀ ڊيٽا ان مان ڪڍي سگهجي ٿو. ۽ پوءِ ان سڀ کان پوءِ، اهو انهن ٻن شين کي ان سرويليٽ جي مناسب طريقي سان منتقل ڪري ٿو جيڪو هڪ الڳ ٿريڊ تي شروع ڪيو ويو هو. جيئن ئي servlet پنهنجو ڪم پورو ڪري ٿو ۽ ڪلائنٽ ڏانهن جواب موڪلڻ لاءِ تيار آهي، اهو Tomcat تي هڪ جهنڊو لڙڪائي ٿو، ”مان ٿي چڪو آهيان، سڀ ڪجهه تيار آهي“. Tomcat جواب وصول ڪري ٿو ۽ ان کي ڪلائنٽ ڏانهن موڪلي ٿو. هي Tomcat کي درخواستون وصول ڪرڻ ۽ جواب موڪلڻ جي اجازت ڏئي ٿو، بغير پريشان ٿيڻ جي، ۽ سمورو ڪم الڳ الڳ موضوعن تي هلندڙ سروليٽ ذريعي ڪيو ويندو آهي. ان جو مطلب اهو آهي ته جڏهن اسان servlet ڪوڊ لکون ٿا ته اسان اهو طئي ڪندا آهيون ته ڪهڙو ڪم ڪيو ويندو. ۽ توھان سمجھي سگھوٿا main() طريقو پاڻ ٽامڪيٽ جي اندر واقع آھي (ھائو، اھو جاوا ۾ لکيل آھي)، ۽ جڏھن اسين Tomcat کي ”لانچ“ ڪندا آھيون، main() طريقو شروع ٿيندو آھي.

servlets ۽ JSPs استعمال ڪندي هڪ سادي ويب ايپليڪيشن ٺاهڻ (حصو 1) - 2

GET طريقن کي پڪڙڻ ۽ سپر سادو جواب موڪلڻ لاءِ servlets استعمال ڪريو

هن وقت، اسان جي سرورن وٽ ڪو به مناسب طريقو ناهي (GET)، تنهنڪري Tomcat هڪ 405 غلطي موٽائي ٿو. اچو ته ان کي ٺاهيو! HttpServlet ڪلاس، اسان کي اسان جي servlets ورثي ۾، مختلف طريقن جو اعلان ڪري ٿو. طريقن کي مخصوص ڪوڊ تفويض ڪرڻ لاء، اسان صرف انهن کي ختم ڪريون ٿا. انهي حالت ۾، اسان کي doGet()ٻنهي سرورن ۾ طريقي کي ختم ڪرڻ جي ضرورت آهي.

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

}

جئين توهان ڏسي سگهو ٿا، اهو طريقو ٻه دلائل وٺندو آهي: درخواست (درخواست) ۽ جواب (جواب). اھي ئي شيون آھن جيڪي Tomcat ٺاھي ٿو ۽ اسان لاءِ آباد ڪري ٿو جڏھن اھو servlet ۾ مناسب طريقو سڏين ٿا. شروع ڪرڻ لاءِ، اسان آسان ترين جواب ٺاھينداسين. هن کي ڪرڻ لاء، اسان resp اعتراض کڻنداسين ۽ ان مان هڪ PrintWriter اعتراض حاصل ڪنداسين. هن قسم جي اعتراض کي جواب ڏيڻ لاء استعمال ڪيو ويندو آهي. اسان ان کي استعمال ڪنداسين هڪ سادي تار ڪڍڻ لاء.

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

اسان ListServlet ۾ ساڳيو ڪم ڪنداسين، ۽ پوء اسان اسان جي سرور کي ٻيهر شروع ڪنداسين. جئين توهان ڏسي سگهو ٿا، هر شي ڪم ڪري ٿو! جڏهن توهان بٽڻن تي ڪلڪ ڪندا آهيو، توهان کي متن سان صفحا ملندا آهن جيڪي اسان "لکيو" پرنٽ رائٽر سان. پر JSP فائلون جيڪي اسان جوابن سان گڏ صفحا پيدا ڪرڻ لاءِ تيار ڪيون آهن استعمال نه ٿيون ڪيون وڃن. اهو صرف ان ڪري آهي ته اهي ڪڏهن به عمل نه ڪيا ويا آهن. اسان جو servlet جواب پاڻ ٺاهي ٿو ۽ ڊوڙي ختم ڪري ٿو، Tomcat ڏانهن اشارو ڪري ٿو ته اهو ڪلائنٽ کي جواب ڏيڻ لاءِ تيار آهي. Tomcat صرف جواب وٺندو آهي ۽ ان کي واپس ڪلائنٽ ڏانهن موڪلي ٿو.

اچو ته servlets کان JSP فائلن تي ڪنٽرول پاس ڪريون. اسان هيٺ ڏنل طريقي سان اسان جي طريقن جو ڪوڊ تبديل ڪنداسين:

اسان درخواست واري اعتراض مان هڪ درخواست موڪليندڙ اعتراض حاصل ڪريون ٿا، ۽ ان کي 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 صفحن جي جسماني ٽيگ ۾، توھان ڪجھھ شامل ڪري سگھو ٿا ته جيئن اسان صاف طور تي ڏسي سگھون ٿا ته ڪھڙو صفحو ڏيکاريو پيو وڃي. هڪ دفعو توهان ڪيو آهي، سرور کي ٻيهر شروع ڪريو ۽ چيڪ ڪريو. اسان مکيه صفحي تي بٽڻ تي ڪلڪ ڪندا آهيون ۽ صفحا کليل آهن، جنهن جو مطلب آهي ته درخواستون موڪليا وڃن ٿيون سرورليٽ ڏانهن. پوء ڪنٽرول JSP صفحن ڏانهن منتقل ڪيو ويو آهي، جيڪي هاڻي پيش ڪيا پيا وڃن. اهو سڀ ڪجهه هاڻي لاءِ آهي. هن آرٽيڪل جي ايندڙ حصي ۾ ، اسان اسان جي ايپليڪيشن جي ڪارڪردگي تي ڪم ڪنداسين.

وڌيڪ پڙهڻ:
servlets ۽ JSPs استعمال ڪندي هڪ سادي ويب ايپليڪيشن ٺاهڻ (حصو 2) توهان جي پهرين ايپليڪيشن جاوا servlets استعمال ڪندي

تبصرا

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