تقدير المشروع
← كل المقالات

Java: ثلاثون عامًا وثلاثة دروس

Java تبلغ الثلاثين! تكريمًا للغة التي تقف خلف قدر كبير من التقنية الحديثة، ينقل أربعة مهندسين كبار دروسًا أساسية إلى الجيل القادم من المطورين. اكتشف ما الذي يجعلها لا تُقهَر.

26 دقائق قراءة
Javauncoverjavaمطابقة الأنماطلغات البرمجة

قبل ثلاثة عقود ظهر «ديوك» الصغير على ساحة التقنية، وأطلقت Java وعدها الجريء «اكتب مرة واحدة، شغّل في أي مكان». واليوم، في 2025، لا تزال Java العمود الفقري لبرمجيات المؤسسات، وتشغّل كل شيء من منصات insurtech إلى محافظ العملات المشفرة التي تتحول بسرعة إلى جزء معتاد من تطبيقات المصارف الحديثة.

يذهب معظم وقت عملي في تحويل التميز الهندسي إلى قيمة تجارية. ومع ذلك، تبدأ كل قصة عظيمة بالأشخاص الذين يعيشونها فعلًا. فسألت أربعة من مهندسينا الكبار عن الدروس التي سينقلونها إلى الجيل القادم من مطوري Java.

إليكم ثلاثة عقود وثلاثة دروس (أو نحو ذلك)، يرويها أشخاص يكتبون كودًا إنتاجيًا كل يوم. عيد ميلاد سعيد يا Java! 🎂

الصيغة النحوية ليست سوى السطح

بدا تعلم لغتي الأولى كأنه تعلم السحر. كنت أكتب بضعة أسطر من الكود فيظهر شيء على الشاشة. كان ذلك مذهلًا.

في البداية بدا كل شيء بسيطًا وواضحًا. تعلمت الصيغة النحوية وجرّبت الميزات الشائعة. تعرّفت على المجموعات (collections) والحلقات والاستثناءات، وصادفت حتى تعدد الخيوط (multithreading). كان تفكيري: «بمجرد أن أتقن اللغة بما يكفي، لن يكون هناك ما لا أستطيع بناءه».

لكن مع كبر أفكاري اصطدمت بجدار «اختبار الواقع».

اتضح أن معرفة اللغة لا تكفي لبناء برمجيات حقيقية. فجأة وجدت نفسي مضطرًا لتعلم Spring Boot وقواعد البيانات و Rest API و«النشر» (deployment)، أيًّا كان معنى ذلك حينها.

وبصفتي مطور برمجيات أدركت أن هذا ليس سوى قمة جبل الجليد.

بناء منتج جيد يتطلب أكثر من مجرد كتابة الكود. لم يعد هدفنا أن نصنع شيئًا فحسب. نريد أن يدوم المنتج. علينا أن نتحقق من تلبية متطلبات العمل وأن نتأكد أن تغييراتنا لا تكسر كل شيء. نريد التطبيق آمنًا وقابلًا للمراقبة وقابلًا للصيانة.

قادني ذلك إلى إدراك مهم: كتابة Java تعني العمل مع منظومة كاملة. كان عليّ أن أتعرف على الأدوات والأطر والمكتبات.

تعلمت الكثير من هذا من مطورين التقيت بهم في اللقاءات المحلية وفي مؤتمرات مختلفة. والطريف أن كثيرين منهم لم يكونوا مطوري Java، ومع ذلك استطعنا تبادل الخبرات والمعارف. ذلك لأن هذه مشكلات نتعامل معها جميعًا مهما كانت اللغة التي نستخدمها.

فإن كنت على الدرب نفسه، فتذكّر: اللغة ليست سوى المدخل. والحرفة الحقيقية في كل ما يحيط بها.

Java لم تعد بطيئة

لسنوات طويلة اشتهرت Java بأنها بطيئة. سمعت ذلك كثيرًا، حتى عندما كانت البرمجة مجرد هواية لدي.

وعلى السطح بدا ذلك معقولًا. فـ Java تعمل على آلة افتراضية، وتستخدم جامع نفايات (garbage collector)، وتضيف طبقات من التجريد. بدا كل ذلك ثقيلًا.

ففي وقت مبكر يعود إلى 2011 نشر Robert Hundt ورقة بحثية بعنوان «Loop Recognition in C++/Java/Go/Scala» حلّل فيها هذه اللغات الأربع وقارن بينها. وإلى جانب C++ كانت Java بطيئة. أمر طبيعي، أليس كذلك؟ فـ C++ تعمل أقرب إلى العتاد. كيف يمكن لأحد منافسة ذلك؟

ومع ذلك فكل إصدار جديد يجعل Java أسرع، وكل إصدار يضيف شيئًا جديدًا.

خذ مثلًا المُصرِّف في الوقت المناسب (Just In Time compiler – JIT) – منقذ حقيقي لتطبيقات Java. فهو يكتشف النقاط الساخنة (مسارات الكود التي تُنفَّذ كثيرًا) ويصرّفها إلى كود آلة أصلي.

هل لديك كود ميت لن يُنفَّذ أبدًا؟ يتخلص منه JIT. وإذا كانت دالة تُستدعى كثيرًا، فسيدمجها JIT في موضع الاستدعاء (inline) – بنسخ جسم الدالة إلى الدالة المستدعية. وإذا كان متغير كائن يعيش فقط ضمن نطاق دالة واحدة، يستطيع JIT وضعه على المكدس (stack).

