JavaRush /مدونة جافا /Random-AR /تطبيق ويب بلغة جافا

مستوى

28 February 2021
41 views
0 comments

تطبيق ويب بلغة جافا

مقدمة

ذات مرة، عززت Java مكانتها لأنها اختارت تطبيقات الويب كأولوية. منذ أيامها الأولى، كافحت جافا لتجد طريقها. أولاً، اقترحت تطبيقات صغيرة. وقد وفر هذا العديد من الفرص للمطورين لإنشاء محتوى ديناميكي على صفحات HTML الثابتة. ومع ذلك، لم ترق التطبيقات الصغيرة إلى مستوى التوقعات لأسباب عديدة: الأمن، والنفقات العامة، وغيرها. ثم اقترح مطورو لغة Java بديلاً - Servlet API . واتضح أنه القرار الصحيح. واجهة برمجة تطبيقات Servlet هي المواصفات التي يتم بناء أي تطبيق ويب Java عليها، سواء كان تطبيقًا قائمًا على الويب أو خدمة ويب تقوم بإرجاع المعلومات حسب الطلب. لذلك، فإن الطريق إلى فهم كيفية عمل تطبيقات الويب Java يبدأ بفهم Servlet API.

واجهة برمجة تطبيقات سيرفلت

لذا، فإن Servlet API هو ما قدمه مطورو اللغة لمطوري Java. واجهة برمجة تطبيقات Servlet عبارة عن مواصفات يجب أن تجيب على أسئلتنا الرئيسية. يمكنك العثور عليه هنا: " JSR-000340 JavaTM Servlet 3.1 الإصدار النهائي للتقييم ". يوضح الفصل " 1.1 ما هو Servlet؟ " أن servlet عبارة عن مكون ويب يعتمد على تقنية Java التي تقوم بإنشاء محتوى ديناميكي (أي محتوى). "يعتمد على Java" يعني أن servlet عبارة عن فئة Java تم تجميعها في bytecode . تتم إدارة السيرفلتس بواسطة حاوية servlet، والتي تسمى أحيانًا محرك Servlet. حاوية servlet هي امتداد لخادم الويب الذي يوفر وظائف servlet. وفي المقابل، توفر servlet التفاعل مع العميل في نموذج الطلب/الاستجابة، والذي يتم تنفيذه بواسطة حاوية servlet. في الفصل " 1.2 ما هي حاوية Servlet؟ "، يُقال أن حاوية Servlet هي جزء من خادم الويب أو خادم التطبيقات الذي يوفر خدمات الشبكة التي يتم من خلالها إرسال الطلبات والاستجابات، ويتم إنشاء الطلبات والاستجابات المستندة إلى MIME ومعالجتها . بالإضافة إلى ذلك، تقوم حاويات servlet بإدارة دورة حياة servlet (أي تحديد وقت إنشائها وحذفها وما إلى ذلك). يجب أن تدعم كافة حاويات servlet بروتوكول HTTP لتلقي الطلبات وإرسال الاستجابات. أود هنا أن أضيف أن MIME هو معيار، وهو عبارة عن مواصفات توضح كيفية تشفير المعلومات وتنسيق الرسائل بحيث يمكن إرسالها عبر الإنترنت.

قاعدة بيانات للانترنت

خادم الويب هو خادم يقبل طلبات HTTP من العملاء ويزودهم باستجابات HTTP (عادةً مع صفحة HTML أو صورة أو ملف أو بيانات أخرى). يتم تحديد الموارد المطلوبة بواسطة عناوين URL. أحد خوادم الويب الأكثر شيوعًا التي تدعم Servlet API هو Apache Tomcat . معظم خوادم الويب عبارة عن أجهزة معقدة تتكون من مكونات مختلفة، يؤدي كل منها وظائف محددة. على سبيل المثال:

موصلات

- عند الإدخال لدينا موصلات (أي موصلات) تقبل الطلبات الواردة من العملاء. يتم تنفيذ موصل HTTP في Tomcat باستخدام مكون "Coyote". تتلقى الموصلات البيانات من العميل وتمررها إلى Tomcat Engine. حاوية Servlet - يقوم Tomcat Engine بدوره بمعالجة الطلب المستلم من العميل باستخدام مكون "Catalina"، وهو عبارة عن حاوية servlet. راجع وثائق Tomcat: " نظرة عامة على الهندسة المعمارية " لمزيد من التفاصيل. هناك خوادم ويب أخرى تدعم مواصفات Servlet API. على سبيل المثال، " رصيف المراكب الصغيرة " أو " Undertow ". إن بنيتها متشابهة، لذلك من خلال فهم مبدأ العمل مع حاوية servlet واحدة، يمكنك التبديل إلى العمل مع حاوية أخرى.

