تجميع وتشغيل Java بدون IDE

ذات مرة على موقع reddit.com ، في موضوع تجميع وتشغيل Java بدون IDE ، تم طرح السؤال: هل هناك أمر يجمع مجموعة من ملفات Java الموجودة داخل الحزمة في مجلد منفصل (دعنا نسميها bin ) ، وكيف يمكنني البدء في بدء ملفات صف دراسي جديدة؟ " يوضح مؤلف الموضوع، kylolink : "عندما بدأت استخدام Java، اعتمدت على Eclipse للقيام بكل عمليات التجميع نيابةً عني وكنت قلقًا فقط بشأن كتابة التعليمات البرمجية." لقد رأيت هذا السؤال عدة مرات، وبالفعل، هذا هو ما دفعني إلى نشر مدونة حول أنظمة GPS وIDEs: جيدة أم سيئة؟ أنا أحب Java IDEs القوية والحديثة وهي تجعل حياتي أسهل على أساس يومي، ولكن هناك أيضًا فوائد لمعرفة كيفية إنشاء وتشغيل أمثلة بسيطة لـ Java دون الحاجة إلى ذلك. هذه المقالة تدور حول كيفية القيام بذلك. في مدونتي حول تعلم Java باستخدام اختبارات بسيطة، كتبت عن كيف أحب أحيانًا استخدام محرر نصوص بسيط وأدوات سطر الأوامر لكتابة وإنشاء وتشغيل تطبيقات بسيطة. لقد فكرة جيدة جدًا الآن عن مقدار "النفقات العامة" التي تتطلبها Java IDEs المفضلة لدي واتخاذ قرار مبكر بشأن ما إذا كانت الفوائد التي تم تحقيقها باستخدام إطار العمل كافية لتبرير "النفقات العامة". في معظم التطبيقات الحقيقية، ليس هناك شك في أن VL IDE يستحق الكثير. ومع ذلك، بالنسبة لأبسط الأمثلة على التطبيقات، فإن هذا ليس هو الحال دائمًا. يوضح الجزء المتبقي من هذا المنشور كيفية إنشاء كود Java وتشغيله بدون IDE لهذه المواقف.

كتابة وتنفيذ كود جافا

لجعل المثال أكثر وضوحًا، سأستخدم بعض فئات Java البسيطة جدًا والتي ترتبط ببعضها البعض من خلال التركيب أو الوراثة والموجودة في نفس الحزمة التي تسمى Dustin.examples . هناك فئتان تفتقدان وظيفة main، أما الفئة الثالثة، Main.java، فلها وظيفة mainتتيح لك توضيح كيفية تشغيل الفئة بدون IDE. يوجد أدناه رمز لهذه الفئات الثلاث: Parent.java

package dustin.examples;

public class Parent
{
   @Override
   public String toString()
   {
      return "I'm the Parent.";
   }
}

Child.java

package dustin.examples;

public class Child extends Parent
{
   @Override
   public String toString()
   {
      return "I'm the Child.";
   }
}

main.java

package dustin.examples;

import static java.lang.System.out;

public class Main
{
   private final Parent parent = new Parent();
   private final Child child = new Child();

   public static void main(final String[] arguments)
   {
      final Main instance = new Main();
      out.println(instance.parent);
      out.println(instance.child);
   }
}

تُظهر لقطة الشاشة التالية بنية الدليل مع فئات .java هذه ، وتُظهر لقطة الشاشة أن الملفات المصدر موجودة في التسلسل الهرمي للدليل الذي يمثل اسم الحزمة ( dustin/examples لأن معلومات الحزمة هي Dustin.examples ) وأن هذه الحزمة تعكس التسلسل الهرمي للدليل تحت الدليل الفرعي SRC. لقد قمت أيضًا بإنشاء دليل فرعي للفئات (وهو فارغ حاليًا) لإيواء ملفات .class المترجمة لذلك لن يقوم Javac بإنشاء هذا الدليل عندما لا يكون موجودًا.

البناء باستخدام JAVAC والتشغيل باستخدام Java