وفي هذه الحالة لا يُخصَّص الكائن في الكومة (heap) أصلًا، فلا يضطر جامع النفايات إلى إدارته.

وهناك الكثير غير ذلك….

جلبت Java 19 الخيوط الافتراضية (virtual threads)، وهي طريقة ملائمة للتعامل مع الاستدعاءات الحاجبة مثل القراءة من قاعدة بيانات.

وبفضل هذه التغييرات تحسّنت Java كثيرًا. فمثلًا في 2024 أطلق Gunnar Morling تحديًا يسمى «The One Billion Row Challenge».

كانت المهمة بسيطة إلى حد ما: اكتب برنامج Java يقرأ قياسات الحرارة من ملف * .txt، ويحسب الحد الأقصى والمتوسط والحد الأدنى لدرجة الحرارة لكل محطة طقس، ويطبع المحطات بترتيب أبجدي.

يبدو ذلك سهلًا، إلا أن الملف كان يحتوي على 1,000,000,000 صف!

تحدٍّ رائع، والنتائج أكثر إبهارًا. فهي تتفاوت بحسب الموارد، لكن بعضها يأتي في أقل من نصف ثانية.

وتحسينات Java لا تتوقف هنا. فـ Java 24 (صدرت في 18 مارس 2025) تتضمن عدة JEPs تهدف إلى جعل Java أسرع. فمثلًا، مع Ahead-of-Time Class Loading & Linking (JEP 483) يمكنك الحصول على تحسّن بنسبة 42% في زمن تشغيل التطبيق لكل من التطبيقات العادية وتطبيقات Spring. صحيح أن هذا الرقم مصدره الـ JEP نفسه، لكنه يبدو واعدًا، أليس كذلك؟

وإن كنت تحتاج إلى أن يبدأ تطبيقك بسرعة خاطفة، يمكنك اللجوء إلى GraalVM وبناء صورة أصلية (native image) لتطبيقك ليعمل بسرعة في الدوال السحابية بلا خوادم (serverless).

هناك طرق كثيرة لتسريع Java لديك.

تذكّر: Java لم تعد بطيئة، وهي تواصل التحسن.

كلما نمت Java ازدادت قابلية للقراءة

أظهر الدرس السابق أن كل إصدار من Java أسرع من سابقه. لكن السرعة ليست السبب الوحيد لترقية Java التي تشغّلها في الإنتاج. فالإصدارات الجديدة من Java تمنحك أيضًا طرقًا أنظف لكتابة الكود.

لنفترض أنك عالق على Java 11 – فقد تفوّت الكثير من الميزات الرائعة في Java الأحدث. إليك بعض الأمثلة:

تعبيرات switch

قبل Java 14: عبارة switch مطوّلة مليئة بـ break

   switch (day) {
    case MONDAY:
    case FRIDAY:
    case SUNDAY:
        System.out.println(6);
        break;
    case TUESDAY:
        System.out.println(7);
        break;
    case THURSDAY:
    case SATURDAY:
        System.out.println(8);
        break;
    case WEDNESDAY:
        System.out.println(9);
        break;
}

Java 14+: تعبير switch بحالات ‘->’ ودون حاجة إلى break

switch (day) {
    case MONDAY, FRIDAY, SUNDAY -> System.out.println(6);
    case TUESDAY                -> System.out.println(7);
    case THURSDAY, SATURDAY     -> System.out.println(8);
    case WEDNESDAY              -> System.out.println(9);
}

switch بدلًا من instanceof

قبل Java 21: سلسلة من فحوصات instanceof

if (animal instanceof Cat c) {
    giveFoodToCat(c);
} else if (animal instanceof Dog d) {
    giveFoodToDog(d);
} else {
    throw new IllegalStateException("Unexpected animat type: " + emp);
}

Java 21+: مطابقة الأنماط داخل switch

switch (animal) {
    case Cat c  -> giveFoodToCat(c);
    case Dog d -> giveFoodToDog(d);
    default -> throw new IllegalStateException("Unexpected animal type: " + animal);
}

تتيح الحراسات (guards) معالجة حالات محددة أيضًا

switch (animal) {
    case Cat c when c.hasName("Garfield") -> giveLasagneTo(c);
    case Cat c -> giveFoodToCat(c);
    case Dog d -> giveFoodToDog(d);
    default -> throw new IllegalStateException("Unexpected animal type: " + animal);
}

السجلات (Records)

تتيح أصناف السجلات (Record classes)، وهي نوع خاص من الأصناف، نمذجة مجمّعات البيانات البسيطة بقدر أقل من الطقوس مقارنةً بالأصناف العادية.

record Rectangle(double length, double width) { }

وهذا وحده يحلّ محل:

public final class Rectangle {
    private final double length;
    private final double width;
    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }
    double length() { return this.length; }
    double width()  { return this.width; }
    public boolean equals...
    public int hashCode...
    public String toString() {...}
}

أنماط switch مع السجلات

switch (animal) {
    case Cat(String name, Color _) when "Garfield".equals(name)-> giveLasagneTo(name);
    ...
}