تطبيق الويب

لذلك، لكي نتمكن من تشغيل تطبيق ويب، نحتاج إلى خادم ويب يدعم Servlet API (أي خادم يحتوي على مكون ملحق ينفذ دعم Servlet API لخادم الويب). بخير. ما هو تطبيق الويب على أي حال؟ وفقًا للفصل " 10 تطبيقات ويب " من مواصفات Servlet API، فإن تطبيق الويب عبارة عن مجموعة من servlet وصفحات HTML والفئات والموارد الأخرى التي تشكل التطبيق النهائي على خادم الويب. وفقًا للفصل " 10.6 ملف أرشيف تطبيقات الويب "، يمكن تجميع تطبيق الويب في Web ARchive (أرشيف بامتداد WAR). وكما جاء في صفحة " المسرد-219 ":

أي أنه تم إنشاء WAR بدلاً من JAR لإظهار أن هذا تطبيق ويب. الحقيقة المهمة التالية: يجب أن يكون لدينا بنية دليل معينة في أرشيف الحرب الخاص بنا. في مواصفات Servlet API في الفصل " 10.5 بنية الدليل ". يقول هذا الفصل أن هناك دليلًا خاصًا يسمى "WEB-INF". يتميز هذا الدليل بأنه غير مرئي للعميل ولا يظهر له مباشرة، ولكن يمكن الوصول إليه من خلال كود servlet. ويوضح أيضًا ما يمكن أن يحتوي عليه دليل WEB-INF:

من هذه القائمة بأكملها، نحن الآن لا نعرف ولا نفهم العنصر المتعلق ببعض ملفات web.xml التي تسمى واصف النشر . ما هذا؟ الفصل " 14. واصف النشر " مخصص لواصف النشر. باختصار، واصف النشر هو ملف xml يصف كيفية نشر (أي تشغيل) تطبيق الويب الخاص بنا على خادم الويب. على سبيل المثال، يشير واصف النشر إلى عناوين URL التي يجب استخدامها للوصول إلى تطبيقنا، كما تتم الإشارة إلى إعدادات الأمان المتعلقة بتطبيقنا وما إلى ذلك. ينص الفصل " 14.2 قواعد معالجة النشر " على أنه قبل تكوين تطبيقنا وتشغيله، سيتم التحقق من صحة web.xml وفقًا للمخطط (أي سيتم التحقق من أن محتويات web.xml مكتوبة بشكل صحيح وفقًا للمخطط) إلى المخطط). وفي الفصل " 14.3 واصف النشر " يُشار إلى أن المخطط موجود هنا: http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd إذا نظرنا إلى محتويات الملف، يمكننا أن نرى:

ما هو المخطط المستخدم لملفات XML؟ تشير المخططات إلى كيفية ملء مستند XML بشكل صحيح: ما هي العناصر التي يمكن استخدامها، وما نوع البيانات التي يمكن تحديدها في العناصر، وبأي ترتيب يجب أن تسير العناصر، وما هي العناصر المطلوبة، وما إلى ذلك. يمكنك مقارنة مخطط مستند XML مع واجهة في Java، لأن المخطط في Java يحدد أيضًا كيفية كتابة الفئات التي تلبي واجهة معينة (أي التي تنفذ واجهة معينة). لذا، نحن مسلحون بالمعرفة السرية ومستعدون لإنشاء أول تطبيق ويب خاص بنا!

إنشاء تطبيق ويب

من الصعب تخيل العمل باستخدام تطبيق Java حديث دون استخدام أنظمة بناء المشروع التلقائية. بعض الأنظمة الأكثر شيوعًا هي Maven وGradle . سوف نستخدم Gradle لهذه المراجعة. تم شرح تثبيت Gradle على الموقع الرسمي . لإنشاء تطبيق جديد، نحتاج إلى مكون إضافي مدمج في Gradle: " Build Init Plugin ". لإنشاء تطبيق Java، عليك تشغيل الأمر التالي: gradle init --type java-application