بغض النظر عن الطريقة التي يستخدمها المرء لإنشاء تعليمات برمجية Java (Ant أو Maven أو Gradle أو IDE)، فإن الأمر يعود في النهاية إلى JAVAC. يمكن رؤية الخيارات القياسية في أداة سطر أوامر JAVAC المقدمة من Oracle/Sun عن طريق تشغيل JAVAC -help ويمكن عرض خيارات الامتداد الإضافية عن طريق تشغيل JAVAC -help -X. يمكن العثور على مزيد من التفاصيل حول كيفية استخدام هذه الخيارات في وثائق أداة JAVAC لنظام التشغيل Windows أو Unix/Linux. كما تقول وثائق Javac، يمكن استخدام خيار -sourcepath للتعبير عن الدليل الذي توجد فيه الملفات المصدر. في بنية الدليل الموضحة في لقطة الشاشة أعلاه، هذا يعني أنه بافتراض أنني أقوم بتشغيل أمر JAVAC من الدليل C:\Java\examples\javacAndJava\ ، يجب أن يكون لدي شيء مثل هذا في أمري: Javac -sourcepath src SRC\داستن\أمثلة\*. جافا . لقطة الشاشة التالية توضح نتائج ذلك. نظرًا لأننا لم نحدد دليلاً لملفات .class ، فقد تم وضعها افتراضيًا في نفس الدليل مثل ملفات .java المصدر التي تم تكوينها منها. يمكننا استخدام الخيار -dلإصلاح هذا الوضع. يمكن تشغيل أمرنا الآن، على سبيل المثال، كفئات Javac -sourcepath src -d src\Dustin\examples\*. انا انت . كما ذكرنا سابقًا، يجب أن يكون المجلد (الفئات) المحدد موجودًا بالفعل. عندما يحدث ذلك، سيقوم الأمر بوضع ملفات .class في المجلد المحدد كما هو موضح في لقطة الشاشة التالية. مع تجميع ملفات Java المصدر في ملفات .class المقابلة في الدليل المحدد، يمكننا تشغيل التطبيق باستخدام قائمة التشغيل السريع أداة سطر أوامر جافا. يتم ذلك ببساطة عن طريق اتباع الإرشادات المتوفرة في صفحات تعليمات Java أو أدوات Java وتحديد موقع ملفات .class باستخدام الخيار -classpath( أو -cp). يتم توضيح استخدام كلا الطريقتين لتحديد دليل الفئات حيث سيتم البحث عن ملفات .class في لقطة الشاشة التالية. الوسيطة الأخيرة هي الاسم الكامل (حزمة Java بأكملها) للفئة التي تحتوي على الوظيفة الرئيسية المراد تنفيذها. الأوامر الموضحة في لقطة الشاشة التالية هي فئات java -cp Dustin.examples.Main وفئات java -classpath Dustin.examples.Main.

البناء والجري مع النملة

بالنسبة لأبسط تطبيقات Java، من السهل جدًا استخدام JAVAC وJava لإنشاء التطبيق وتشغيله، على التوالي، كما هو موضح للتو. نظرًا لأن التطبيقات أصبحت أكثر تعقيدًا (على سبيل المثال، التعليمات البرمجية الموجودة في أكثر من حزمة/دليل واحد أو فئات تبعية أكثر تعقيدًا في مكتبات وأطر عمل تابعة لجهات خارجية)، فقد يصبح هذا النهج غير عملي. يعد Apache Ant أقدم أدوات بناء Java "الثلاثة الكبار" وقد تم استخدامه في آلاف التطبيقات وعمليات النشر. كما قلت في منشور سابق بالمدونة، من السهل إنشاء ملف بناء Ant بسيط جدًا، خاصة إذا كان يبدأ بقالب كما أوضحته في هذا المنشور. قائمة التعليمات البرمجية التالية مخصصة لملف Ant's build.xml ، والذي يمكن استخدامه لإنشاء ملفات .java في ملفات .class ثم تشغيل الفئة Dustin.examples.Main كما حدث أعلاه مع JAVAC وJava. build.xml

<?xml version="1.0" encoding="UTF-8"?>
<project name="BuildingSansIDE" default="run" basedir=".">
   <description>Building Simple Java Applications Without An IDE</description>

   <target name="compile"
           description="Compile the Java code.">
      <javac srcdir="src"
             destdir="classes"
             debug="true"
      includeantruntime="false" />
   </target>

   <target name="run" depends="compile"
           description="Run the Java application.">
      <java classname="dustin.examples.Main" fork="true">
         <classpath>
           <pathelement path="classes"/>
         </classpath>
      </java>
   </target>
