JavaRush /جاوا بلاگ /Random-SD /جاوا ۾ ويب ايپليڪيشن

سطح

28 February 2021
44 views
0 comments

جاوا ۾ ويب ايپليڪيشن

تعارف

هڪ دفعي، جاوا پنهنجي پوزيشن کي مضبوط ڪيو ان حقيقت جي ڪري ته هن ويب ايپليڪيشنن کي ترجيح طور چونڊيو. ان جي شروعاتي ڏينهن کان وٺي، جاوا جدوجهد ڪئي آهي ان جو رستو ڳولڻ لاء. پهرين، مون تجويز ڪيو ايپلٽ. هي ڊولپرز لاءِ جامد HTML صفحن تي متحرڪ مواد ٺاهڻ لاءِ ڪيترائي موقعا فراهم ڪيا آهن. جڏهن ته، ايپلٽ ڪيترن ئي سببن جي اميدن تي نه رهي: سيڪيورٽي، مٿي، ۽ ٻيا. پوءِ جاوا ٻولي جي ڊولپرز هڪ متبادل تجويز ڪيو - Servlet API . ۽ اهو صحيح فيصلو ثابت ٿيو. Servlet API اها وضاحت آهي جنهن تي ڪنهن به جاوا ويب ايپليڪيشن ٺاهي وئي آهي، اها ويب تي ٻڌل ايپليڪيشن هجي يا ويب سروس جيڪا گهربل معلومات واپس ڪري ٿي. تنهن ڪري، اهو سمجهڻ جو رستو ڪيئن جاوا ويب ايپليڪيشنون ڪم ڪن ٿيون Servlet API کي سمجهڻ سان.

Servlet API

تنهن ڪري، Servlet API اهو آهي جيڪو ٻولي ڊولپرز جاوا ڊولپرز کي پيش ڪيو. Servlet API هڪ وضاحت آهي جنهن کي اسان جي مکيه سوالن جو جواب ڏيڻ گهرجي. توھان ان کي ھتي ڳولي سگھو ٿا: " JSR-000340 JavaTM Servlet 3.1 فائنل رليز لاءِ تشخيص ". باب " 1.1 هڪ سرليٽ ڇا آهي؟ " چوي ٿو ته هڪ سروليٽ هڪ ويب جزو آهي جيڪو جاوا ٽيڪنالاجي تي ٻڌل آهي جيڪو متحرڪ مواد (يعني مواد) ٺاهي ٿو. "Java-based" جو مطلب آهي ته هڪ servlet هڪ جاوا ڪلاس آهي جيڪو بائيٽ ڪوڊ ۾ مرتب ڪيو ويو آهي . Servlets هڪ servlet ڪنٽينر جي ذريعي منظم ڪيا ويا آهن، ڪڏهن ڪڏهن سڏيو ويندو آهي Servlet Engine. هڪ servlet ڪنٽينر هڪ ويب سرور واڌارو آهي جيڪو مهيا ڪري ٿو servlet ڪارڪردگي. موڙ ۾، servlets ڪلائنٽ سان رابطي کي مهيا ڪن ٿا درخواست / جواب جي پيراڊم ۾، جيڪو servlet ڪنٽينر طرفان لاڳو ڪيو ويو آهي. باب ۾ " 1.2 هڪ سرورٽ ڪنٽينر ڇا آهي؟ " چيو ويو آهي ته هڪ سرورٽ ڪنٽينر هڪ ويب سرور يا ايپليڪيشن سرور جو حصو آهي جيڪو نيٽ ورڪ خدمتون مهيا ڪري ٿو جنهن جي ذريعي درخواستون ۽ جواب موڪليا وڃن ٿا، MIME تي ٻڌل درخواستون ۽ جواب ٺاهيا ۽ پروسيس ڪيا ويندا آهن. . ان کان علاوه، servlet ڪنٽينرز servlets جي زندگي جي چڪر کي منظم ڪن ٿا (يعني فيصلو ڪريو جڏهن انهن کي ٺاهيو، انهن کي حذف ڪريو، وغيره). درخواستون حاصل ڪرڻ ۽ جواب موڪلڻ لاءِ سڀني سرورليٽ ڪنٽينرز کي HTTP پروٽوڪول کي سپورٽ ڪرڻ گهرجي. هتي مان اهو شامل ڪرڻ چاهيان ٿو ته MIME هڪ معيار آهي، هڪ وضاحت جيڪا ٻڌائي ٿي ته معلومات کي ڪيئن انڪوڊ ڪيو وڃي ۽ پيغامن کي فارميٽ ڪيو وڃي ته جيئن اهي انٽرنيٽ تي موڪلي سگهجن.