بعد إنشاء المشروع، سنحتاج إلى تعديل ملف build.gradle . هذا هو ما يسمى بـ Build Script (لمزيد من التفاصيل، راجع وثائق Gradle: " كتابة نصوص البناء "). يصف هذا الملف كيفية تجميع المشروع والجوانب الأخرى للعمل مع مشروع Java. تصف كتلة المكونات الإضافية " مكونات Gradle الإضافية " التي يجب استخدامها لمشروع Gradle الحالي. تعمل المكونات الإضافية على توسيع قدرات مشروعنا. على سبيل المثال، البرنامج المساعد الافتراضي هو " جافا ". يتم استخدام هذا البرنامج المساعد دائمًا إذا كنا بحاجة إلى دعم Java. لكننا لسنا بحاجة إلى البرنامج المساعد " التطبيق "، لأن... ينص وصفه على أنه يُستخدم لإنشاء "تطبيق JVM قابل للتنفيذ"، أي. تشغيل تطبيقات JVM. نحتاج إلى إنشاء تطبيق ويب على شكل أرشيف WAR. وإذا بحثنا عن كلمة WAR في وثائق Gradle، فسنجد " War Plugin ". لذلك، سوف نحدد المكونات الإضافية التالية:

plugins {
    id 'java'
    id 'war'
}

يُقال أيضًا في " الإعدادات الافتراضية لـ War Plugin " أن الدليل الذي يحتوي على جميع محتويات تطبيق الويب يجب أن يكون "src/main/webapp"، ويجب أن يكون هناك نفس دليل WEB-INF الذي يجب أن يكون web.xml فيه تقع. لنقم بإنشاء مثل هذا الملف. سنملأها بعد قليل، لأن... ليس لدينا حتى الآن معلومات كافية لهذا الغرض. في كتلة "التبعيات"، نشير إلى تبعيات مشروعنا، أي تلك المكتبات/أطر العمل التي بدونها لا يمكن لتطبيقنا أن يعمل. في هذه الحالة، نحن نكتب تطبيق ويب، مما يعني أننا لا نستطيع العمل بدون واجهة برمجة تطبيقات Servlet:

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

"providedCompile" يعني أن التبعية لا تحتاج إلى تضمينها في أرشيف WAR الخاص بتطبيق الويب: فهي مطلوبة فقط للتجميع. وعند تنفيذها، سيتم توفير هذه التبعية من قبل شخص آخر (أي خادم الويب). حسنًا، نترك معلومات في نص البناء حول مستودع التبعيات الذي نريد استخدامه - سيتم تنزيل جميع التبعيات المحددة منه:

repositories {
    jcenter()
}

نقوم بإزالة كل شيء آخر من ملف البرنامج النصي للبناء. الآن دعونا نقوم بتحرير الفئة src\main\java\App.java. دعونا نجعل servlet للخروج منه. تنص مواصفات Servlet API في الفصل " الفصل 2. واجهة Servlet " على أن واجهة 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 War دون أخطاء:

إطلاق تطبيق ويب

كيف يتم إطلاق تطبيق الويب؟ دعونا نتعامل مع الخيار الأكثر تعقيدًا أولاً. قلنا سابقًا أن هناك خادم ويب Apache Tomcat يدعم Servlet 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 war، \build\libs\تم إنشاء أرشيف حرب في الدليل. هذا هو ما نحتاج إلى نسخه. بعد النسخ، قم بتحديث الصفحة http://localhost:8080/managerوانظر:

بعد الانتهاء http://localhost:8080/javaweb/app، سوف ننتقل إلى servlet لدينا، لأنه لقد قمنا سابقًا "بتخطيط" (أي تعيين) طلب /app إلى App servlet. هناك طريقة أسرع للتحقق من كيفية عمل التطبيق. ويساعدنا نظام التجميع في ذلك مرة أخرى. في البرنامج النصي الخاص ببناء مشروع Gradle الخاص بنا، يمكننا إضافة مكون إضافي جديد " Gretty " إلى قسم المكونات الإضافية: id "org.gretty" version "2.3.1" والآن يمكننا تنفيذ مهمة gradle لتشغيل تطبيقنا:gradle appRun

راجع " إضافة المكوّن الإضافي الرائع وتشغيل التطبيق " للحصول على التفاصيل.

واجهة برمجة تطبيقات الربيع وServlet

السيرفلتس هي أساس كل شيء. وحتى Spring Framework الشهير الآن ليس أكثر من مجرد إضافة إلى Servlet API. في البداية، يعد Spring Framework بمثابة تبعية جديدة لمشروعنا. لذلك، دعونا نضيفه إلى البرنامج النصي للبناء في كتلة التبعيات: compile 'org.springframework:spring-webmvc:5.1.3.RELEASE' يوجد فصل " 1.1.DispatcherServlet " في وثائق Spring Framework. تقول أن Spring Framework مبني على نمط "وحدة التحكم الأمامية" - وهذا عندما يكون هناك servlet مركزي يسمى " DispatcherServlet ". تأتي جميع الطلبات إلى هذا servlet، ويقوم بتفويض المكالمات إلى المكونات الضرورية. كما ترون، حتى هنا هناك servlets. تحتاج إلى إضافة مستمع إلى واصف النشر:

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

