การคอมไพล์และรัน Java โดยไม่มี IDE

ครั้งหนึ่งบนreddit.comในหัวข้อการคอมไพล์และการรัน Java โดยไม่มี IDEคำถามถูกถาม: มีคำสั่งที่รวบรวมกลุ่มของไฟล์ Java ที่อยู่ภายในแพ็คเกจลงในโฟลเดอร์แยกต่างหาก (ขอเรียกว่าbin ) และฉันจะเปิดไฟล์คลาสใหม่ได้อย่างไร " ผู้เขียนหัวข้อkylolinkอธิบายว่า: "เมื่อฉันเริ่มใช้ Java ฉันอาศัย Eclipse ในการคอมไพล์ทั้งหมดให้ฉันและกังวลแค่เรื่องการเขียนโค้ด" ฉันเคยเห็นคำถามนี้หลายครั้ง และแน่นอนว่าสิ่งนี้ คือสิ่งที่กระตุ้นให้ฉันโพสต์บล็อกระบบ GPS และ IDE: ดีหรือไม่ดี ฉันชอบ Java IDE สมัยใหม่ที่ทรงพลังและทำให้ชีวิตของฉันง่ายขึ้นในแต่ละวัน โพสต์นี้เกี่ยวกับวิธีการทำเช่นนั้น ในบล็อกของฉันเกี่ยวกับการเรียนรู้ Java ด้วยการทดสอบอย่างง่าย ฉันเขียนเกี่ยวกับวิธีที่บางครั้งฉันชอบใช้โปรแกรมแก้ไขข้อความอย่างง่ายและเครื่องมือบรรทัดคำสั่งเพื่อเขียน สร้าง และเรียกใช้แอปพลิเคชันง่ายๆ ฉันมี เป็นความคิดที่ดีในตอนนี้ว่า Java IDE ที่ฉันชื่นชอบต้องการ "ค่าใช้จ่าย" เท่าใด และตัดสินใจตั้งแต่เนิ่นๆ ว่าประโยชน์ที่ได้รับจากการใช้เฟรมเวิร์กนั้นเพียงพอที่จะพิสูจน์ "ค่าใช้จ่าย" หรือไม่ ในแอปพลิเคชันจริงส่วนใหญ่ ไม่ต้องสงสัยเลยว่า VL IDE นั้นคุ้มค่ามาก อย่างไรก็ตาม สำหรับตัวอย่างการใช้งานที่ง่ายที่สุด อาจไม่เป็นเช่นนั้นเสมอไป ส่วนที่เหลือของโพสต์นี้แสดงวิธีการสร้างและรันโค้ด Java โดยไม่ต้องใช้ IDE สำหรับสถานการณ์เหล่านี้

การเขียนและการรันโค้ด Java

เพื่อ ให้ตัวอย่างชัดเจนยิ่งขึ้น ฉันจะใช้คลาส 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.";
   }
}

เด็ก.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 -help หรือเครื่องมือ Java และระบุตำแหน่งของ ไฟล์ .classด้วย อ็อพชัน -classpath( หรือ-cp) การใช้ทั้งสองวิธีเพื่อระบุไดเร็กทอรีคลาสที่จะค้นหา ไฟล์ .classจะแสดงในภาพหน้าจอต่อไปนี้ อาร์กิวเมนต์สุดท้ายคือชื่อเต็ม (แพ็คเกจ Java ทั้งหมด) ของคลาสที่มีฟังก์ชันหลักที่จะดำเนินการ คำสั่งที่แสดงในภาพหน้าจอต่อไปนี้คือคลาส java -cp dustin.examples.Main และคลาส java -classpath dustin.examples.Main

การสร้างและดำเนินการกับ Ant

