أستمع الى المقال

ما هي أدواتُ البناء:

أدوات البناء هي برامج تقوم بإنشاء تطبيقات قابلة للتنفيذ من التعليمات البرمجية أو الشفرات التي نكتبها. استخدام هذه الأدوات، يقلّل من مخاطر الخطأ البشري، ويُسرّع عملية ترجمة وتجميع التطبيقات، ويحسّن جودة المنتج النهائي (التطبيق)، وبذلك يتم توفير الوقت والمال.

تؤدي أدوات البناء الحديثة الكثير من المهام مثل تنزيل الاعتماديات (المكتبات الخارجية) من المستودعات Repositories على الإنترنت، وإضافتها للتطبيق الذي نعمل عليه. وتعمل أيضًًا على تجميع وترجمة compiling الشفرة البرمجية، وضع الشفرات البرمجية المُجمَعة والمترجمة في حِزم Packages، وتشغيل الاختبارات. بالنسبة للمشاريع القائمة على جافا، فإن أدوات البناء المستخدمة على نطاق واسع هي Apache Ant, Apache Maven, Gradle.

أداة البناء Gradle:

هي أداةُ أتمتة تساعد في بناء وإدارة المشاريع المكتوبة باللغات الموجّهة لحاسوب جافا الافتراضي JVM Languages، ومنها لغة كوتلن. وتقوم هذه الأداة، بكل ما ذُكر في الفقرة أعلاه، بطريقة أفضل وأسرع بكثير عن باقي الأدوات.

لغة كتابة شفرات Gradle:

تَستخدم Gradle لغتها الخاصة بالمجال (Domain-Specific Language – DSL)  المستندة على لغة البرمجة Groovy والتي تمنح المطوّرينَ طريقة محدّدة لكتابة شفرات بناء مخصّصة. ومؤخرًا، تم أيضًا إعتماد لغة البرمجة كوتلن لكتابة شفرات ملفات Gradle. لذلك، هناك لغتان لكتابة شفرات ملفات Gradle، كوتلن و Groovy ويمكننا اختيار أيّاً منهما.

استخدامات Gradle:

في الوقت الحاضر، تُعدُّ أداة Gradle هي الأداة الأساسية المُعتَمدة لبناء تطبيقات Android. ومع ذلك، تُستخدم أيضًا، في تطوير تطبيقات الخادم Server-Side وسطح المكتب Desktop، بدلاً من أدوات البناء الأخرى. 