ويب سرور

ويب سرور ھڪڙو سرور آھي جيڪو ڪلائنٽ کان HTTP درخواستون قبول ڪري ٿو ۽ انھن کي HTTP جوابن سان گڏ مهيا ڪري ٿو (عام طور تي HTML صفحي، تصوير، فائل، يا ٻي ڊيٽا سان گڏ). گهربل وسيلن جي سڃاڻپ URLs جي ذريعي ڪئي وئي آهي. Servlet API سپورٽ سان مشهور ويب سرورز مان هڪ آهي Apache Tomcat . گهڻا ويب سرور پيچيده مشينون آهن جيڪي مختلف حصن مان ٺهيل آهن، جن مان هر هڪ مخصوص ڪم انجام ڏئي ٿو. مثال طور:

ڳنڍيندڙ

- ان پٽ تي اسان وٽ رابطا آھن (يعني ڪنيڪٽر) جيڪي ڪلائنٽ کان ايندڙ درخواستون قبول ڪندا آھن. Tomcat ۾ HTTP کنیکٹر "Coyote" جزو استعمال ڪندي لاڳو ڪيو ويو آھي. رابط ڪندڙ ڪلائنٽ کان ڊيٽا وصول ڪن ٿا ۽ ان کي ٽامڪٽ انجڻ تي منتقل ڪن ٿا. Servlet ڪنٽينر - Tomcat Engine، موڙ ۾، "Catalina" جزو استعمال ڪندي ڪلائنٽ کان وصول ڪيل درخواست تي عمل ڪري ٿو، جيڪو هڪ سروليٽ ڪنٽينر آهي. ڏسو Tomcat دستاويز: " آرڪيٽيڪچر جو جائزو " وڌيڪ تفصيل لاءِ. ٻيا ويب سرور آھن جيڪي سپورٽ ڪن ٿيون Servlet API وضاحت. مثال طور، " Jetty " يا " Undertow ". انهن جو فن تعمير ساڳيو آهي، تنهنڪري هڪ سرليٽ ڪنٽينر سان ڪم ڪرڻ جي اصول کي سمجهي، توهان ٻئي سان ڪم ڪرڻ لاء سوئچ ڪري سگهو ٿا.

ويب ايپليڪيشن

تنهن ڪري، اسان جي لاءِ ويب ايپليڪيشن هلائڻ لاءِ، اسان کي هڪ ويب سرور جي ضرورت آهي جيڪو سرورٽ API کي سپورٽ ڪري (يعني اهو آهي، جيڪو هڪ ايڪسٽينشن جزو آهي جيڪو ويب سرور لاءِ Servlet API سپورٽ کي لاڳو ڪري ٿو). ٺيڪ. بهرحال ويب ايپليڪيشن ڇا آهي؟ Servlet API جي وضاحت جي " 10 ويب ايپليڪيشنون " باب جي مطابق ، هڪ ويب ايپليڪيشن servlets، HTML صفحن، طبقن، ۽ ٻين وسيلن جو مجموعو آهي جيڪو ويب سرور تي حتمي ايپليڪيشن ٺاهي ٿو. باب " 10.6 ويب ايپليڪيشن آرڪائيو فائل " جي مطابق، هڪ ويب ايپليڪيشن ويب آرڪائيو ۾ پيڪيج ڪري سگهجي ٿي (وار جي واڌ سان گڏ هڪ آرڪائيو). جيئن ” لغت-219 “ صفحي تي بيان ڪيو ويو آهي:

اهو آهي، جنگ JAR جي بدران ٺاهيو ويو آهي اهو ڏيکارڻ لاء ته هي هڪ ويب ايپليڪيشن آهي. ايندڙ اھم حقيقت: اسان کي اسان جي WAR آرڪائيو ۾ ھڪڙي خاص ڊاريڪٽري جي جوڙجڪ ھجڻ گھرجي. باب " 10.5 ڊائريڪٽري جي جوڙجڪ " ۾ Servlet API وضاحت ۾. هي باب چوي ٿو ته اتي هڪ خاص ڊاريڪٽري آهي جنهن کي "WEB-INF" سڏيو ويندو آهي. هي ڊاريڪٽري خاص آهي ته اها ڪلائنٽ کي نظر نه ايندي آهي ۽ سڌو سنئون نه ڏيکاريل آهي، پر اهو سرورٽ ڪوڊ تائين رسائي آهي. اهو پڻ چوي ٿو ته ڇا WEB-INF ڊاريڪٽري ۾ شامل ٿي سگھي ٿو:

هن پوري لسٽ مان، اسان هاڻي نه ڄاڻون ٿا ۽ نه ٿا سمجهون شيون بابت ڪجهه web.xml فائل جنهن کي deployment descriptor سڏيو ويندو آهي . اهو ڇا آهي؟ باب " 14. ڊيپلائيمينٽ ڊسڪرپٽر " ڊپلائيمينٽ ڊسڪرپٽر لاءِ وقف ٿيل آهي. مختصر ۾، هڪ ترتيب ڏيڻ وارو بيان ڪندڙ هڪ xml فائل آهي جيڪو بيان ڪري ٿو ته ڪيئن ترتيب ڏيڻ (يعني، هلائڻ) اسان جي ويب ايپليڪيشن کي ويب سرور تي. مثال طور، ترتيب ڏيڻ وارو بيان ڪندڙ اشارو ڪري ٿو ته ڪهڙن URLs کي اسان جي ايپليڪيشن تائين رسائي ڪرڻ لاء استعمال ڪيو وڃي، سيڪيورٽي سيٽنگون جيڪي اسان جي ايپليڪيشن سان تعلق رکن ٿيون، وغيره. باب " 14.2 ضابطن جي عمل لاءِ ڊيپلائيمينٽ " چوي ٿو ته web.xml اسان جي ايپليڪيشن کي ترتيب ڏيڻ ۽ لانچ ڪرڻ کان اڳ اسڪيما جي تصديق ڪئي ويندي (يعني هڪ چيڪ ڪيو ويندو ته web.xml جو مواد اسڪيما جي مطابق صحيح لکيو ويو آهي) . ۽ باب " 14.3 ڊيپلائيمينٽ ڊسڪرپٽر " ۾ اهو اشارو ڪيو ويو آهي ته ڊراگرام هتي آهي: http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd جيڪڏهن اسان فائل جي مواد کي ڏسو، اسان ڏسي سگهون ٿا:

XML فائلن لاء اسڪيما ڇا استعمال ڪيو ويو آهي؟ اسڪيما ظاهر ڪن ٿا ته ڪيئن صحيح طريقي سان هڪ XML دستاويز کي ڀريو وڃي: ڪهڙا عناصر استعمال ڪري سگهجن ٿا، ڪهڙي قسم جي ڊيٽا عناصر ۾ بيان ڪري سگهجي ٿي، ڪهڙي ترتيب ۾ عناصر وڃڻ گهرجي، ڪهڙا عناصر گهربل آهن، وغيره. توهان هڪ XML دستاويز جي اسڪيما کي جاوا ۾ هڪ انٽرفيس سان ڀيٽي سگهو ٿا، ڇاڪاڻ ته جاوا ۾ اسڪيما اهو به بيان ڪري ٿو ته ڪئين ڪلاس جيڪي ڏنل انٽرفيس کي پورو ڪن ٿا (يعني ڏنل انٽرفيس کي لاڳو ڪرڻ) کي لکڻ گهرجي. تنهن ڪري، اسان ڳجهي ڄاڻ سان هٿياربند آهيون ۽ اسان جي پهرين ويب ايپليڪيشن ٺاهڻ لاء تيار آهيون!

ويب ايپليڪيشن ٺاهڻ

جديد جاوا ايپليڪيشن سان ڪم ڪرڻ جو تصور ڪرڻ مشڪل آهي بغير خودڪار پروجيڪٽ بلڊ سسٽم استعمال ڪرڻ. ڪجھ سڀ کان وڌيڪ مشهور سسٽم Maven ۽ Gradle آهن . اسان استعمال ڪنداسين Gradle ھن جائزي لاءِ. Gradle جي تنصيب بيان ڪئي وئي آهي سرڪاري ويب سائيٽ تي . نئين ايپليڪيشن ٺاهڻ لاءِ، اسان کي گرڊ ۾ ٺهيل پلگ ان جي ضرورت آهي: " Build Init Plugin ". جاوا ايپليڪيشن ٺاهڻ لاءِ توھان کي ھيٺ ڏنل حڪم هلائڻ جي ضرورت آھي. gradle init --type java-application

