أساسيات جافا للويب والـ Servlets

دورة حياة السيرفلت

18 دقيقة الدرس 4 من 13

دورة حياة السيرفلت

كل سيرفلت تكتبه يعيش داخل حاوية (container) — سواء كانت Tomcat أو Jetty أو WildFly أو أي محرك متوافق مع Jakarta EE. تملك الحاوية الكائن: هي التي تقرر متى تُنشئ سيرفلتك، ومتى تُدمّره، وكم عدد الخيوط (threads) المسموح لها باستدعائه في آنٍ واحد. إنّ فهم هذا التعاقد بعمق هو ما يُفرّق بين المطوّرين الذين يعالجون مشكلات التزامن في خمس دقائق وأولئك الذين يطاردونها لأيام.

توابع دورة الحياة الثلاثة

تُحدّد مواصفة Jakarta Servlet ثلاثة توابع تُعلّم مراحل وجود السيرفلت. الحاوية هي التي تستدعيها — وأنت تُعيد تعريفها (override).

init(ServletConfig config) — يُستدعى مرة واحدة فور أن تُنشئ الحاوية السيرفلت. استخدمه للإعداد المُكلف الذي يُنفَّذ مرة واحدة فحسب: فتح تجمّع اتصالات قاعدة البيانات، أو تحميل ملف إعداد، أو تهيئة ذاكرة تخزين مؤقت.
service(ServletRequest req, ServletResponse res) — يُستدعى لكل طلب، وربما من خيوط متعددة في الوقت ذاته. تُوزّع HttpServlet كل استدعاء على doGet وdoPost وما شابهها، لذا ستُعيد تعريف تلك التوابع الملائمة بدلًا من service مباشرةً في الغالب.
destroy() — يُستدعى مرة واحدة حين تُغلق الحاوية أو يُزال السيرفلت. حرّر ما اقتناه init: أغلق التجمّع، وافرغ مخزن الكتابة، وألغِ الخيوط الخلفية.

ضمان دورة الحياة: يكتمل init قبل أول استدعاء لـ service. ولا يُستدعى destroy إلا بعد انتهاء جميع استدعاءات service الجارية. الحاوية تفرض ذلك — تحصل على حدود واضحة دون أن تكتب كود تزامن لانتقالات المرحلة بنفسك.

مثال عملي كامل لدورة الحياة

يُوضّح السيرفلت التالي التوابع الثلاثة في سياقها. يفتح تجمّع اتصال وهميًا في init، ويستعلم منه لكل طلب، ويُغلقه في destroy.

package com.example.web;

import jakarta.servlet.ServletConfig;
import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.concurrent.atomic.AtomicInteger;

@WebServlet(name = "LifecycleServlet", urlPatterns = "/lifecycle")
public class LifecycleServlet extends HttpServlet {

    // ---- حالة آمنة للمشاركة بين الخيوط ----
    private static final long serialVersionUID = 1L;
    private final AtomicInteger requestCount = new AtomicInteger(0);

    // محاكاة مورد مُكلف (مثل غلاف تجمّع اتصال)
    private AppDataSource dataSource;

    // -------------------------------------------------------
    // 1. INIT — يُستدعى مرة واحدة قبل وصول أول طلب
    // -------------------------------------------------------
    @Override
    public void init(ServletConfig config) throws ServletException {
        super.init(config);   // استدعِ super دائمًا — يحفظ config

        String dbUrl = config.getInitParameter("dbUrl");
        dataSource = new AppDataSource(dbUrl);
        dataSource.open();

        log("تمّت تهيئة LifecycleServlet، dbUrl=" + dbUrl);
    }

    // -------------------------------------------------------
    // 2. SERVICE — يُستدعى مع كل طلب (خيوط متعددة!)
    // -------------------------------------------------------
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse res)
            throws ServletException, IOException {

        int count = requestCount.incrementAndGet();   // عداد آمن بين الخيوط

        res.setContentType("text/html;charset=UTF-8");
        try (PrintWriter out = res.getWriter()) {
            out.println("<p>الطلب #" + count + " معالَج بواسطة الخيط "
                    + Thread.currentThread().getName() + "</p>");
        }
    }

    // -------------------------------------------------------
    // 3. DESTROY — يُستدعى مرة واحدة عند إزالة السيرفلت
    // -------------------------------------------------------
    @Override
    public void destroy() {
        if (dataSource != null) {
            dataSource.close();
        }
        log("تمّ تدمير LifecycleServlet بعد " + requestCount.get() + " طلبات.");
        super.destroy();
    }
}

لاحظ استدعاء super.init(config). يخزّن HttpServlet.init كائن ServletConfig حتى تعمل getServletConfig() والتابع المساعد getInitParameter() لاحقًا. إن نسيت super.init ستُعيد تلك الاستدعاءات null وستواجه NullPointerException بعيدًا عن السبب الحقيقي.

نموذج المثيل الواحد متعدد الخيوط

تُنشئ الحاوية مثيلًا واحدًا فقط من فئة سيرفلتك (افتراضيًا) وتُوجّه جميع الطلبات المتزامنة عبر ذلك الكائن الواحد. عشرة مستخدمين متزامنين تعني عشرة خيوط تُنفّذ doGet جميعها — على نفس المثيل، تقرأ وتكتب في نفس الحقول.

يُعظّم هذا التصميم الإنتاجية: إنشاء الكائنات مُكلف؛ إنشاء الخيوط أرخص؛ ومشاركة سيرفلت واحد تتجنّب الأمرين معًا. لكنه يُلقي بعبء سلامة الخيوط عليك أنت كليًا.