الميّزات الأساسية لاستخدام Gradle في مشروع:

  • ملفات الإعدادات Settings files: تستخدم Gradle عدّة أنواع من ملفات الإعدادات التي نصف بها كيفية بناء المشروع.
  • بناء آلي Automatic Build: لا يحتاج المُبرمِج إلى تحديد كل خطوة بناء يجب القيام بها. بدلاً من ذلك، تستخدم Gradle الإعدادات الافتراضية لبناء المشروع. على الرّغم من أنّه يمكن تخصيص كل خطوة من خطوات عملية البناء الافتراضية إذا لِزم الأمر.
  • إدارة الاعتماديات Dependency management: في أثناء إنشاء التطبيقات، قد نحتاج إلى إضافة مكتبات خارجية للاستفادة منها في أداء مهام محدّدة في التّطبيق. يمكننا وضع رابط مخصّص للمكتبة في ملف Gradle، وستقوم Gradle تلقائيًا بتنزيل هذه المكتبات، وتَحلُّ حالات التّعارض مع الاعتماديات الأخرى. يمكننا دمج العديد من الاعتماديات التي نحتاجها لمشروع ما.
  • البناء Build: تسمح Gradle للمبرمجين بتصميم برامج جيدة التنظيم وسهلة الفهم. كما أنّها تدعم الحالات المُعقّدة مثل أنشاء مشاريع متعدّدة.
  • سهولة نقل المشروع Ease of migration: يمكن لـ Gradle التّكيّف بسهولة مع أي هيكل مشروع. لذلك، يمكننا دائمًا تطوير المشروعات بالطريقة التي نريدها بالضّبط.
  • لغة موجهة للمجال (Domain-Specific Language (DSL: تعتمد Gradle، لغة مخصّصة للمجال بالاعتماد على لغتي (Groovy و كوتلن) لكتابة الشفرات في ملفات الإعدادات Settings files.

إنشاء مشروع Gradle في برنامج IntelliJ:

لفهم أداة Gradle أكثر، سنقوم بإنشاء مشروع كوتلن يعتمد على أداة البناء Gradle، سنفتح برنامج IntelliJ ومن النافذة التالية، نختار New Project:

ثم في النافذة التالية، نضغط على كلمة Gradle في القائمة على اليسار، ثم نضع علامة صح يسار Kotlin/JVM من القائمة على اليمين، ثم نضغط على Next، كالتالي:

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

بعد ذلك سيعمل IntelliJ على إنشاء مشروعنا البسيط لتَظهر شجرة ملفاتهُ كالتالي:

بالنظر إلى المشروع في الصورة، سنجد أنه يتكون من:

  1. مجلد KotlinGradleProject وهو المجلد الرئيسي للمشروع ويحمل الاسم  الذي اخترناه للمشروع عند إنشائه. أهم المجلدات والملفات داخله، هي مجلدي src و test واللذان يحتويان بداخلهما ثلاث مجلدات فارغة هي:
    • مجلد جافا java يتم إنشاؤه افتراضيًا من قبل IntelliJ لنضع به ملفات جافا، يمكننا حذفه ﻷنّنا نريد إنشاء مشروع كوتلن وليس جافا.
    • مجلد كوتلن kotlin لملفات كوتلن التي نُنشئها نحن.
    • مجلد الموارد resources ونضع فيه ملفات الواجهة الرّسومية التي يتفاعل معها مستخدم التطبيق، مثل الصور ،والأزرار وغيرها.

ويحتوي مجلد KotlinGradleProject أيضاً، على مجلدات وملفات أداة Gradle، وأهمّها ملف build.gradle، الذي سنعمل عليه في هذه المقالة.

يجب التنويه إلى أن الملفات التي سنضعها في مجلد test هي ملفات تحوي شفرات اختبار التطبيق. (سنشرح الاختبار في الدرس 27 من دورة كوتلن).

بالنّقر على زر الماوس على ملف build.gradle، سيتم فتحه كما يظهر في الجهة اليمنى:

  1. هنا سنضع فيه كل الإضافات plugins التي نريد إضافتها لأداة الـ Gradle. وما يظهر في الصورة، هي إضافة كوتلن تم إضافتها من قَبل تلقائيًا من قِبل برنامج IntelliJ ﻷننا اخترنا مشروع كوتلن في البداية.
  2. هنا نضع المستودعات repositories التي نريد من الأداة البحث من خلالها عن المكتبات الخارجية (الاعتماديات) dependencies.
  3. هنا نضع روابط المكتبات الخارجية والتّكوين configuration الذي شرحناه في أعلى هذه المقالة. كما نرى تم إضافة مكتبة كوتلن القياسية تلقائيًا.
  4. مجلد المكتبات الخارجية External Libraries وهو المجلد الذي ستضع به الأداة مجلدات وملفات المكتبة الخارجية التي يتم تحميلها من قبل الأداة. وما يظهر في الصورة، هي مجلدات المكتبة القياسية لكوتلن والتي وضع رابطها في كتلة dependencies.
  5. علامة التبويب Build هنا ستظهر لنا نتيجة بناء التطبيق أو المَهمّة التي قامت أداة Gradle بها. أو الأخطاء إذا لم تستطع الأداة إتمام بالمَهمّة.
  6. في الجهة اليسار، يظهر اسم المَهمّة التي تقوم بها الأداة. وفي الجهة اليمنى معلومات عن الخطوات التي تم إتخاذها من قبل الأداة في القيام بالمَهمّة. وفي الخطوة الأخيرة تظهر الرسالة: BUILD SUCCESSFUL in 3s وهذا يعني الأداة قامت بالمَهمّة بدون أخطاء في مدة ثلاث ثواني.

إضافة مكتبات خارجية لمشاريع التطبيقات:

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

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

هذه المكتبات الخارجية، تُسمى في Gradle، اعتماديات Dependencies. تأتي هذه المكتبات، في شكل حِزم من ملفات JAR.  يمكن لـ Gradle تنزيلها تلقائيًا وإضافتها إلى المشروع. بهذا تكون Gradle قد وفرّت لنا الوقت الذي سنقضيه في تنزيل هذه المكتبات، بالإضافة إلى حل إشكالية التّعارضات المُحتمَلة بين إصداراتها.

كيفية الحصول على المكتبات الخارجية (ملفات JAR):

من أين يمكن أن نحصل على هذه الاعتماديات؟ وكيف نضيفها إلى المشروع؟ 

إذا أردنا البحث عنها يدوياً، فنحن بحاجة إلى البحث عن ملفات الـ JAR هذه وتنزيلها بأنفسنا وإضافتها إلى مسار الأصناف classpath الخاص بمشروعنا. الكثير من الوقت والجُهد والملّل بلا عائد، أليس كذلك؟ إذًا، دعونا نجعل Gradle تقوم بأكثر الجُهد نيابةً عنّا.

إدارة الاعتماديات Dependency management:

تُعد إدارة الاعتماديات إحدى الميزات الرئيسية لـ Gradle. لإضافة مكتبة خارجية إلى مشروع ما، علينا القيام بخطوتين بالضبط:

  • تحديد مستودع repository حيث يتم البحث عن الاعتماديات.
  • تحديد الاعتماديات التي نريد تضمينها في مشروعنا.

تحديد مستودع أو عدة مستودعات:

المستودعات هي مجرد أماكن مثل مواقع الويب، يتمُّ فيها تخزين المكتبات. يمكن لأي مشروع Gradle، استخدام مستودع واحد أو أكثر أو عدم استخدام أي مستودع. هناك العديد من المستودعات منها: المستودعات المتوافقة مع أداة البناء Maven (مثلًا: Maven Central و JCenter و Google).

يحتوي Gradle على أربعة تعريفات يمكننا استخدامها عندما نريد إضافة المستودعات المتوافقة مع Maven إلى المشروع:

ويتم إضافة هذه التعريفات، في ملف build.gradle كما رأينا في المشروع أعلاه. وعمومًا تكون أبسط صورة لإضافة مستودع هي كالتالي:

repositories {
mavenCentral()
  google()
}

تحديد المكتبة المراد جلبها للمشروع:

بعد أن عرّفنا أداة Gradle على المستودعات التي يجب أن تبحث فيها، يمكننا الآن تحديد المكتبة التي نريد من الأداة تنزيلها ودمجها في المشروع. للبحث عن مكتبة معينة، نحتاج أولاً إلى تحديدها بالسّمات التالية: المجموعة group، الاسم name والإصدار version. تَستخدم أداة البناء هذه السّمات للبحث عن المكتبة في المستودعات. 

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

إضافة مكتبة اختبار:

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

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

هذا الأمر سيكون سهلًا ﻷنّنا نمتلك أداة Gradle. إذًا، كل ما علينا فعله هو اخبار Gradle، بمستودع مكتبة الاختبار، وسِماتها الثلاث: group, name, version. ومن أهم مكتبات الاختبار واسعة الانتشار والتي تتوافق جيدًا مع مشروع كوتلن، مكتبة JUnit. لذا يمكننا البحث عن مكتبة JUnit في مستودع Maven Central. نقوم أولًا بالذهاب إلى موقع المستودع وكتابة اسم المكتبة في خانة البحث، كالتالي:

بالضغط على اسم المكتبة، سنذهب إلى الصفحة الخاصة بها، كالتالي:

في صفحة المكتبة، عند الضغط على رقم آخر إصدار للمكتبة (5.8.2)، كما يظهر في الصورة أعلاه، ستفتح صفحة الإصدار، كالتالي:

  1. هنا نختار أداة البناء التي نريد وضع رابط المكتبة بها. اخترنا Gradle.
  2. هذا هو رابط المكتبة، وهو كما يلي:

testImplementation group: ‘org.junit.jupiter’, name: ‘junit-jupiter-api’, version: ‘5.8.2’

نجد في الرابط الكلمة testImplementation (تم شرحها في آخر فقرة من هذا المقال) ثم سمات المكتبة الثلاث مذكورة صراحةً. ننسخ الرابط كما هو، ومن ثم نضعه في كتلة dependencies داخل ملف build.gradle في مشروعنا السابق، كالتالي:

نلاحظ أنه بمجرد وضع رابط المكتبة في الملف، ظهرت علامة مزامنة جديدة في أعلى الملف على اليمين. هذا يعني أن هناك تغييرات جديدة في الملف، ويجب مزامنة الملف لتقوم الأداة بإضافة التغييرات. نضغط على العلامة، لنجد بعدها أن الأداة قامت بتحميل المكتبة من المستودع، وإضافة مجلداتها وملفاتها إلى المشروع في مجلد External Libraries، كالتالي:

الآن أصبحت كل أصناف ودوال مكتبة الاختبار JUnit، متاحة لنستخدمها داخل ملفات مشروعنا.

نسخة أقصر من رابط المكتبة:

يمكننا التخلي عن كتابة سِمات المكتبة: group, name, version في الرابط واستبدالها بالنقطتين (:)، وستؤدي الغرض. لذا سنعود إلى مستودع Maven، ونختار هذه المرة، علامة التبويب (Gradle(Short، كالتالي:

ليظهر الرابط كما يلي:

testImplementation ‘org.junit.jupiter:junit-jupiter-api:5.8.2’

تم الفصل بين السِمات الثلاث، عبر نقطتين متعامدتين (:) ووضعها معًا بين علامتي تنصيص منفردة (‘ ‘). هذه هي الطريقة الأشهر في كتابة روابط المكتبات في Gradle عبر لغة Groovy. مع العلم أنه يمكننا أيضًا استخدام علامتي تنصيص مزدوجة (” “). كالتالي:

testImplementation “org.junit.jupiter:junit-jupiter-api:5.8.2”

وهكذا نكون قد أضفنا مكتبة خارجية إلى مشروعنا، واخترنا لها أن تكون ضمن مجموعة التكوينات المسمّاة testImplementation. حسنًا، ما هي التكوينات؟

التكوينات Configurations:

يتم تجميع جميع الاعتماديات التي نضيفها لأداة Gradle، في مجموعة مسمّاة من الاعتماديات تسمى التكوينات. لكل منها خصائص مختلفة وتحدد النقاط التالية:

  • هل يجب أن تتوافر الاعتماديات أثناء بناء المشروع أم لا.
  • هل هناك حاجة إلى تضمين الاعتماديات في النتيجة النهائية للمشروع (البرنامج أو التطبيق النهائي).
  • التّحكم في رؤية الاعتماديات الخاصة بالمبرمجين الذين يستخدمون المشروع كـ مكتبة.

تكوينات إضافة كوتلن Kotlin Gradle Plugin:

من أهم ميزات Gradle، هي قبول العديد من الإضافات Plugins. إذا أردنا إنشاء مشروع جافا عبر الأداة، يمكننا أن نضيف إليها إضافة جافا Plugin. وﻷننا نريد العمل على مشروع كوتلن، تم وضع رابط لإضافة كوتلن Kotlin Plugin كما رأينا في الأعلى. وستضيف إضافة كوتلن في المشروع العديد من التكوينات. أهمّها هي التالية:

  • implementation: يعني هذا التكوين أن المكتبة مُتاحة في وقت التّجميع compile-time فقط، ولا يراها المُبرمجون الذين يستخدمون شفرة المشروع المجمعة كـ مكتبة خارجية في مشاريعهم الخاصة. يعتبر هذا التكوين الافتراضي.
  • compileOnly: يستخدم التكوين لتحديد أن المكتبة يجب أن تكون متاحة فقط في وقت التّجميع compile-time، ﻷن المشروع لا يحتاج إليها في وقت التشغيل runtime.
  • runtimeOnly: يُستخدم لتحديد أن المكتبة يجب أن تكون متاحة فقط في وقت التشغيل runtime، ﻷن المشروع لا يحتاج إليها في وقت التجميع compile-time.
  • api: هذا التكوين مشابه لـ implementation. لكن يمكن للمبرمجين الذين يستخدمون شفرة المشروع المجمع كـ مكتبة في مشاريعهم، رؤية المكتبة المضافة.
  • testImplementation: هذا التكوين يُكتب عند إضافة مكتبة تقوم بعمل اختبارات آلية للمشروع. ونظرًا لأن ملفات الاختبارات التي نضعها في مجلد test، يتم تجميعها وتشغيلها بشكل مُنفصل ولا يتمُّ تضمينها في ملف JAR للمشروع النهائي، من المنطقي فعل المِثل مع المكتبات الخارجية التي تساعد في إجراء الاختبارات. وهذا سيؤدي في النهاية، إلى تقليل حجم ملف المشروع النهائي، وهو أمرٌ مفيد بشكل خاص في تطوير تطبيقات Android.

قد تجد أن بعض المشاريع القديمة، تستخدم تكوينات مثل: compile و runtime. هذه التكوينات تم إلغاءها deprecated في وقتنا الحالي. نستطيع بدلًا عنها استخدام، implementation و compileOnly.

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

هل أعجبك المحتوى وتريد المزيد منه يصل إلى صندوق بريدك الإلكتروني بشكلٍ دوري؟
انضم إلى قائمة من يقدّرون محتوى إكسڤار واشترك بنشرتنا البريدية.