پروجيڪٽ ٺاهڻ کان پوءِ، اسان کي build.gradle فائل ۾ ترميم ڪرڻي پوندي . ھي آھي نام نہاد بلڊ اسڪرپٽ (وڌيڪ تفصيل لاءِ ڏسو Gradle ڊاڪيومينٽيشن: " لکڻ اسڪرپٽ ٺاھيو "). هي فائل بيان ڪري ٿو ته ڪيئن گڏ ڪجي پروجيڪٽ ۽ جاوا پروجيڪٽ سان ڪم ڪرڻ جا ٻيا پهلو. پلگ ان بلاڪ بيان ڪري ٿو ته موجوده Gradle پروجيڪٽ لاءِ ڪهڙيون ” گريڊل پلگ ان “ استعمال ٿيڻ گهرجن. پلگ ان اسان جي پروجيڪٽ جي صلاحيتن کي وڌايو. مثال طور، ڊفالٽ پلگ ان " java " آهي. هي پلگ ان هميشه استعمال ڪيو ويندو آهي جيڪڏهن اسان کي جاوا سپورٽ جي ضرورت آهي. پر اسان کي " ايپليڪيشن " پلگ ان جي ضرورت ناهي ، ڇاڪاڻ ته ... ان جي وضاحت ۾ چيو ويو آهي ته اهو هڪ "قابل عمل JVM ايپليڪيشن" ٺاهڻ لاء استعمال ڪيو ويندو آهي، يعني. هلندڙ JVM ايپليڪيشنون. اسان کي WAR آرڪائيو جي صورت ۾ ويب ايپليڪيشن ٺاهڻ جي ضرورت آهي. ۽ جيڪڏھن اسان لفظ ڳوليندا آھيون WAR Gradle ڊاڪيومينٽيشن ۾، اسان ملنداسين ” وار پلگ ان “. تنهن ڪري، اسان هيٺ ڏنل پلگ ان جي وضاحت ڪنداسين:

plugins {
    id 'java'
    id 'war'
}

" وار پلگ ان ڊفالٽ سيٽنگز " ۾ پڻ چيو ويو آهي ته ويب ايپليڪيشن جي سڀني موادن سان گڏ ڊاريڪٽري "src/main/webapp" هجڻ گهرجي، اتي ساڳي WEB-INF ڊاريڪٽري هجڻ گهرجي جنهن ۾ web.xml هجڻ گهرجي. واقع. اچو ته اهڙي فائيل ٺاهي. اسان ان کي ٿوري دير کان پوء ڀرينداسين، ڇاڪاڻ ته ... اسان وٽ اڃا تائين ان لاءِ ڪافي معلومات نه آهي. "انحصار" بلاڪ ۾ اسان پنهنجي پروجيڪٽ جي انحصار کي ظاهر ڪريون ٿا، اهو آهي، اهي لائبريريون / فريم ورڪ جن جي بغير اسان جي ايپليڪيشن ڪم نه ڪري سگهي. انهي صورت ۾، اسان هڪ ويب ايپليڪيشن لکي رهيا آهيون، جنهن جو مطلب آهي ته اسان Servlet API کان سواء ڪم نٿا ڪري سگهون:

dependencies {
    providedCompile 'javax.servlet:javax.servlet-api:3.1.0'
    testCompile 'junit:junit:4.12'
}

مهيا ڪيل ڪمپيل جو مطلب آهي ته انحصار کي اسان جي ويب ايپليڪيشن جي WAR آرڪائيو ۾ شامل ڪرڻ جي ضرورت ناهي: اهو صرف تاليف لاءِ گهربل آهي. ۽ جڏهن عمل ڪيو ويندو، اهو انحصار ڪنهن ٻئي طرفان مهيا ڪيو ويندو (جيڪو آهي، ويب سرور). خير، اسان معلومات کي تعمير اسڪرپٽ ۾ ڇڏي ڏيون ٿا جنهن بابت انحصار جي ذخيري کي اسان استعمال ڪرڻ چاهيون ٿا - سڀ مخصوص انحصار ان مان ڊائون لوڊ ڪيا ويندا:

repositories {
    jcenter()
}

اسان بلڊ اسڪرپٽ فائل مان هر شي کي هٽائي ڇڏيو. ھاڻي اچو ته ايڊٽ ڪريون ڪلاس src\main\java\App.java. اچو ته ان مان هڪ سروليٽ ٺاهيو. باب " باب 2. سرورٽ انٽرفيس " ۾ Servlet API جي وضاحت بيان ڪري ٿي ته Servlet انٽرفيس ۾ HttpServlet جو بنيادي عمل آهي ، جيڪو اڪثر ڪيسن ۾ ڪافي هجڻ گهرجي ۽ ڊولپرز کي صرف ان مان ورثي ۾ اچڻ جي ضرورت آهي. ۽ باب ۾ " 2.1.1 HTTP مخصوص درخواستن کي سنڀالڻ جا طريقا " مکيه طريقا جيڪي ايندڙ درخواستن تي عمل ڪندا آهن، اشارو ڪيو ويو آهي. ان ڪري، اچو ته ٻيهر لکون App.java ڪلاس:

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.PrintWriter;
import java.io.IOException;

public class App extends HttpServlet {
    public String getGreeting() {
        return "Hello world.";
    }

    public void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
 		// https://www.oracle.com/technetwork/java/servlet-142430.html
 		PrintWriter out = resp.getWriter();
 		out.println(this.getGreeting());
 		out.close();
 	}
}

تنهن ڪري، اسان وٽ هر شيء تيار آهي. اهو سڀ ڪجهه باقي رهي ٿو ترتيب ڏيڻ جي وضاحت ڪندڙ کي صحيح طور تي لکڻ لاء. ڊراگرام مان، ھيٺ ڏنل متن کي web.xml ۾ نقل ڪريو:

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="..."
      version="3.1">
      ...
</web-app>

۽ پڻ اسڪيما جو رستو جيڪو ان ۾ اشارو ڪيو ويو آهي: http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd هاڻي اچو ته هڪ مثال ڏسو ته web.xml کي Servlet API جي وضاحت ۾ ڪيئن ڏسڻ گهرجي. هي مثال باب ۾ ڏنو ويو آهي " 14.5.1 هڪ بنيادي مثال ". اچو ته گڏ ڪريون ته ڇاپي ۾ اشارو ڪيو ويو آهي مثال جي وضاحت سان. اسان هيٺ ڏنل حاصل ڪريون ٿا:

<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">
      <display-name>A Simple Web Application</display-name>
      <servlet>
		<servlet-name>app</servlet-name>
		<servlet-class>App</servlet-class>
	  </servlet>
	  <servlet-mapping>
		<servlet-name>app</servlet-name>
		<url-pattern>/app</url-pattern>
	  </servlet-mapping>
</web-app>

جئين توھان ڏسي سگھو ٿا، اسان استعمال ڪيو اسڪيما ۽ اسڪيما جڳھ جيڪي اڳ بيان ڪيا ويا آھن. ۽ عناصر جي وضاحت پاڻ کي باب 14.5.1 مان مثال مان ورتو ويو. جيڪڏهن اسان سڀ ڪجهه صحيح طريقي سان ڪيو، اسان بغير ڪنهن غلطي جي gradle جنگ جي ڪم کي انجام ڏينداسين:

ويب ايپليڪيشن لانچ ڪرڻ

