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

سطح

Киев

28 February 2021
38 views
0 comments

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

مضمون کي سمجھڻ لاءِ علم جي سطح گھربل آھي: توھان اڳ ۾ ئي جاوا ڪور کي وڌيڪ يا گھٽ سمجھيو آھي ۽ توھان چاھيو ٿا جاوا اي ٽيڪنالوجيز ۽ ويب پروگرامنگ کي ڏسڻ. اهو سڀ کان وڌيڪ معنيٰ رکي ٿو جيڪڏهن توهان هن وقت جاوا مجموعن جي ڳولا جو مطالعو ڪري رهيا آهيو، جيڪو مضمون جي ويجهو عنوانن کي ڍڪي ٿو. servlets ۽ jsp استعمال ڪندي هڪ سادي ويب ايپليڪيشن ٺاهڻ (حصو 1) - 1

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

صارف کي شامل ڪرڻ واري صفحي تي؛
يوزر لسٽ ڏسڻ واري صفحي ڏانهن.

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

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

اسان جو مکيه صفحو ( / ) ھيڊر ۽ ٻن لنڪس/بٽن سان گڏ سڀ کان عام جامد html صفحو ھوندو:

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

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

اچو ته هڪ مستحڪم هوم پيج ٺاهيو

جيڪڏھن توھان وٽ آھي index.jsp توھان جي ويب فولڊر ۾ ، ان کي ختم ڪريو. ان جي بدران، هن فولڊر ۾ اسان هڪ سادي html فائل ٺاهينداسين جنهن کي index.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>    <!-- buttons holder -->
            <button onclick="location.href='/list'">List users<//button>
            <button onclick="location.href='/add'">Add user<//button>
        </div>
    </div>
</body>
</html>

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

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

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

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

اچو ته انهن کي مناسب صفحي جي عنوان ڏيو. "نئون استعمال ڪندڙ شامل ڪريو" ۽ "صارفين جي فهرست" وانگر ڪجھ، ۽ اسان ان کي ھاڻي ھاڻي اھو رستو ڇڏي ڏينداسين.

اچو ته ٻه servlets ٺاهي

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

ادارا - هي اهو آهي جتي اسان جا ادارا ڪوڙ ڪندا (طبقو پاڻ، جيڪو صارف جي شين کي بيان ڪندو)؛
ماڊل - اسان جو ماڊل هتي هوندو (وڌيڪ ٿوري دير کان پوء)؛
servlets - خير، هتي اسان جي servlets ٿي ويندي.

ان کان پوء، توهان محفوظ طور تي ايپ پيڪ مان ان طبقي کي هٽائي سگهو ٿا (جيڪڏهن توهان ان کي ٺاهيو، يقينا). servlets پيڪيج ۾ اسين ٻه طبقا ٺاهينداسين:

AddServlet - حاصل ڪيل درخواستن تي عمل ڪندو /add ؛
ListServlet - /list تي حاصل ڪيل درخواستن تي عمل ڪندو .

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

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

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

وڃو Maven repository ويب سائيٽ؛
اتي ڏسو لئبرريءَ لاءِ جنهن جي توهان کي ضرورت آهي ۽ توهان کي گهربل نسخو.
توھان حاصل ڪريو انحصار ڪوڊ جيڪو توھان جي pom.xml ۾ داخل ٿيڻ جي ضرورت آھي.
داخل ڪريو! :)

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

<dependencies>

</dependencies>

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

    <properties>
        <maven.compiler.source>1.8</maven.compile.source>
        <maven.compiler.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 ٺاهڻ

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

نقشي سازي يا ورهاڱي

هاڻي اهو سٺو لڳندو ته ڪنهن به طرح Tomcat کي ٻڌايان ته جيئن /add کان درخواستون اسان جي AddServlet servlet پاران سنڀاليون وڃن ، ۽ تنهن ڪري /list کان درخواستون لسٽ سرويليٽ سرليٽ طرفان هٿ ڪيا وڃن . هن عمل کي ميپنگ سڏيو ويندو آهي . اهو هن اصول جي مطابق web.xml فائل ۾ ڪيو ويندو آهي :

پهرين اسان 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>

جئين توهان ڏسي سگهو ٿا، سرور-نالو ٻنهي صورتن ۾ ساڳيو آهي. انهي جي مهرباني، Tomcat ڄاڻي ٿو ته جيڪڏهن ڪا درخواست اچي ٿي /add address ، ان کي پاس ڪرڻ جي ضرورت آهي app.servlets.AddServlet servlet . اسان ٻئي 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>