يجمع هذا السطر الواحد بين نمط محروس (when) وتفكيك السجل من Java 21 ومتغير غير مسمّى من Java 22.

وبالمقارنة مع Java القديمة هناك تحسينات أكثر بكثير، وأشجعك على اكتشافها وتجربتها. حظًا موفقًا واستمتع.

الكود يُكتب مرة واحدة ويُقرأ مرات كثيرة

بدأت مغامرتي البرمجية مع C++ في المرحلة الثانوية. ما زلت أذكر أول نشوة عند كتابة بعض النص ثم رؤية النتيجة على الشاشة – بدا الأمر كالسحر الخالص.

دفعتني تلك التجربة إلى دراسة علوم الحاسوب. وعلى مر السنين تعلمت المزيد والمزيد عن البرمجة وهياكل البيانات والخوارزميات وأنظمة التشغيل. وبحلول ذلك الوقت كنت قد كتبت الكثير من البرامج الصغيرة بلغات مختلفة، غالبًا لاجتياز مقرراتي.

كان لقائي بـ Java أمرًا لا مفر منه، وكان حبًا من النظرة الأولى. بدت لي Java سهلة وقوية وقابلة للقراءة. وكان مشروعي الأكبر الأول تطبيق سطح مكتب متعدد الخيوط يحاكي سوق الأسهم – مغامرة حقيقية!

ومع ذلك تعثرت في مشكلات كثيرة: كيف أسمّي الأصناف والدوال؟ كيف أعرف متى ينبغي أن يصبح شيء ما صنفًا؟ كيف أتجنب الضياع في الكود؟ بدأت أدرس أنماط التصميم (Design Patterns) التي ساعدتني على إكمال المشروع، وبعدها اعتقدت أنني رأيت كل شيء.

ثم جاءت وظيفتي الأولى – تدريب عملي التقيت فيه ببرمجيين أكثر خبرة ونظام أعقد بكثير. أذهلني أن قاعدة كود يمكن أن تكون بهذه الضخامة! (لم تكن ضخمة إلى هذا الحد فعلًا.)

كان يمكنك أن ترى هناك «عمارة كلاسيكية من 3 طبقات» (العرض والتطبيق والبيانات)، مع خدمات محشوة بمنطق العمل وجمل if متداخلة لحالات خاصة متنوعة. كان من الصعب قراءتها ومن الصعب معرفة متى سيُنفَّذ شيء ومتى لن يُنفَّذ. ولم تساعد الاختبارات كثيرًا أيضًا – فقد كانت معقدة، بإعداد غير مقروء وأحيانًا بتأكيدات (asserts) أصعب في المتابعة. لحسن الحظ رأى زملائي هذا مشكلة أيضًا، فلم أكن وحدي من يجهل المجال والمتطلبات والمشكلات – بل كانوا يعانون كذلك.

بدأنا نتعلم المزيد عن التصميم الموجّه بالمجال (Domain Driven Design – DDD)، وشاركنا في ورش عمل، وأدخلنا عملية مراجعة كود أكثر صرامة. وفي النهاية أتى ذلك بثماره: أصبحت الميزات الجديدة أسهل قراءة، والاختبارات أيسر فهمًا، والكود أكثر انفتاحًا على التغيير.

لم يكن الأمر متعلقًا بـ DDD وحده، بل بالعقلية التي تأتي بها عند كتابة الكود – كيف تسمّي الدوال وكيف توزّع المسؤوليات بين الأصناف والوحدات. وبالنسبة إلى طالب لم ينجز سوى مشاريع فردية، كانت تجربة رائعة أن يكتشف أن الطريقة التي تكتب بها الكود مهمة، وأنه سيبقى مع أشخاص آخرين لفترة طويلة!

ليس كل شيء بالسهولة التي يبدو بها

قد يكون الفشل أفضل معلم، لكن ربما ليس عندما يتعطل الإنتاج وتضطر إلى التراجع عن تغييراتك.

كُلّف فريقي ببناء ميزة جديدة تدفع معلومات حديثة من الخادم إلى العميل. كان أمامنا خياران نوازن بينهما: Server-Sent Events (SSE) و WebSockets، واخترنا SSE لأنه بدا أبسط وأنسب لنا.

إليك كود SSE النموذجي:

@GetMapping("/stream")
public SseEmitter streamEvents() {
    SseEmitter emitter = new SseEmitter();

    executor.submit(() -> {
        try {
            int i = 0;
            while (true) {
                emitter.send("SSE message " + i++);
                Thread.sleep(1000);
            }
        } catch (IOException | InterruptedException e) {
            emitter.completeWithError(e);
        }
    });

    return emitter;
}

ينشئ الكود أعلاه كائنًا قابلًا للتشغيل (runnable) منفصلًا لكل emitter، ثم يتولى ExecutorService أمره.

عند استدعاء نقطة النهاية هذه، تصلك رسالة كل ثانية حتى تغلق الاتصال. ويعتمد عدد الطلبات المتوازية التي تستطيع نقطة النهاية هذه خدمتها على تنفيذ ExecutorService.

ولحسن الحظ، في هذا الكود يُغلَق الـ emitter بمجرد إطلاق استثناء (Exception)، وهذا ما يحدث عند انقطاع الاتصال.