هڪ ويب ايپليڪيشن ڪيئن شروع ٿئي ٿي؟ اچو ته پهرين کان وڌيڪ پيچيده اختيار سان ڊيل ڪريو. اسان اڳ ۾ چيو آهي ته هڪ Apache Tomcat ويب سرور آهي جيڪو سرورٽ API کي سپورٽ ڪري ٿو. هن جو مطلب اهو آهي ته اسان هن سرور تي اسان جي گڏ ڪيل جنگي آرڪائيو کي ترتيب ڏئي سگهون ٿا (اهي پڻ چوندا آهن "تعيل"). " ڊائون لوڊ Tomcat " صفحي تي، "بائنري تقسيم" سيڪشن مان زپ فارميٽ ۾ "ڪور" ترسيل قسم ڊائون لوڊ ڪريو. ۽ ڊائون لوڊ ٿيل آرڪائيو کي پيڪ ڪريو ڪجھ ڊاريڪٽري ۾، مثال طور C:\apache-tomcat-9.0.14 ۾. سرور شروع ڪرڻ کان اڳ، اچو ته فائل کوليو ايڊيٽنگ لاءِ conf\tomcat-users.xml۽ ان ۾ ھيٺيون لائين شامل ڪريو: <user username="tomcat" password="tomcat" roles="tomcat,manager-gui,admin-gui"/> ھاڻي، ڪمانڊ لائن تي، bin ڊاريڪٽري ڏانھن وڃو ۽ عمل ڪريو catalina.bat start. ڊفالٽ طور، سرور ڪنسول تي دستياب هوندو http://localhost:8080/manager. لاگ ان ۽ پاسورڊ ساڳيا آهن جيڪي اسان tomcat-users.xml ۾ بيان ڪيا آهن. Tomcat وٽ "webapps" ڊاريڪٽري آھي، جنھن ۾ ويب ايپليڪيشنون شامل آھن. جيڪڏهن اسان پنهنجو پاڻ کي ترتيب ڏيڻ چاهيون ٿا، اسان کي پنهنجي جنگي آرڪائيو کي اتي نقل ڪرڻ گهرجي. جڏهن اسان اڳي ئي gradle وار ڪمانڊ هلائيندا هئاسين، \build\libs\ڊاريڪٽري ۾ هڪ جنگ آرڪائيو ٺاهي وئي هئي. اھو اھو آھي جيڪو اسان کي نقل ڪرڻ جي ضرورت آھي. ڪاپي ڪرڻ کان پوء، صفحي کي تازو ڪريو http://localhost:8080/manager۽ ڏسو:

مڪمل ٿيڻ کان پوء http://localhost:8080/javaweb/app، اسان اسان جي خدمت ڏانهن رخ ڪنداسين، ڇاڪاڻ ته اسان اڳي ئي ”ميپ ٿيل“ (يعني نقشي ٿيل) /app جي درخواست کي ايپ سرورٽ ڏانهن. هتي هڪ تيز طريقو آهي چيڪ ڪرڻ لاءِ ته ايپليڪيشن ڪيئن ڪم ڪري ٿي. ۽ اسيمبليء جو نظام اسان کي هن سان ٻيهر مدد ڪري ٿو. اسان جي Gradle پروجيڪٽ جي بلڊ اسڪرپٽ ۾، اسان پلگ ان سيڪشن ۾ هڪ نئون پلگ ان " Grettyid "org.gretty" version "2.3.1" " شامل ڪري سگھون ٿا: ۽ ھاڻي اسان پنھنجي ايپليڪيشن کي هلائڻ لاءِ ھڪڙو gradle ڪم ڪري سگھون ٿا:gradle appRun

تفصيلات لاءِ ڏسو " گرٽي پلگ ان شامل ڪريو ۽ ايپ کي هلايو ".

بهار ۽ سروليٽ API

سروليٽ هر شيء جو بنياد آهن. ۽ اڃا به مشهور اسپرنگ فريم ورڪ Servlet API ۾ اضافو کان وڌيڪ ڪجهه ناهي. شروع ڪرڻ سان، اسپرنگ فريم ورڪ اسان جي منصوبي لاءِ هڪ نئون انحصار آهي. تنهن ڪري، اچو ته ان کي شامل ڪريون بلڊ اسڪرپٽ ۾ انحصار بلاڪ ۾: compile 'org.springframework:spring-webmvc:5.1.3.RELEASE' بهار جي فريم ورڪ دستاويزن ۾ هڪ باب آهي " 1.1. DispatcherServlet ". اهو چوي ٿو ته اسپرنگ فريم ورڪ "فرنٽ ڪنٽرولر" جي نموني تي ٺهيل آهي - اهو آهي جڏهن اتي هڪ مرڪزي سروليٽ آهي جنهن کي " DispatcherServlet " سڏيو ويندو آهي. سڀئي درخواستون هن سرورٽ تي اچن ٿيون، ۽ اهو ضروري اجزاء ڏانهن ڪالون موڪلي ٿو. تون ڏسندين، ته هتي به servlets آهن. توھان کي ھڪڙي ٻڌندڙ کي شامل ڪرڻ جي ضرورت آھي ترتيب ڏيڻ واري بيان ۾:

<listener>
	&ltlistener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

هي هڪ servlet حوالي سان واقعو ٻڌندڙ آهي. اھو آھي، جڏھن Servlet Context شروع ٿئي ٿو، Spring context (WebApplicationContext) پڻ شروع ٿئي ٿو. Servlet Context ڇا آهي؟ اهو باب ۾ Servle API جي وضاحت ۾ بيان ڪيو ويو آهي " CHAPTER 4. Servlet Context ". هڪ servlet context ويب ايپليڪيشن جو هڪ servlet جو "ڏسو" آهي جنهن جي اندر servlets هلندا آهن. هر ويب ايپليڪيشن جو پنهنجو سرورٽ ڪنٽينڪس هوندو آهي. اڳيون، اسپرنگ فريم ورڪ کي فعال ڪرڻ لاءِ، توھان کي بيان ڪرڻ جي ضرورت آھي context-param - servlet context لاءِ شروعاتي پيٽرولر.

<context-param>
	<param-name>contextConfigLocation</param-name>
	<param-value>/WEB-INF/app-context.xml</param-value>
</context-param>

۽ DispatcherServlet تعريف مڪمل ڪري ٿي تشڪيل :

<servlet>
	<servlet-name>app</servlet-name>
	<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
	<init-param>
		<param-name>contextConfigLocation</param-name>
 		<param-value></param-value>
	</init-param>
	<load-on-startup>1</load-on-startup>
</servlet>

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

۽ ھاڻي اسان کي صرف contextConfigLocation ۾ بيان ڪيل فائل ڀرڻ جي ضرورت آھي. اهو ڪيئن ڪجي باب ۾ بيان ڪيل اسپرنگ فريم ورڪ دستاويزن ۾ "1.3.1. اعلان":

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <context:component-scan base-package="ru.javarush.javaweb"/>
    <mvc:annotation-driven/>
</beans>

هتي اهو ضروري آهي ته نه رڳو اهو ظاهر ڪرڻ لاءِ ته ڪهڙي پيڪيج کي اسڪين ڪرڻو آهي، پر اهو پڻ ته اسان تشريح تي ٻڌل چاهيون ٿا، يعني تشريحن کي ڪنٽرول ڪرڻ لاءِ ته بهار ڪيئن ڪم ڪندو. باقي اهو آهي ته ru.javarush.javaweb پيڪيج ٺاهيو ۽ ان ۾ اسپرنگ ڪنٽرولر ڪلاس رکو:

package ru.javarush.javaweb;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class SpringController {

    @GetMapping("/app")
    @ResponseBody
    public String getGreeting() {
        return "Hello world.";
    }
}

ھاڻي gradle appRun کي ھلائيندي ۽ ايڊريس تي وڃڻ سان، http://127.0.0.1:8080/javaweb/appاسان کي ساڳيو Hello World ملندو. جئين توهان ڏسي سگهو ٿا، اسپرنگ فريم ورڪ ويجهڙائي سان ڳنڍيل آهي Servlet API ۽ ان جي مٿان ڪم ڪرڻ لاءِ استعمال ڪري ٿو.

تشريحون