</project>

لم أستخدم خصائص Ant ولم أقم بتضمين الأهداف المشتركة التي أدرجها عادةً (مثل "pure" و"Javadoc") لإبقاء هذا المثال بسيطًا قدر الإمكان وإبقائه قريبًا من المثال السابق باستخدام JAVAC وJava . لاحظ أيضًا أنني قمت بتمكين "debug" لتعيين "true" لمهمة JAVAC Ant لأن هذا ليس صحيحًا في حالة فشل Ant، ​​ولكنه صحيح مع افتراضي JAVAC. ليس من المستغرب أن تشبه مهمة Javac ومهمة Java Ant أدوات أوامر JAVAC وJava. لأنني استخدمت الاسم الافتراضي، تتوقع Ant ملف بناء عندما لا يتم تحديده بشكل صريح (build.xml) ولأنني قدمت هدف "التشغيل" باعتباره "الافتراضي" لهذا الإصدار ولأنني قمت بتضمين "ترجمة" كتشغيل تبعية هدف "التشغيل" ولأن Ant كان على مسار البيئة الخاصة بي، كل ما كان علي فعله في سطر الأوامر هو جعل Ant يقوم بتجميع وتشغيل مثال النمل في الدليل باستخدام ملف build.xml . يظهر هذا في لقطة الشاشة التالية. على الرغم من أنني أوضحت تجميع وتشغيل تطبيق Java بسيط باستخدام Ant، ​​إلا أنني أميل فقط إلى التجميع باستخدام Ant وتشغيله باستخدام Java (أو برنامج نصي يستدعي Java إذا كان مسار الفصل ثقيلًا).

البناء والتشغيل مع Maven

على الرغم من أن Ant كانت أول أداة بناء Java أساسية، إلا أن Apache Maven اكتسب شهرته في النهاية بسبب اعتماده على التكوين القائم على الاتفاقية ودعم مستودعات المكتبات المشتركة. يعد Maven سهل الاستخدام عندما تتبع التعليمات البرمجية والكائنات التي تم إنشاؤها تخطيط الدليل القياسي الخاص بها. لسوء الحظ، المثال الخاص بي لا يتبع بنية الدليل هذه، لكن Maven يسمح لنا بتجاوز بنية الدليل الافتراضية المتوقعة. فيما يلي قائمة من التعليمات البرمجية لملف Maven POM الذي يتم استخدامه بدلاً من دليلي المصدر والهدف ويوفر الحد الأدنى من العناصر الأخرى المطلوبة لبناء Maven باستخدام Maven 3.2.1. pom.xml

<project>
   <modelVersion>4.0.0</modelVersion>
   <groupId>dustin.examples</groupId>
   <artifactId>CompilingAndRunningWithoutIDE</artifactId>
   <version>1</version>

   <build>
      <defaultGoal>compile</defaultGoal>
      <sourceDirectory>src</sourceDirectory>
      <outputDirectory>classes</outputDirectory>
      <finalName>${project.artifactId}-${project.version}</finalName>
   </build>
</project>

نظرًا لأن ملف pom.xml أعلاه يحدد "الهدف الافتراضي" لـ "التحويل البرمجي" ولأن ملفات pom.xml هي ملف POM الافتراضي المخصص الذي يبحث عنه Maven القابل للتنفيذ (MVN) ولأن دليل سلة تثبيت Maven موجود على المسار الخاص بي، فقط أحتاج إلى تشغيل "MVN" لتجميع ملفات .class كما هو مذكور في لقطة الشاشة التالية. يمكنني أيضًا تشغيل التطبيق المترجم من Maven باستخدام أمر Mvn Exec: Java -Dexec.mainClass = Dustin.examples.Main ، وهو ما يمكن ملاحظته في لقطة الشاشة التالية. كما هو الحال مع Ant، ​​لا أميل إلى استخدام Maven لتشغيل تطبيق Java البسيط الخاص بي، ولكن بدلًا من ذلك استخدم Java على التعليمات البرمجية المجمعة (أو استخدم برنامجًا نصيًا يستدعي Java مباشرة في الفصول الطويلة).

البناء والتشغيل باستخدام Gradle