สำหรับแอปพลิเคชัน Java ที่ง่ายที่สุด การใช้ JAVAC และ Java เพื่อสร้างและรันแอปพลิเคชันนั้นค่อนข้างง่าย ตามลำดับ ตามที่ได้สาธิตไปแล้ว เนื่องจากแอปพลิเคชันมีความซับซ้อนมากขึ้นเล็กน้อย (เช่น โค้ดที่มีอยู่ในแพ็คเกจ/ไดเร็กทอรีมากกว่าหนึ่งรายการ หรือมีคลาสการพึ่งพาที่ซับซ้อนมากขึ้นในไลบรารีและเฟรมเวิร์กของบุคคลที่สาม) วิธีการนี้อาจกลายเป็นเรื่องยุ่งยากได้ Apache Ant เป็นเครื่องมือสร้าง Java ที่เก่าแก่ที่สุดในบรรดา "สามยักษ์ใหญ่" และถูกนำมาใช้ในแอปพลิเคชันและการปรับใช้หลายพันรายการ ดังที่ฉันได้กล่าวไว้ในโพสต์บล็อกก่อนหน้านี้ ไฟล์ Ant build ที่เรียบง่ายนั้นสร้างได้ง่าย โดยเฉพาะอย่างยิ่งหากเริ่มต้นด้วยเทมเพลตอย่างที่ฉันอธิบายไว้ในโพสต์นี้ รายการโค้ดต่อไปนี้ใช้สำหรับไฟล์ build.xmlของ Ant ซึ่งสามารถใช้เพื่อเขียน ไฟล์ .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 และไม่ได้รวมเป้าหมายทั่วไปที่ฉันมักจะรวมไว้ (เช่น "บริสุทธิ์" และ "Javadoc") เพื่อให้ตัวอย่างนี้ง่ายที่สุดเท่าที่จะทำได้ และเก็บไว้ใกล้กับตัวอย่างก่อนหน้าโดยใช้ JAVAC และ Java . โปรดทราบว่าฉันได้เปิดใช้งานการตั้งค่า "debug" เป็น "true" สำหรับงาน JAVAC Ant เนื่องจากสิ่งนี้ไม่เป็นความจริงในกรณีที่ Ant ล้มเหลว แต่จะเป็นจริงกับค่าเริ่มต้นของ JAVAC ไม่น่าแปลกใจที่งาน Javac และงาน Java Ant มีลักษณะคล้ายกับเครื่องมือคำสั่ง JAVAC และ Java เนื่องจากฉันใช้ชื่อเริ่มต้น Ant คาดหวังไฟล์บิลด์เมื่อไม่ได้ระบุอย่างชัดเจน (build.xml) และเนื่องจากฉันระบุเป้าหมาย "Run" เป็น "ค่าเริ่มต้น" สำหรับบิลด์นี้ และเนื่องจากฉันรวม "คอมไพล์" เป็นการรันการพึ่งพา เป้าหมาย "เรียกใช้" และเนื่องจาก Ant อยู่บนเส้นทางของสภาพแวดล้อมของฉัน สิ่งที่ฉันต้องทำบนบรรทัดคำสั่งคือให้ Ant คอมไพล์และรันตัวอย่าง ant ในไดเร็กทอรีด้วยไฟล์build.xml นี่จะแสดงในภาพหน้าจอต่อไปนี้ แม้ว่าฉันได้สาธิตการคอมไพล์และรันแอปพลิเคชัน Java แบบธรรมดาด้วย Ant แล้ว แต่ฉันมักจะคอมไพล์ด้วย Ant และรันด้วย Java เท่านั้น (หรือสคริปต์ที่เรียก Java หาก classpath นั้นหนัก)