هذا هو مستمع حدث سياق servlet. أي أنه عندما يبدأ سياق Servlet، يبدأ سياق Spring (WebApplicationContext) أيضًا. ما هو سياق Servlet؟ تم وصفه في مواصفات Servle API في الفصل " الفصل 4. سياق Servlet ". سياق servlet هو "عرض" servlet لتطبيق الويب الذي تعمل فيه servlet. كل تطبيق ويب له سياق Servlet الخاص به. بعد ذلك، لتمكين Spring Framework، تحتاج إلى تحديد context-param - معلمة التهيئة لسياق servlet.

<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. كيفية القيام بذلك موصوفة في وثائق Spring Framework في الفصل "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>

من المهم هنا ليس فقط الإشارة إلى الحزمة التي سيتم فحصها، ولكن أيضًا أننا نريد أن نعتمد على التعليقات التوضيحية، أي التحكم في التعليقات التوضيحية حول كيفية عمل Spring. كل ما تبقى هو إنشاء حزمة ru.javarush.javaweb ووضع فئة وحدة التحكم Spring فيها:

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. كما ترون، فإن Spring Framework متشابك بشكل وثيق مع Servlet API ويستخدمه للعمل فوقه.

الشروح

كما رأينا، التعليقات التوضيحية ملائمة. ولم نكن الوحيدين الذين اعتقدوا ذلك. لذلك، في مواصفات Servlet API، بدءًا من الإصدار 3.0، ظهر الفصل " الفصل 8 التعليقات التوضيحية وقابلية التوصيل "، والذي يحدد أن حاويات servlet يجب أن تدعم القدرة على تحديد ما تم تحديده مسبقًا في واصف النشر من خلال التعليقات التوضيحية. وبالتالي، يمكن إزالة web.xml بالكامل من المشروع، وفوق فئة servlet يمكنك تحديد التعليق التوضيحي @WebServlet والإشارة إلى المسار الذي سيتم تعيين servlet إليه. كل شيء يبدو واضحا هنا. ولكن ماذا لو قمنا بربط Spring بالمشروع، الأمر الذي يتطلب إعدادات أكثر تعقيدًا؟ هنا كل شيء أكثر تعقيدًا بعض الشيء. أولاً، تقول وثائق Spring أنه لتكوين Spring بدون web.xml، فإنك تحتاج إلى استخدام فصلك الخاص الذي سيقوم بتنفيذ WebApplicationInitializer. لمزيد من التفاصيل، راجع الفصل " 1.1.DispatcherServlet ". اتضح أن هذا هو فصل الربيع. كيف إذن يتم استخدام Servlet API هنا؟ في الواقع، تمت إضافة ServletContainerInitializer إلى Servlet API 3.0 . باستخدام آلية خاصة في Java (تسمى SPI )، يحدد Spring أداة تهيئة حاوية servlet الخاصة به والتي تسمى SpringServletContainerInitializer. وهو بدوره يبحث بالفعل عن تطبيقات WebApplicationInitializer ويستدعي الطرق الضرورية وينفذ الإعدادات اللازمة. راجع " كيفية عثور حاوية servlet على تطبيقات WebApplicationInitializer " لمزيد من التفاصيل. يمكن إجراء الإعدادات المذكورة أعلاه على النحو التالي:

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);
    }
}

الآن، باستخدام " التكوين المستند إلى Java " سنشير إلى الحزمة التي سيتم فحصها + تمكين التعليقات التوضيحية:

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، بحيث لا يجد التكوين نفسه عند المسح، بل يبحث فقط عن وحدات التحكم.

تلخيص

آمل أن تلقي هذه النظرة العامة بعض الضوء على كيفية عمل تطبيقات الويب في Java. هذا مجرد غيض من فيض، ولكن بدون فهم الأساسيات، من الصعب فهم كيفية عمل التقنيات المبنية على هذا الأساس. تعد واجهة برمجة تطبيقات Servlet الجزء المركزي لأي تطبيق ويب Java، وقد بحثنا في كيفية تناسب أطر العمل الأخرى معها. للمتابعة يمكنك الاطلاع على المواد التالية:

# فياتشيسلاف

تعليقات

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