رستي ۾، اسان هتي مکيه صفحي لاء مارڪ اپ نه ٺاهيو آهي (at / ). حقيقت اها آهي ته هن معاملي ۾ اسان کي ان جي ضرورت نه آهي. اسان جو هوم پيج هڪ سادي html فائل آهي جيڪا صرف ٻه بٽڻ ڏيکاري ٿي. ڪو به متحرڪ مواد نه آهي، تنهن ڪري اهو اسان لاءِ ڪو به احساس نٿو رکي ته ان لاءِ هڪ الڳ سروليٽ ٺاهيو وڃي، جنهن تي ايڊريس کان درخواستون موڪليا وڃن / موڪليا ويندا، ۽ جيڪو ڪجهه jsp ڏانهن منتقلي جي عمل کان سواءِ ٻيو ڪجهه نه ڪندو (جنهن کي پڻ هجڻ گهرجي. ٺاھيو ويو) جيڪو ٺاھيندو جيڪڏھن اسان وٽ صرف ٻه بٽڻ ھجن. اسان کي ان جي ضرورت ناهي؛ اسان هڪ مستحڪم وسيلن سان خوش آهيون. جڏهن Tomcat هڪ درخواست وصول ڪري ٿي، اهو چيڪ ڪندو ته اتي هڪ به سرورٽ ناهي جيڪو اهڙي ايڊريس تي درخواست تي عمل ڪري سگهي ٿو، ۽ پوء اهو ڏسندو ته هن ايڊريس تي اصل ۾ هڪ تيار ڪيل html فائل آهي ، جيڪو اهو ڪاميابي سان موڪليندو. . اسان پنهنجي ايپليڪيشن کي ٻيهر هلائي سگھون ٿا (سرور کي ٻيهر شروع ڪريو يا ٻيهر ترتيب ڏيو، جيئن توهان چاهيو) ۽ پڪ ڪريو ته مکيه صفحو پيش ڪيو ويو آهي، ڪجھ به نه ٽٽل آهي، جڏهن اسان بٽڻ تي ڪلڪ ڪندا آهيون، منتقلي ٿينديون آهن، پر هاڻي لاء هڪ غلطي پڻ آهي. لکيل رستي ۾، جيڪڏهن اڳ ۾ اسان وٽ 404 غلطي هئي، هاڻي اسان وٽ 405 آهي. ان جو مطلب اهو آهي ته ميپنگ ڪم ڪيو، سروليٽ مليا، پر انهن وٽ صرف درخواست تي عمل ڪرڻ لاء ڪو به مناسب طريقو نه هو. جيڪڏهن هن مرحلي تي توهان اڃا تائين 404 غلطي حاصل ڪندا آهيو، جيتوڻيڪ سڀ ڪجهه صحيح طريقي سان ڪيو ويو، شايد توهان کي خيال ۾ ترتيب ڏيڻ واري ترتيب کي درست ڪرڻ گهرجي. هن کي ڪرڻ لاءِ، توهان کي وڃڻ جي ضرورت آهي ايڊٽ ڪنفيگريشنز (شروعاتي بٽڻ جي ويجھو مٿي تي)، ونڊو جي ساڄي پاسي ڊيپلائيمينٽ ٽيب ڏانهن وڃو ۽ پڪ ڪريو ته ايپليڪيشن جي حوالي سان اهو صرف اشارو ڪيو ويو آهي /

هڪ مختصر lyrical digression: ڇا ٿي رهيو آهي "هوڊ هيٺ"؟

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

اسان servlets سان GET طريقن کي پڪڙيندا آهيون ۽ سادو جواب موڪليندا آهيون

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

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

}

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

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

اسان ListServlet servlet ۾ ڪجهه ائين ڪنداسين ، جنهن کان پوء اسان پنهنجو سرور ٻيهر شروع ڪنداسين. جئين توهان ڏسي سگهو ٿا، هر شي ڪم ڪري ٿو! جڏهن توهان بٽڻن تي ڪلڪ ڪندا آهيو، صفحا ان متن سان کُليندا آهن جيڪي اسان PrintWriter سان ”ريڪارڊ“ ڪيا آهن . اهو صرف اهو آهي ته اسان جو jsp جيڪو اسان جوابن سان گڏ صفحا ٺاهڻ لاءِ تيار ڪيو آهي ڪنهن به طريقي سان استعمال نه ڪيو ويو آهي. اهو ئي سبب آهي ته اعدام صرف انهن تائين پهچي نه ٿو. سرورليٽ پاڻ هاڻي هڪ جواب ٺاهي ٿو ۽ پنهنجي ڪم کي ختم ڪري ٿو، Tomcat کي سگنل ڏئي ٿو ته ان وٽ ڪلائنٽ لاءِ جواب تيار آهي. Tomcat صرف هي جواب وٺندو آهي ۽ ان کي واپس ڪلائنٽ ڏانهن موڪلي ٿو. اسان ڪنٽرول کي servlets مان 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 صفحن جي باڊي ۾ (باڊي ٽيگ جي اندر) اسان ڪجهه لکي سگهون ٿا ته جيئن اسان واضح طور تي ڏسي سگهون ته ڪهڙو صفحو ڏيکاري رهيو آهي. ان کان پوء، اسان سرور کي ٻيهر شروع ڪيو ۽ چيڪ ڪريو. مکيه صفحي تي بٽڻ دٻايو ويندو آهي، صفحا کوليا ويندا آهن، جنهن جو مطلب آهي درخواستون موڪليا ويندا آهن servlets، جنهن کان پوء ڪنٽرول jsp صفحن ڏانهن منتقل ڪيو ويندو آهي، جيڪي اڳ ۾ ئي پيش ڪيا ويا آهن. اهو ئي سڀ ڪجهه آهي. مضمون جي ايندڙ حصي ۾ اسان اسان جي ايپليڪيشن جي ڪارڪردگي سان معاملو ڪنداسين.

ٻيو ڇا پڙهو:

IntelliJ Idea Enterprise ۾ هڪ سادي ويب پروجيڪٽ ٺاهڻ. قدم بہ قدم، تصويرن سان

منهنجي چيٽ

تبصرا

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