การสร้างและดำเนินการด้วย 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 ด้านบน กำหนด "defaultGoal" ของ "compile" และเนื่องจาก ไฟล์ pom.xmlเป็น POM เริ่มต้นที่กำหนดเองที่ Maven executable (MVN) ค้นหา และเนื่องจากไดเร็กทอรี bin การติดตั้ง 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 build ที่สามารถใช้เพื่อคอมไพล์และรันแอปพลิเคชันแบบง่าย ซึ่งเป็นโค้ดตัวอย่างหลักสำหรับโพสต์นี้ ฉันนำเสนอตัวอย่างที่ดัดแปลงนี้ในบล็อก 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 และปลั๊กอิน Application ส่งผลให้มีฟังก์ชันการทำงานมากมายรวมอยู่ในบิลด์นี้โดยอัตโนมัติ การกำหนด "sourceSets" และ "sourceSets.main.output.classesDir" ช่วยให้คุณสามารถแทนที่ไดเร็กทอรี Java เริ่มต้นของปลั๊กอิน Gradle สำหรับซอร์สโค้ด Java และคลาสไบนารีที่คอมไพล์แล้วตามลำดับ "MainClassName" ช่วยให้คุณระบุอย่างชัดเจนว่าควรรันคลาสใดภายใน ปลั๊กอินแอปพลิเคชัน บรรทัด "defaultTasks" กำหนดงานที่จะทำงานโดยเพียงพิมพ์ "Gradle" บนบรรทัดคำสั่ง: 'compileJava' เป็นงานเริ่มต้นที่จัดทำโดยปลั๊กอิน Java และ 'Run' เป็นงานเริ่มต้นที่จัดทำโดยปลั๊กอินแอปพลิเคชัน เนื่องจากฉันตั้งชื่อแอสเซมบลี build.gradle และนั่นคือสาเหตุที่ฉันระบุงานเริ่มต้นเป็น 'compileJava' และ 'Run' และเนื่องจากฉันมีไดเร็กทอรีถังการติดตั้ง Gradle ในเส้นทางของฉัน สิ่งที่ฉันต้องทำทั้งหมดเพื่อสร้างและรันตัวอย่างคือพิมพ์ 'Gradle' และสิ่งนี้แสดงให้เห็นในภาพหน้าจอต่อไปนี้ แม้แต่คนที่ขี้ระแวงที่สุดก็ต้องยอมรับว่า Gradle builds นั้นลื่นมากสำหรับตัวอย่างง่ายๆนี้ โดยผสมผสานความกระชับของการพึ่งพาแบบแผนและสมมติฐานบางประการเข้ากับกลไกที่ง่ายมากในการแทนที่ค่าเริ่มต้นเมื่อจำเป็น ความจริงที่ว่ามันอยู่ใน Groovy แทนที่จะเป็น XML ก็น่าดึงดูดมากเช่นกัน! เช่นเดียวกับ Ant และ Maven ฉันมักจะสร้างด้วยเครื่องมือเหล่านี้เท่านั้น และมีแนวโน้มที่จะเรียกใช้ไฟล์ .class ที่คอมไพล์แล้วโดยตรงจาก Java หรือสคริปต์ที่เรียก Java อย่างไรก็ตาม ฉันมักจะเก็บ .classes เหล่านี้ไว้ใน jar เพื่อเปิดใช้งานด้วย แต่นั่นอยู่นอกเหนือขอบเขตของบทความนี้

บทสรุป

IDE มักไม่จำเป็นในการสร้างแอปพลิเคชันและตัวอย่างง่ายๆ และอาจมีราคาแพงกว่าต้นทุนในการสร้างตัวอย่างง่ายๆ ด้วยซ้ำ ในกรณีเช่นนี้ การใช้ JAVAC และ Java เพื่อสร้างและรันตัวอย่างโดยตรงนั้นค่อนข้างง่าย ตัวอย่างของการมีส่วนร่วมมากขึ้น เครื่องมือสร้างเช่น Ant, Maven หรือ Gradle จะน่าดึงดูดยิ่งขึ้น ความจริงที่ว่าสภาพแวดล้อมการพัฒนาจำนวนมากรองรับยูทิลิตี้บิลด์เหล่านี้ หมายความว่านักพัฒนาสามารถย้ายไปยัง IDE โดยใช้เครื่องมือในตัวที่สร้างขึ้นก่อนหน้านี้ในกระบวนการ หากพิจารณาแล้วว่าจำเป็นต้องมีการสนับสนุน IDE เนื่องจากแอปพลิเคชันธรรมดาขยายเป็นโปรเจ็กต์ที่เต็มเปี่ยม .