يبدو الأمر بسيطًا، أليس كذلك؟

فكرنا بالطريقة نفسها، وأكد لنا أحد المطورين أنه سيعمل جيدًا. كانت حالتنا أعقد قليلًا من هذا المثال، إذ كان علينا أن نتحقق بدقة ممن يطلب الـ emitter ونرسل له فقط البيانات المسموح له برؤيتها. وطوال المشروع لم ننتبه إلى أن Tomcat يضع حدًا أقصى لمجموعة خيوطنا (thread pool)، وأن الخيوط التي تشغّل الـ emitters لا تُحرَّر عند انقطاع الاتصال.

للأسف لم نلاحظ المشكلة إلا في الإنتاج، عندما توقف الخادم عن الاستجابة. كيف فاتنا ذلك مبكرًا؟ يمكننا الإشارة إلى أسباب كثيرة: كانت بيئات الاختبار لدينا قصيرة العمر، ولم تكن هناك حركة تقريبًا، ولم تكن لدينا اختبارات حمل أو ضغط على الإطلاق.

لحسن الحظ علّمنا هذا الخطأ أن:

  • نبحث في الحلول التي لا نعرفها، مع الانتباه إلى عيوبها وما إذا كان بإمكاننا التعايش معها
  • نتحقق من استنتاجاتنا مع زملائنا في الفريق
  • نبقى ناقدين لنتائجنا ونتائج الآخرين
  • نختبر دائمًا الحل الذي نختاره، خاصة عندما لا نكون متأكدين من سلوكه تحت الحمل

حيلة صغيرة في Streams API

Stream API قوية جدًا وتجعل معالجة المجموعات أكثر قابلية للقراءة. وبعد أن تعلمتها أردت استخدامها في كل مكان. وبالطبع الواجهة ليست كاملة وتفتقر إلى بعض الميزات التي تتيحها Gatherers الآن.

إحدى المشكلات التي واجهتها كانت اختيار عناصر مميزة بناءً على خاصية معينة بدلًا من الدالة equals(). ولحسن الحظ أراني زميل هذه الحيلة الأنيقة:

    record Book(String title, String author) {}

    public static void main(String[] args) {
        List<Book> books = List.of(
                new Book("Title", "Author1"),
                new Book("Title - next part", "Author1"),
                new Book("Some adventure", "Author2"),
                new Book("Other adventure", "Author2")
        );

        books.stream()
                .filter(uniqueAuthor())
                .forEach(System.out::println);
    }

    private static Predicate<Book> uniqueAuthor() {
        Set<String> state = new HashSet<>();
        return book -> state.add(book.author());
    }

تعتمد الحيلة على أن الدالة uniqueAuthor تعيد Predicate. يُطبَّق الـ predicate في الـ Stream، فيمر به كل عنصر، لكن الـ Set الذي يحمل الحالة يُنشَأ مرة واحدة فقط – عند استدعاء الدالة uniqueAuthor.

وهذا ما يتيح له تذكّر قيم authorName عبر استدعاءات Predicate.

وللمقارنة، إليك كيف يمكن معالجة المشكلة نفسها باستخدام Gatherers:

public static void main(String[] args) {
        List<Book> books = List.of(
                new Book("Title", "Author1"),
                new Book("Title - next part", "Author1"),
                new Book("Some adventure", "Author2"),
                new Book("Other adventure", "Author2")
        );

        books.stream()
                .gather(new UniqueAuthorGatherer())
                .forEach(System.out::println);
    }

    static class UniqueAuthorGatherer implements Gatherer<Book, Set<String>, Book> {
        @Override
        public Supplier<Set<String>> initializer() {
            return HashSet::new;
        }

        @Override
        public Integrator<Set<String>, Book, Book> integrator() {
            return Integrator.ofGreedy((state, item, downstream) -> {
                String author = item.author();
                if(state.add(author)) {
                    downstream.push(item);
                }

                return true;
            });
        }
    }

واجهة Gatherer أقوى، وأعقد أيضًا. يطبّق UniqueAuthorGatherer الدالة initializer التي توفر HashSet جديدًا، والدالة integrator التي تعالج كل عنصر وتمرره إلى المصب (downstream) فقط إذا لم يكن مؤلفه موجودًا في الحالة بعد.

وفي الحالتين يمكن جعل الدوال عامة (generic) وإعادة استخدامها كأداة مساعدة (Util) في مواضع أخرى.

أيهما تفضّل؟

من «يعمل على جهازي» إلى DevOps: كيف تطورت ممارسات تطوير Java

من الصعب تصديق مدى التحول الذي شهده تطوير Java في بضعة عقود فقط.

في الأيام الأولى كان مشروع Java النموذجي يبدأ كحزمة من الأصناف الفوضوية، مجمّعة بقليل من الاختبار وأقل منه من الأتمتة. وكان شحن الكود يعني بناء ملف WAR أو EAR ودفعه، غالبًا يدويًا، إلى خادم Tomcat أو WebLogic، على أمل أن «يعمل ببساطة» في الإنتاج كما عمل على حاسوبك المحمول.

الاختبار؟ عادةً فكرة لاحقة.
التوثيق؟ غالبًا محفوظ في رأس أحدهم.
الأتمتة؟ كتابة سكربت shell (ربما).