جيئن اسان ڏٺو آهي، تشريحون آسان آهن. ۽ اسان ئي نه هئاسين جن ائين سوچيو. تنهن ڪري، Servlet API جي وضاحت ۾، نسخو 3.0 سان شروع ڪندي، باب “ باب 8 تشريحون ۽ پلگ ايبلٽي ” ظاهر ٿيو، جيڪو بيان ڪري ٿو ته سرورٽ ڪنٽينرز کي لازمي طور تي بيان ڪرڻ جي صلاحيت جي حمايت ڪرڻ گهرجي جيڪا اڳ ۾ تشريح جي ذريعي ڊيپلائيمينٽ ڊسڪٽر ۾ بيان ڪئي وئي هئي. اهڙيءَ طرح، web.xml کي پروجيڪٽ مان مڪمل طور ختم ڪري سگھجي ٿو، ۽ servlet ڪلاس جي مٿان توھان @WebServlet تشريح بيان ڪري سگھو ٿا ۽ ظاھر ڪري سگھو ٿا ته ڪھڙي واٽ کي servlet جو نقشو ٺاھيو وڃي. هتي سڀ ڪجهه صاف نظر اچي ٿو. پر ڇا جيڪڏهن اسان بهار کي منصوبي سان ڳنڍيو، جنهن کي وڌيڪ پيچيده سيٽنگن جي ضرورت آهي؟ هتي هر شيء ٿورو وڌيڪ پيچيده آهي. پهرين، بهار جي دستاويزن ۾ چيو ويو آهي ته بهار کي ترتيب ڏيڻ لاءِ web.xml کان سواءِ، توهان کي پنهنجو ڪلاس استعمال ڪرڻو پوندو جيڪو WebApplicationInitializer لاڳو ڪندو. وڌيڪ تفصيل لاءِ، ڏسو باب " 1.1. DispatcherServlet ". اهو ظاهر ٿيو ته هي هڪ بهار ڪلاس آهي. پوءِ هتي ڪيئن استعمال ٿئي ٿو Servlet API؟ حقيقت ۾، ServletContainerInitializer Servlet API 3.0 ۾ شامل ڪيو ويو . جاوا ۾ هڪ خاص ميکانيزم استعمال ڪندي (جنهن کي SPI سڏيو ويندو آهي )، اسپرنگ پنهنجي سروليٽ ڪنٽينر جي شروعات ڪندڙ کي بيان ڪري ٿو SpringServletContainerInitializer. موڙ ۾، اهو اڳ ۾ ئي WebApplicationInitializer جي عملن کي ڳولي ٿو ۽ ضروري طريقن کي سڏي ٿو ۽ ضروري سيٽنگون انجام ڏئي ٿو. ڏسو " How servlet container finds WebApplicationInitializer implementations " وڌيڪ تفصيل لاءِ. مٿي ڏنل سيٽنگون هن ريت ٿي سگهن ٿيون:

package ru.javarush.javaweb.config;

import org.springframework.web.WebApplicationInitializer;
import org.springframework.web.context.ContextLoaderListener;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.servlet.DispatcherServlet;

import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletRegistration;

public class AppInitializer implements WebApplicationInitializer {
    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        // регистрируем конфигурацию созданую высше
        ctx.register(AppConfig.class);
        // добавляем в контекст слушателя с нашей конфигурацией
        servletContext.addListener(new ContextLoaderListener(ctx));

        ctx.setServletContext(servletContext);

        // настраиваем маппинг Dispatcher Servlet-а
        ServletRegistration.Dynamic servlet =
                servletContext.addServlet("dispatcher", new DispatcherServlet(ctx));
        servlet.addMapping("/");
        servlet.setLoadOnStartup(1);
    }
}

ھاڻي، " جاوا تي ٻڌل ترتيب " استعمال ڪندي اسان اشارو ڪنداسين ته ڪھڙي پيڪيج کي اسڪين ڪرڻ + تشريح کي فعال ڪرڻ:

package ru.javarush.javaweb.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;

@Configuration
@EnableWebMvc
@ComponentScan(basePackages = "ru.javarush.javaweb.controllers")
public class AppConfig {
}

۽ SpringController پاڻ ڏانهن منتقل ڪيو ويو ru.javarush.javaweb.controllers، انهي ڪري جڏهن اسڪيننگ، ترتيب پاڻ کي ڳولي نه سگهندي، پر صرف ڪنٽرولرز کي ڳولي سگهندو.

اختصار ڪرڻ

مون کي اميد آهي ته هي جائزو ڪجهه روشني وجهي چڪو آهي ته ڪيئن ويب ايپليڪيشنون جاوا ۾ ڪم ڪن ٿيون. اهو صرف برفاني ٽڪر جو ٽڪرو آهي، پر بنيادي ڳالهين کي سمجهڻ کان سواء، اهو سمجهڻ ڏکيو آهي ته ٽيڪنالاجيون هن بنياد تي ڪيئن ڪم ڪن ٿيون. Servlet API ڪنهن به جاوا ويب ايپليڪيشن جو مرڪزي حصو آهي، ۽ اسان ڏٺو آهي ته ٻيا فريم ورڪ ان ۾ ڪيئن ٺهندا آهن. جاري رکڻ لاءِ، توھان ھيٺ ڏنل مواد ڏسي سگھو ٿا:

#وياچسلاو

تبصرا

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