Gradle هو الإصدار الأحدث والأكثر عصرية والأناقة من بين أدوات إنشاء Java الثلاثة الرئيسية. أحيانًا ما أكون متشككًا بشأن جوهر ما هو عصري، لكنني وجدت الكثير من الأشياء التي أعجبتني في Gradle (مكتوب بلغة Groovy بدلاً من XML، ودعم Ant المدمج، ودعم Ivy المدمج، والتكوين حسب الاتفاقية وهو أمر سهل لإعادة التكوين، ودعم مستودع Maven، وما إلى ذلك). يوضح المثال التالي بناء Gradle الذي يمكن استخدامه لتجميع وتشغيل تطبيق بسيط، وهو رمز المثال الرئيسي لهذا المنشور. لقد قدمت هذا المثال المعدل على مدونة Simple Gradle Java Plugin Customization. build.gradle

apply plugin: 'java'
apply plugin: 'application'

// Redefine where Gradle should expect Java source files (*.java)
sourceSets {
    main {
        java {
            srcDirs 'src'
        }
    }
}

// Redefine where .class files are written
sourceSets.main.output.classesDir = file("classes")

// Specify main class to be executed
mainClassName = "dustin.examples.Main"

defaultTasks 'compileJava', 'run'

يشير أول سطرين من ملف build.gradle إلى استخدام المكون الإضافي Java والمكون الإضافي للتطبيق، مما يؤدي إلى إنشاء مجموعة من الوظائف تلقائيًا في هذا الإصدار. يتيح لك تحديد "sourceSets" و"sourceSets.main.output.classesDir" تجاوز أدلة Java الافتراضية الخاصة بمكون Gradle الإضافي لكود مصدر Java والفئات الثنائية المترجمة، على التوالي. ويتيح لك "MainClassName" تحديد الفئة التي يجب تشغيلها بشكل صريح داخل المكون الإضافي للتطبيق. يحدد السطر "defaultTasks" المهام التي سيتم تشغيلها بمجرد كتابة "Gradle" في سطر الأوامر: "compileJava" هي المهمة الافتراضية التي يوفرها مكون Java الإضافي و"Run" هي المهمة الافتراضية التي يوفرها المكون الإضافي للتطبيق. لأنني قمت بتسمية التجميعات build.gradle ولهذا السبب قمت بتحديد المهام الافتراضية باسم "compileJava" و"Run" ولأن لدي دليل سلة تثبيت Gradle في المسار الخاص بي، كل ما كان علي فعله لإنشاء الأمثلة وتشغيلها هو الكتابة "Gradle" وهذا موضح في لقطة الشاشة التالية. حتى أكبر المتشككين يجب أن يعترفوا بأن تصميمات Gradle زلقة للغاية بالنسبة لهذا المثال البسيط. فهو يجمع بين إيجاز الاعتماد على اتفاقيات وافتراضات معينة مع آلية سهلة للغاية لتجاوز الافتراضات عند الضرورة. حقيقة أنه موجود في Groovy بدلاً من XML هي أيضًا جذابة للغاية! كما هو الحال مع Ant وMaven، أميل إلى البناء باستخدام هذه الأدوات فقط وأميل إلى تشغيل ملفات .class المترجمة مباشرة من Java أو برنامج نصي يستدعي Java. بالمناسبة، أميل أيضًا إلى أرشفة هذه الفئات في جرة للإطلاق، لكن هذا خارج نطاق هذه المقالة.

خاتمة

غالبًا ما لا يكون IDE ضروريًا لإنشاء تطبيقات وأمثلة بسيطة ويمكن أن يكون أكثر تكلفة من تكلفة إنشاء أمثلة بسيطة. في مثل هذه الحالة، من السهل جدًا استخدام JAVAC وJava لإنشاء الأمثلة وتشغيلها مباشرةً. كأمثلة على المشاركة بشكل أكبر، تصبح أداة البناء مثل Ant أو Maven أو Gradle أكثر جاذبية. حقيقة أن العديد من بيئات التطوير تدعم أدوات البناء المساعدة هذه تعني أنه يمكن للمطور الانتقال إلى IDE باستخدام أداة مضمنة تم إنشاؤها مسبقًا في العملية إذا تقرر أن دعم IDE مطلوب عندما يتحول تطبيق بسيط إلى مشروع كامل .