ومع ازدياد التعقيد ازدادت الحاجة إلى الانضباط. ويبدو مشروع Java الحديث اليوم مختلفًا تمامًا:

  • يُحفظ الكود المصدري في مستودع Git، مع عمليات بناء واختبارات وأدوات تدقيق (linters) آلية تُطلَق عند كل دفع.
  • اختبارات الوحدة والتكامل وحتى اختبارات العقود أمر مسلَّم به.
  • تسلّم خطوط التكامل المستمر/النشر المستمر (CI/CD) المنتجات إلى بيئات سحابية في دقائق.
  • توصف البنية التحتية ككود، وتُعد الحاوية (Docker) والتنسيق (Kubernetes) القاعدة.
  • المراقبة والتنبيه والتراجع السريع ممارسات قياسية.

فما الدرس؟

التطور الحقيقي يتجاوز الأدوات الجديدة. إنه تغيير ثقافي. فاليوم تهتم فرق Java بجودة الكود والأتمتة والتعاون بقدر اهتمامها بميزات اللغة.

توفر المنظومة ثروة من الأدوات للتسليم السريع والجودة العالية، لكنها تجلب أيضًا تعقيدًا وأعباءً كبيرة. والوعي بذلك أمر حاسم.

ولحسن الحظ، لدى مؤسسات كثيرة الآن فرق بنية تحتية ومنصات مخصصة تدير خط النشر، فيتمكن المطورون من التركيز على ما يهم حقًا: بناء برمجيات موثوقة وحل مشكلات العمل الفعلية بدلًا من محاربة صداع النشر.

ميزات رائعة: من الكود المتكرر إلى الجمال

إذا كتبت Java في العقد الأول من الألفية، فأنت تتذكر عذاب الكود المتكرر (boilerplate) الذي لا ينتهي. فصنف بيانات بسيط كان يتطلب كتابة الحقول والمُنشئات و getters و setters و equals و hashCode و toString مرارًا وتكرارًا. كانت Java قوية، لكنها نادرًا ما كانت أنيقة.

انظر إلى هذا الأسلوب الكلاسيكي:

// Java 7 and earlier
public class User {
    private final String name;
    private final int age;
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() { return name; }
    public int getAge() { return age; }
    @Override
    public String toString() { return "User{name='" + name + "', age=" + age + '}'; }
    @Override
    public boolean equals(Object o) { /* lots of code */ }
    @Override
    public int hashCode() { /* lots of code */ }
}

ابتداءً من Java 16 يمكنك ببساطة استخدام record:

public record User(String name, int age) {}

وهذه مجرد البداية.

  • Lambdas و Streams (Java 8) غيّرت طريقة معالجتنا للمجموعات:
List<String> names = users.stream()
    .filter(u -> u.age() > 18)
    .map(User::name)
    .collect(Collectors.toList());
  • مطابقة الأنماط (Pattern matching) والأصناف المختومة (sealed classes) تجعلان الكود أكثر أمانًا وتعبيرًا معًا.
sealed interface User permits Admin, RegularUser {}
record Admin(String name, int age, int level) implements User {}
record RegularUser(String name, int age) implements User {}
String accessLevel(User user) {
    return switch (user) {
        case Admin a -> "Admin Level " + a.level();
        case RegularUser r -> r.age() > 18 ? "Full Access" : "Restricted Access";
    };
}

والآن: الخيوط الافتراضية (Virtual Threads) (Java 21+)

لسنوات كان خدمة عدد كبير من الطلبات المتزامنة في Java صعبًا – فإنشاء آلاف من خيوط نظام التشغيل مكلف، لذا اعتمدت الأطر على مجموعات الخيوط (thread pools) واستدعاءات الرجوع (callbacks)، مما جعل الكود أعقد.

التزامن التقليدي في Java:

// Handling tasks with traditional threads
for (int i = 0; i < 1000; i++) {
    new Thread(() -> {
        // Handle some request
        handleRequest();
    }).start();
}
// This approach doesn’t scale well—creating thousands of real threads is costly!

باستخدام الخيوط الافتراضية:

// Java 21+ - Virtual Threads make massive concurrency simple and efficient
for (int i = 0; i < 1000; i++) {
    Thread.startVirtualThread(() -> {
        handleRequest();
    });
}
// Now you can easily have thousands or even millions of lightweight threads!

أو باستخدام ExecutorService حديث:

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 1000; i++) {
        executor.submit(() -> handleRequest());
    }
}

Spring Boot يجعل الأمر أبسط!

مع Spring Boot 3.2+ (و Java 21+) لا يتطلب الانتقال إلى الخيوط الافتراضية جهدًا يُذكر.

كل ما تحتاجه هو هذه الخاصية في ملف application.properties:

spring.threads.virtual.enabled=true

هذا كل شيء – لا حاجة إلى أي تغيير في الكود! سيبدأ Spring بمعالجة الطلبات الواردة على خيوط افتراضية، مما يجعل تطبيقك فورًا أكثر قابلية للتوسع وجاهزًا لأعباء العمل الحديثة.

فما الذي اختلف؟

تدير JVM الخيوط الافتراضية بدلًا من نظام التشغيل. وهي رخيصة الإنشاء والجدولة، فيمكنك كتابة كود متزامن قابل للتوسع وبسيط وقابل للقراءة – دون مجموعات خيوط معقدة أو بهلوانيات غير متزامنة.