حقول المثيل مشتركة بين جميع الخيوط. عداد ساذج مثل private int count = 0; مع count++ داخل doGet هو سباق بيانات (data race). يمكن لخيطين أن يقرآ نفس القيمة، وكلاهما يزيدها، ثم يكتبان نفس النتيجة — مع فقدان أحد التزايدين بصمت. استخدم AtomicInteger أو LongAdder أو التزامن المناسب.

ما هو آمن وما ليس آمنًا في السيرفلت

القاعدة الحاسمة بسيطة: مَيّز بين البيانات التي تنتمي للسيرفلت وتلك التي تنتمي لطلب واحد.

آمن تخزينه كحقول مثيل: الكائنات غير القابلة للتغيير (سلاسل نصية، أغلفة أوليّة، مراجع final تُضبط مرة في init)، الكائنات الآمنة بين الخيوط (AtomicInteger، ConcurrentHashMap)، الكائنات المساعدة عديمة الحالة (ObjectMapper من Jackson يُضبط عند بدء التشغيل).
لا تُخزّن أبدًا كحقول مثيل: بيانات خاصة بالطلب مثل مدخلات المستخدم، أو مرجع HttpServletRequest أو HttpServletResponse، أو مجموعة نتائج، أو أي حساب محلي. صرّح عنها كـمتغيرات محلية داخل التابع — كل خيط يحصل على إطار مكدسه الخاص.

// خطأ — يُخزَّن req و res في حقول متاحة لجميع الخيوط
public class BrokenServlet extends HttpServlet {
    private HttpServletRequest currentRequest;   // لا تفعل هذا أبدًا

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse res) {
        currentRequest = req;                    // سباق إذعان
        processRequest();
    }
}

// صحيح — تمرير بيانات الطلب كمعاملات تابع أو متغيرات محلية
public class CorrectServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse res) {
        String userId = req.getParameter("id");  // محلي — يعيش على مكدس هذا الخيط
        String result = processRequest(userId);
        // ...
    }
}

التهيئة الكسولة مقابل الفورية مع load-on-startup

افتراضيًا تُهيّئ الحاوية السيرفلت عند أول طلب يصلها — التهيئة الكسولة. يدفع المُستدعي الأول تكلفة init. للسيرفلت التي تحمل عبئًا ثقيلًا عند البدء (بناء ذاكرة تخزين، تدفئة تجمّع اتصال) يكون هذا التأخير غير مرغوب فيه. تفرض السمة load-on-startup التهيئة الفورية عند وقت النشر:

@WebServlet(
    name        = "SearchServlet",
    urlPatterns = "/search",
    loadOnStartup = 1          // عدد صحيح موجب = تهيئة عند بدء التشغيل؛ الأصغر يعمل أولًا
)
public class SearchServlet extends HttpServlet {
    @Override
    public void init() throws ServletException {
        buildSearchIndex();    // يعمل عند النشر لا عند أول طلب
    }
}

تتحكّم قيمة العدد الصحيح في ترتيب التهيئة حين تستخدم سيرفلتات متعددة loadOnStartup: القيمة 1 تبدأ قبل القيمة 2 وهكذا. القيم السالبة (أو حذف السمة) تُبقي السلوك الكسول الافتراضي.

فضّل تجاوز init() عديم الوسيطات. توفّر HttpServlet تابع init() بلا وسيطات يستدعيه الحاوية بعد اكتمال init(ServletConfig) الكامل وتخزين config. تجاوزه يعني أنك لست بحاجة لتذكّر super.init(config) — فـconfig مُخزَّن بالفعل حين يعمل كودك.

التابع destroy عمليًا

يُعدّ destroy خطّافك للتنظيف، غير أن له قيودًا. لا تُقدّم الحاوية ضمانًا صارمًا على المدة التي ستنتظرها حتى اكتمال destroy قبل إيقاف JVM أثناء إيقاف التشغيل المفاجئ (SIGKILL أو OOM kill). للعمل الحساس عند الإيقاف — إرسال الرسائل، إتمام المعاملات المالية — استخدم خطّاف إيقاف JVM أو آلية إيقاف تشغيل متحكّم بها على مستوى الإطار كطبقة ثانية من الدفاع.

لاحظ أيضًا: إذا رمى init استثناء ServletException، تُعلّم الحاوية السيرفلت على أنها غير متاحة ولا تستدعي destroy أبدًا. نظّف أي شيء تمّت تهيئته جزئيًا داخل نفس تابع init باستخدام كتلة try/finally.

@Override
public void init(ServletConfig config) throws ServletException {
    super.init(config);
    try {
        connectionPool = buildPool(config.getInitParameter("dbUrl"));
        searchIndex    = loadIndex();
    } catch (Exception e) {
        // نظّف ما تمّت تهيئته جزئيًا
        if (connectionPool != null) connectionPool.close();
        throw new ServletException("فشل تهيئة السيرفلت", e);
        // لن يُستدعى destroy() بعد هذا الرمي
    }
}

الخلاصة

تمنحك دورة حياة السيرفلت ثلاثة خطّافات محدودة بوضوح: init (مرة واحدة عند بدء التشغيل)، وservice/doGet/doPost (لكل طلب، على خيوط متعددة)، وdestroy (مرة واحدة عند الإيقاف). يعني نموذج المثيل الواحد أن كل حقل مثيل مشترك بين جميع الطلبات المتزامنة — فقط الكائنات الآمنة بين الخيوط أو البيانات المُهيَّأة عند بدء التشغيل الثابتة تنتمي إليه. بيانات نطاق الطلب يجب أن تعيش في المتغيرات المحلية. فهم هذا النموذج أساسي لكتابة تطبيقات ويب صحيحة وذات إنتاجية عالية في Java.