هذه الميزات الجديدة أكثر من مجرد سكر نحوي – فهي تتيح تصميمًا أفضل وأخطاء أقل وإنتاجية حقيقية.

الدرس:

إذا لم تجرّب Java الحديثة بعد، فأنت تفوّت الكثير. رحّب بالتطور: كود متكرر أقل، ومنطق عمل أكثر، ولغة تواكب أخيرًا أقاربها الأصغر سنًا.

هل الإطار ضروري حقًا؟ معضلة Java التي لا تنتهي

لنكن صريحين: كل مطور Java تقريبًا يحاول، في وقت ما، كتابة إطار العمل الخاص به.

ربما يبدو Spring أكثر من اللازم لـ REST API البسيط لديك. وربما ترغب في فهم كيفية عمل حقن الاعتماديات (dependency injection) أو التوجيه (routing) فعلًا. أو ربما تريد ببساطة أن تبقى الأمور «نظيفة وأدنى ما يمكن».

فتبدأ بحفنة من الأصناف، وربما تغلّف بعض الإعدادات، وتضيف خادم HTTP أساسيًا. تشعر بالرضا… إلى أن تجد نفسك فجأة تنفّذ المصادقة ومعالجة الأخطاء والتسجيل (logging) والتحقق من الصحة ودعم الاختبار… ويبدأ الأمر يشبه Spring أو Quarkus بشكل مريب، لكن دون الاختبار في الميدان ودعم المجتمع.

إليك مثالًا صغيرًا:

// Minimal HTTP server in Java, no framework
HttpServer server = HttpServer.create(new InetSocketAddress(8080), 0);
server.createContext("/hello", exchange -> {
    String response = "Hello, World!";
    exchange.sendResponseHeaders(200, response.length());
    try (OutputStream os = exchange.getResponseBody()) {
        os.write(response.getBytes());
    }
});
server.start();

يعمل هذا جيدًا للتعلّم وللحلول السريعة أو للخدمات الصغيرة حقًا. لكن مع تراكم المتطلبات يتراكم احتياجك إلى الأمان والاختبار والتوثيق والتكاملات… وفجأة لا يبدو الإطار سيئًا إلى هذا الحد.

هل تهتم بالجيل الجديد من أطر Java؟

درس مصغّر:

توجد أطر مثل Spring أو Micronaut لسبب وجيه – فهي تعالج مشكلات صعبة وغالبًا غير مرئية: حقن الاعتماديات والإعدادات وإدارة دورة الحياة وغير ذلك. إنها توفر علينا إعادة اختراع العجلة.

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

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

النمذجة الوظيفية للمجال

عندما ظهرت Scala لأول مرة في 2004 كلغة تمزج بين النموذجين الوظيفي والكائني، بدأت تنشر مفاهيم البرمجة الوظيفية.

اعتُبرت Scala في البداية «Java أفضل»، لكن اليوم لا يصح ذلك إلا جزئيًا – فـ Java لم تتخلف عبر السنين وأضافت عدة ميزات لغوية تجعل البرمجة الوظيفية في بعض المجالات شبه سهلة كما في Scala.

أحد هذه المجالات هو النمذجة الوظيفية للمجال، التي تقوم، مثل البرمجة الوظيفية عمومًا، على نمذجة المجال بقيم غير قابلة للتغيير ودوال نقية. والمفهوم المحوري هنا هو أنواع البيانات الجبرية (Algebraic Data Types – ADTs).

ADTs

تأتي ADTs في نوعين:

  • أنواع الضرب (Product types) – تمثل تركيبة من الخصائص (مثلًا، للمستخدم اسم وبريد إلكتروني)، حيث تملك كل نسخة جميع الخصائص (أي حاصل ضرب ديكارتي لها – ومن هنا جاء الاسم). وفي Java يُعبَّر عنها بالسجلات (records):
record User(String name, String email)
  • أنواع الجمع/الاتحاد (Sum/union types) – تمثل اختيار واحدة من عدة قيم مسموحة منفصلة (مثلًا، الحالة إما تشغيل أو إيقاف). وفي Java يُعبَّر عنها بالتسلسلات الهرمية المختومة (sealed hierarchies):
sealed interface State {
    record On() implements State {}
    record Off() implements State {}
}

تعني الكلمة المفتاحية sealed أن كل متغير ممكن من State معروف عند الترجمة، فيستطيع المصرّف التحقق من معالجة جميع القيم، مثلًا في مطابقة الأنماط.

ومن أكبر مزايا ADTs أنه ببساطة لا يمكن تمثيل الحالات غير المشروعة – فمثل هذا الكود لا يُترجَم أصلًا.

الأخطاء كقيم

يتعامل النهج الوظيفي في نمذجة المجال مع كل شيء على أنه قيمة – بما في ذلك الأخطاء. لذا بدلًا من إطلاق الاستثناءات، من الأفضل تمثيل الأخطاء كقيم – باستخدام ADTs بطبيعة الحال. إليك مثالًا:

sealed interface DomainError {
   record SomeError(String message) implements DomainError {}
   record OtherError(int code) implements DomainError {}
}

sealed interface Try<A> {
    record Success<A>(A value) implements Attempt<A> {}
    record Failure<A>(DomainError e) implements Attempt<A> {}
}

سنجعل بعد ذلك Try نوع الإرجاع لكل دالة قد تنتج خطأ. وهذا يعطينا آلية واحدة لتمثيل النتائج الناجحة والفاشلة معًا. وفوق ذلك، تنحصر أخطاء المجال (تلك التي نتوقعها) في SomeError و OtherError.

مطابقة الأنماط

بالجمع مع مطابقة الأنماط، يتيح لنا هذا أن نضمن عند الترجمة أن كل نتيجة ممكنة لدالة تعيد Try قد عولجت:

Try<String> result = foo();

switch (result) {
    case Try.Success(var value) -> // use value as a String
    case Try.Failure(SomeError(var message)) -> // use message as a String
    case Try.Failure(OtherError(var code)) -> // use code as an int
}

بعض النقاط الجديرة بالملاحظة:

  • تتيح لنا مطابقة الأنماط تفكيك السجلات المتداخلة (مثلًا، الوصول إلى code مباشرةً بدلًا من e.code).
  • يستطيع المصرّف استنتاج الأنواع داخل السجلات المتداخلة.
  • لو غابت أي من الحالات أعلاه، لاشتكى المصرّف (بسبب الكلمة المفتاحية sealed في التسلسل الهرمي DomainError).

قد تبدو النمذجة الوظيفية للمجال مخالفة للحدس في البداية، لكنني أشجعك بشدة على تجربتها ومشاهدة مدى قوتها.

الإسهاب بدلًا من السحر

لنلقِ نظرة على البنية (المبسّطة) لتطبيق Spring Boot نموذجي:

@Service
public class Service {

    @Autowired
    private Repository repository;
}

@Controller
public class Controller {

    @Autowired
    private Service service;

    // request mappings
}

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

سيعمل مباشرةً دون أي إعداد – لا شك في ذلك. يبدو الكود بسيطًا وسهل الاستيعاب – لكن هل هذا هو الواقع فعلًا؟ المشكلة في أطر مثل Spring Boot أنها تُدخل الكثير من السحر بقيامها بأشياء كثيرة نيابةً عنك.

إنها تتبع بوضوح نهج الاصطلاح قبل الإعداد (convention over configuration). لكن هل تعرف كل اصطلاح؟ مثلًا، هل تستطيع أن تقول:

  • ما الذي يحدث فعلًا خلف الكواليس عندما تضع التعليق @SpringBootApplication على صنف؟
  • كيف تبدو دورة حياة المستودعات (repositories) والخدمات وغيرها، مثلًا متى تُنشأ نسخها؟
  • ما الاعتماديات التي يملكها كل مكوّن، مثلًا هل ترى أن Repository يحتاج إلى اتصال بقاعدة بيانات؟
  • من أين تُحمَّل الإعدادات؟
  • كيف تُدار اتصالات قاعدة البيانات الخاصة بـ Repository؟

ينجح هذا النهج بشكل رائع ما دام تطبيقك يتصرف كما ينبغي. لكن عندما يتعطل شيء، تتوقف الاصطلاحات الخفية عن كونها مفيدة. عليك أن تفهم جزءًا من السحر على الأقل قبل أن تتمكن من تصحيح مشكلاتك.

إذا استبدلت إطارًا شاملًا بمجموعة من المكتبات، لكل منها مسؤولية واحدة، فستحصل على تحكم أكبر بكثير فيما يجري في تطبيقك. يصبح الكود أكثر إسهابًا، لكن ذلك قد يؤتي ثماره مع الوقت، لأنه لا يبقى سحر ولا اصطلاحات خفية.

إليك تطبيقنا بعد التعديل:

public class Service(Repository repository) {
}

public class Controller(Service service) {
    // request mappings
}

public class Application {
    public static void main(String[] args) {
        final var config = Config.load();
        final var repository = new Repository(config);
        final var service = new Service(repository);
        final var controller = new Controller(service)

        new HttpServer(config, controller).start();
    }
}

يُظهر الكود أعلاه بوضوح ما يلزم لإعداد التطبيق.

هناك نقطة دخول واحدة لفحصها عند تحليل قاعدة الكود. وتحصل أيضًا على حرية أكبر في كيفية هيكلة الكود والأدوات التي تستخدمها لحل المشكلات المختلفة. لكن، وليس مستغربًا، الأمر دائمًا مسألة مفاضلات – فقد لا يتوسع هذا النهج بشكل مثالي لقواعد الكود الكبيرة جدًا، لذا استخدمه بحذر.

الأطر مثل Spring مفيدة للنماذج الأولية السريعة، لكنني أرى أنه بعد تجاوز مرحلة النماذج الأولية قد يكون من المجدي أن تتحكم أكثر فيما يفعله تطبيقك من وراء ظهرك. وقد يكون هذا مفيدًا بشكل خاص عند تصحيح مشكلات الإنتاج.

هناك حياة خارج @SpringBootApplication و Hibernate (هل سمعت عن jOOQ؟)!

RPC – من EJB إلى REST و gRPC

إليك زاوية أخرى لإبقاء الأمور بسيطة. الاستدعاء عن بعد للإجراءات (Remote Procedure Call – RPC) جزء أساسي من كل نظام موزّع، وقد قطعت Java شوطًا طويلًا في هذا المجال عبر السنين.

EJB

بدأ كل شيء مع Enterprise Java Beans (EJB): معيار خاص بـ Java لاستدعاء الكود عن بعد يعتمد في أساسه على RMI (Remote Method Invocation) الخاص.

لم يكن إعداد EJB سهلًا على الإطلاق: كان عليك كتابة عدة واصفات نشر بصيغة XML، مثلًا لما يسمى الواجهات المحلية والبعيدة. وكان اكتشاف الخدمات (أي إيجاد الطرف الآخر) يتم عبر JNDI – وهي تقنية أخرى خاصة بـ Java.

وأخيرًا وليس آخرًا، كان تشغيل التطبيق يتطلب حاوية J2EE كاملة (مثل JBoss أو Weblogic).

خدمات الويب (WebServices)

بعد ذلك جاءت SOAP وخدمات الويب: أول محاولة لتنفيذ الكود عن بعد عبر بروتوكول موجود ومعروف، هو HTTP.

دعمتها Java عبر مواصفة JAX-WS. ولم تعتمد خدمات الويب على لغة بعينها، لذا، خلافًا لـ EJB، لم تكن بحاجة إلى عميل Java للتخاطب عن بعد مع تطبيق Java.

اعتمدت خدمات الويب على حمولات نصية مرمّزة بصيغة XML، مع فرض المخطط عبر XSL. والحمولة النصية تسهّل عمومًا تصحيح الأخطاء على البشر، لكن XML لم تكن الصيغة المثالية، لأنها أضافت قدرًا كبيرًا من الكود المتكرر (حمولة لا تحمل بيانات فعلية)، مما جعل الطلبات ضخمة وليست سهلة التصحيح.

REST

كانت الخطوة التالية في RPC المبني على HTTP أن نرسل JSON بدلًا من XML عبر HTTP.

يقوم REST (اختصار Representational State Transfer) على إدارة الموارد المعرّفة بمعرّفات URI، والتي يمكنك جلبها أو تغييرها. ورغم أن النهج غير مصمم تحديدًا لتشغيل كود اعتباطي عن بعد، فقد استُخدم على نطاق واسع لهذا الغرض، متجاوزًا مجرد إدارة الموارد بكثير.

وبما أن JSON يحمل كودًا متكررًا أقل بكثير من XML، أصبحت الحمولات أصغر بكثير وقابلة فعلًا للقراءة البشرية – وبالتالي سهلة التصحيح فعلًا.

ولم تكن خدمات REST مدعومة من لغة Java نفسها فحسب (عبر JAX-RS). فقد احتضنت الأوساط هذا النهج على نطاق واسع، وظهرت في ذلك الوقت أطر كثيرة (مثل Spring) ومكتبات (للتعامل مع JSON أو اختبار الخدمات).

وبفضل مرونة HTTP والحمولات النصية، سرعان ما أصبح إدخال ممارسات جيدة في تصميم API أمرًا مهمًا.

gRPC

لا يزال gRPC يعتمد على بروتوكول معروف (HTTP/2)، لكنه يستبدل الحمولات النصية بحمولات ثنائية، ويستخدم لغة وصف واجهات (IDL) منفصلة، هي Protocol Buffers أو protobuf، لوصف بنية الرسائل وتواقيع نقاط النهاية البعيدة.

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

الوضع الحالي

في أيامنا هذه، REST و gRPC هما الخياران الأكثر شعبية، ويعتمد اختيار أحدهما على حالة الاستخدام. وأيًّا اخترت، فأرى أنه سيكون أبسط بكثير من التعامل مع EJB (الثقيل والمرتبط بـ Java) أو خدمات الويب (بحمولاتها الضخمة التي بالكاد تُقرأ). البساطة تنتصر!

الخاتمة

على مدى ثلاثة عقود أظهرت Java أن الابتكار الحقيقي يأتي بالقدر نفسه من الناس والعملية والمنصة:

  • اللغة تزداد خفة باستمرار. السجلات و lambdas والأصناف المختومة والخيوط الافتراضية تثبت أن التعبيرية والأداء يمكن أن يتحسنا جنبًا إلى جنب.
  • اختر تجريداتك بعناية. تعالج أطر مثل Spring أو Micronaut أو Quarkus مشكلات صعبة، لكن معرفة ما يحدث تحت الغطاء تظل أفضل تقنية لتصحيح الأخطاء.
  • الثقافة والأدوات مهمتان بالقدر نفسه. من خوادم التطبيقات على العتاد المباشر إلى DevOps وهندسة المنصات (Platform Engineering)، تستثمر الفرق الناجحة في التعاون والأتمتة بقدر ما تستثمر في بيئات التطوير (IDEs) والمكتبات.
  • قابلية القراءة ميزة. إن قضاء الوقت في تصميم مدروس وصريح يؤتي ثماره بجعل المنصات أسهل صيانة ومساعدتك على الفوز في كل مراجعة كود.

إذا كنت في رحلتك الخاصة مع Java، سواء كانت تحديثًا أو بناءً سحابيًا أصيلًا من الصفر، فتواصل معنا.

نخب ثلاثين عامًا أخرى من تسليم برمجيات موثوقة وأنيقة معًا!