ทำไมไม่มีใครใช้ make for Java?

เกือบทุกโปรเจ็กต์ Java ที่ฉันเคยเห็นใช้ Maven หรือ Ant พวกเขาเป็นเครื่องมือที่ดีและฉันคิดว่าโครงการใด ๆ สามารถใช้งานได้ แต่สิ่งที่เคยเกิดขึ้นกับให้ ? มันใช้สำหรับโครงการที่ไม่ใช่ Java ที่หลากหลายและสามารถจัดการกับ Java ได้อย่างง่ายดาย แน่นอนว่าคุณต้องดาวน์โหลด make.exe หากคุณใช้ Windows แต่ Ant และ Maven ยังไม่ได้มาพร้อมกับ JDK

มีข้อบกพร่องพื้นฐานกับ make เมื่อใช้กับ Java หรือไม่ มันเป็นเพราะ Ant และ Maven เขียนด้วยภาษาจาวาใช่ไหม

ปัญหาพื้นฐานกับ Make และ Java คือ Make ทำงานบนสมมติฐานที่คุณระบุการพึ่งพาและจากนั้นกฎเพื่อแก้ไขการพึ่งพานั้น

ด้วยพื้นฐาน C ซึ่งโดยทั่วไป "เพื่อแปลงไฟล์ main.c เป็นไฟล์ main.o ให้เรียกใช้" cc main.c "

คุณสามารถทำเช่นนั้นใน java แต่คุณเรียนรู้บางสิ่งบางอย่างได้อย่างรวดเร็ว

ส่วนใหญ่คอมไพเลอร์ javac จะเริ่มต้นช้า

ความแตกต่างระหว่าง:

javac Main.java
javac This.java
javac That.java
javac Other.java

และ

javac Main.java This.java That.java Other.java

เป็นกลางคืนและกลางวัน

ทำให้รุนแรงขึ้นด้วยคลาสหลายร้อยคลาสและมันก็ไม่สามารถป้องกันได้

จากนั้นคุณรวมสิ่งนั้นกับความจริงที่ว่า Java มีแนวโน้มที่จะจัดระเบียบเป็นกลุ่มของไฟล์ในไดเรกทอรี, vs C และอื่น ๆ ซึ่งมีแนวโน้มไปสู่โครงสร้างอี๋ ทำให้ไม่มีการสนับสนุนโดยตรงมากในการทำงานกับลำดับชั้นของไฟล์

ทำยังไม่ดีในการกำหนดไฟล์ที่ล้าสมัยในระดับคอลเลกชัน

ด้วย Ant มันจะผ่านและสรุปไฟล์ทั้งหมดที่ล้าสมัยแล้วรวบรวมในคราวเดียว Make จะเรียกคอมไพเลอร์ java ในแต่ละไฟล์ การทำให้ไม่ต้องใช้เครื่องมือภายนอกเพียงพอที่จะแสดงว่า Make ไม่ได้ขึ้นอยู่กับงาน

นั่นเป็นเหตุผลที่ทางเลือกเช่น Ant และ Maven เพิ่มขึ้น

makeโปรแกรมที่น่าเชื่อถือจัดการภาษาที่คอมไพล์แยกเช่น C และ C ++ ได้ดีพอสมควร คุณรวบรวมโมดูลมันใช้#includeเพื่อดึงข้อความของไฟล์ include อื่น ๆ และเขียนไฟล์อ็อบเจ็กต์เดียวเป็นเอาต์พุต คอมไพเลอร์เป็นระบบแบบครั้งละมากพร้อมขั้นตอนการเชื่อมโยงที่แยกต่างหากเพื่อผูกไฟล์อ็อบเจ็กต์ในไบนารีที่เรียกใช้งานได้

อย่างไรก็ตามใน Java คอมไพเลอร์มีจริงรวบรวมชั้นเรียนอื่น ๆ importที่คุณนำเข้าด้วย แม้ว่ามันจะเป็นไปได้ที่จะเขียนสิ่งที่สร้างการพึ่งพาที่จำเป็นทั้งหมดจากซอร์สโค้ด Java เพื่อที่makeจะสร้างคลาสในลำดับที่ถูกต้องในแต่ละครั้ง

คอมไพเลอร์ Java สามารถมีประสิทธิภาพมากขึ้นโดยการแคชผลลัพธ์ที่คอมไพล์แล้วของคลาสอื่น ๆ ในขณะที่คอมไพล์คลาสเพิ่มเติมที่ขึ้นอยู่กับผลลัพธ์ของคลาสที่คอมไพล์แล้ว การประเมินผลการพึ่งพาอัตโนมัติประเภทนี้ไม่สามารถทำได้โดยmakeลำพัง

คำถามขึ้นอยู่กับข้อสันนิษฐานที่ไม่ถูกต้องนักพัฒนาใช้จำนวนที่ไม่makeสำคัญ ดูJava เครื่องมือรูปร่าง: มดกับ Maven สำหรับสาเหตุที่นักพัฒนาไม่ใช้make: นักพัฒนาหลายคนไม่เคยใช้makeหรือใช้แล้วเกลียดมันด้วยไฟที่ไหม้ร้อนกว่าดวงอาทิตย์นับพัน เช่นนี้พวกเขาใช้เครื่องมือทางเลือก

ที่จริงแล้ว make สามารถจัดการการคอมไพล์ใหม่ในหนึ่งคำสั่งของไฟล์ java ที่ล้าสมัยทั้งหมด เปลี่ยนบรรทัดแรกหากคุณไม่ต้องการรวบรวมไฟล์ทั้งหมดในไดเรกทอรีหรือต้องการคำสั่งเฉพาะ ...

JAVA_FILES:=$(wildcard *.java)
#
# the rest is independent of the directory
#
JAVA_CLASSES:=$(patsubst %.java,%.class,$(JAVA_FILES))

.PHONY: classes
LIST:=

classes: $(JAVA_CLASSES)
        if [ ! -z "$(LIST)" ] ; then \
                javac $(LIST) ; \
        fi

$(JAVA_CLASSES) : %.class : %.java
        $(eval LIST+=$$<)

คำตอบอื่น ๆ ทั้งหมดเกี่ยวกับข้อดีทางเทคนิคของแต่ละคำนั้นเป็นจริง AntและMavenอาจเหมาะกับ Java มากกว่าการทำหรือแฮงค์เกย์ชี้ให้เห็นพวกเขาอาจไม่ :)

อย่างไรก็ตามคุณถามว่าสำคัญหรือไม่ที่ Ant และ Maven เขียนด้วย Java แม้ว่าใน StackOverflow เราจะไม่พิจารณาความคิดดังกล่าว (ปิด! ไม่เกี่ยวข้องกับการเขียนโปรแกรม! ฯลฯ ) แน่นอนว่าเป็นส่วนหนึ่งของสิ่งนั้น บนรางเราใช้ Rake, C เป็ดใช้ make และใน Java เราใช้ Ant และ Maven ในขณะที่มันเป็นความจริงที่นักพัฒนา Ant หรือ Maven จะดูแลนักพัฒนา Java อาจจะดีกว่าคนอื่น ๆ แต่ก็มีคำถามอื่น: คุณเขียนภารกิจ Ant ไว้ในอะไร ชวา หากคุณเป็นผู้พัฒนา Java นั่นเป็นเรื่องง่าย

ดังนั้นใช่ส่วนหนึ่งคือการใช้เครื่องมือที่เขียนในภาษาที่คุณกำลังขับรถ

Ant และต่อมา Maven ถูกออกแบบมาเพื่อแก้ปวดหัวบางอย่างที่เกิดจากMake(ในขณะที่สร้างใหม่ในกระบวนการ) มันเป็นเพียงวิวัฒนาการ

... หลังจากนั้นไม่นานโครงการ Java หลายโอเพนซอร์สก็ตระหนักว่า Ant สามารถแก้ปัญหาที่เกิดขึ้นกับ Makefiles ได้ ...

จากhttp://ant.apache.org/faq.html#history

ไม่ว่าพวกเขาจะแก้ไขอะไรหรือเพียงแค่สร้างรูปแบบเพิ่มเติมเพื่อเรียนรู้เป็นหัวข้อส่วนตัว ความจริงก็คือว่าเป็นประวัติศาสตร์ของการประดิษฐ์ใหม่ทุกครั้ง: ผู้สร้างบอกว่ามันแก้ปัญหาได้มากมายและผู้ใช้ดั้งเดิมบอกว่าสิ่งเหล่านั้นเป็นคุณธรรม

ข้อได้เปรียบหลักที่มันมีคือความเป็นไปได้ที่จะรวมกับจาวา

ผมคิดว่ามีประวัติที่คล้ายกันจะมีrakeเช่น

หนึ่งในปัญหาสำคัญที่แก้ไขโดยการตั้งค่าผ่านทาง Maven (และการตั้งค่า Ant-Ivy ที่เปิดใช้งาน Ivy) คือการแก้ปัญหาการพึ่งพาโดยอัตโนมัติและการดาวน์โหลดไหการพึ่งพาของคุณ

ฉันคิดว่าคำอธิบายที่น่าจะเป็นไปได้มากที่สุดคือมีปัจจัยหลายประการที่ทำให้การใช้ภายในชุมชน Java ไม่เป็นช่วงเวลาที่สำคัญ (ช่วงปลายทศวรรษ 1990):

1. เนื่องจาก Java มีหลายแพลตฟอร์มผู้เขียนโปรแกรม Java จึงไม่เชี่ยวชาญในเครื่องมือของ Unix เหมือนกับที่โปรแกรมเมอร์มักจะ จำกัด อยู่ที่สภาพแวดล้อม Unix (เช่น C และ Perl โปรแกรมเมอร์) โปรดทราบว่านี่เป็นแบบทั่วไป ไม่ต้องสงสัยเลยว่ามีและเป็นโปรแกรมเมอร์ Java ที่มีพรสวรรค์ด้วยความเข้าใจอย่างลึกซึ้งเกี่ยวกับ Unix
2. ดังนั้นพวกเขาจึงเชี่ยวชาญน้อยในการทำและไม่ทราบวิธีการใช้ให้ได้อย่างมีประสิทธิภาพ
3. แม้ว่ามันจะเป็นไปได้ที่จะเขียน Makefile สั้น ๆ และเรียบง่ายที่คอมไพล์ Java ได้อย่างมีประสิทธิภาพ แต่ก็ต้องระมัดระวังเป็นพิเศษด้วยวิธีที่ไม่ขึ้นกับแพลตฟอร์ม
4. ดังนั้นจึงมีความอยากอาหารสำหรับเครื่องมือสร้างอิสระภายในแพลตฟอร์ม
5. มันอยู่ในสภาพแวดล้อมนี้ที่ Ant และ Maven ภายหลังถูกสร้างขึ้น

กล่าวโดยย่อในขณะที่การทำให้แน่นอนที่สุดสามารถใช้สำหรับโครงการ Java ได้มีโอกาสที่จะทำให้มันเป็นเครื่องมือสร้าง Java อย่างแท้จริง ช่วงเวลานั้นผ่านไปแล้ว

ทำให้สคริปต์มีแนวโน้มที่จะขึ้นอยู่กับแพลตฟอร์มโดยเนื้อแท้ Java ควรจะเป็นแพลตฟอร์มอิสระ ดังนั้นการสร้างระบบที่ใช้งานได้บนแพลตฟอร์มเดียวสำหรับแพลตฟอร์มหลายแพลตฟอร์มจึงเป็นปัญหา

คำตอบสั้น ๆ : เพราะmakeไม่ดี แม้แต่ทางด้านหน้า C คุณจะเห็นทางเลือกมากมายที่โผล่ขึ้นมา

คำตอบยาว: makeมีข้อบกพร่องหลายประการที่ทำให้แทบจะไม่เหมาะสำหรับการคอมไพล์ C และไม่เหมาะสำหรับการคอมไพล์ Java คุณสามารถบังคับให้คอมไพล์ Java ได้หากต้องการ แต่คาดว่าจะพบปัญหาบางอย่างไม่มีวิธีการแก้ไขที่เหมาะสม นี่คือบางส่วน:

การแก้ปัญหาการพึ่งพา

makeโดยปกติคาดว่าไฟล์จะมีการพึ่งพาต้นไม้เหมือนกันซึ่งไฟล์หนึ่งเป็นผลลัพธ์ของการสร้างอื่น ๆ สิ่งนี้จะแสดงผลกลับเป็น C เมื่อจัดการกับไฟล์ส่วนหัว makeต้องการmakeไฟล์ -specific include ที่จะสร้างขึ้นเพื่อแสดงถึงการขึ้นต่อกันของไฟล์ C ในไฟล์ส่วนหัวดังนั้นการเปลี่ยนแปลงที่เกิดขึ้นหลังจะทำให้ไฟล์ก่อนหน้าถูกสร้างใหม่ อย่างไรก็ตามเนื่องจากไฟล์ C นั้นไม่ได้ถูกสร้างขึ้นมาใหม่ (สร้างใหม่เพียงอย่างเดียว) จึงมักจะต้องระบุเป้าหมายเป็น.PHONYทำให้มักจะต้องระบุเป้าหมายเป็น โชคดีที่ GCC รองรับการสร้างไฟล์เหล่านั้นโดยอัตโนมัติ

ใน Java การพึ่งพาสามารถเป็นแบบวงกลมและไม่มีเครื่องมือสำหรับการสร้างคลาสที่พึ่งพาอัตโนมัติในmakeรูปแบบ ภารกิจantของมันDependสามารถอ่านไฟล์คลาสโดยตรงกำหนดคลาสที่อิมปอร์ตและลบไฟล์คลาสหากมีคลาสใดล้าสมัย หากไม่มีสิ่งนี้การพึ่งพาที่ไม่สำคัญอาจส่งผลให้คุณถูกบังคับให้ใช้การสร้างที่สะอาดซ้ำแล้วซ้ำอีกลบข้อดีของการใช้เครื่องมือสร้างออก

ช่องว่างในชื่อไฟล์

แม้ว่า Java หรือ C จะไม่สนับสนุนการใช้ช่องว่างในชื่อไฟล์ซอร์สโค้ดของคุณ แต่makeนี่อาจเป็นปัญหาแม้ว่าช่องว่างจะอยู่ในพา ธ ของไฟล์ C:\My Documents\My Code\program\srcพิจารณาตัวอย่างเช่นถ้ารหัสต้นฉบับของคุณที่มีอยู่ใน makeนี้จะเพียงพอที่จะทำลาย นี่เป็นเพราะmakeถือว่าชื่อไฟล์เป็นสตริง antถือว่าเส้นทางเป็นวัตถุพิเศษ

กำลังสแกนไฟล์เพื่อสร้าง

makeต้องการการตั้งค่าอย่างชัดเจนว่าไฟล์ใดที่จะถูกสร้างขึ้นสำหรับแต่ละเป้าหมาย antอนุญาตให้ระบุโฟลเดอร์ที่จะสแกนอัตโนมัติสำหรับไฟล์ต้นฉบับ อาจดูเหมือนความสะดวกสบายเล็กน้อย แต่พิจารณาว่าใน Java แต่ละคลาสใหม่ต้องใช้ไฟล์ใหม่ การเพิ่มไฟล์เข้ากับโครงการอาจกลายเป็นเรื่องยุ่งยากอย่างรวดเร็ว

และปัญหาที่ใหญ่ที่สุดด้วยmake:

make ขึ้นอยู่กับ POSIX

คำขวัญของ Java คือ "รวบรวมเมื่อทำงานทุกที่" แต่การ จำกัด การรวบรวมระบบที่ใช้ POSIX ซึ่งการสนับสนุน Java เป็นสิ่งที่เลวร้ายที่สุดไม่ใช่ความตั้งใจ

สร้างกฎในmakeเป็นbashสคริปต์ขนาดเล็กเป็นหลัก แม้ว่าจะมีพอร์ตmakeไปยัง Windows เพื่อให้สามารถทำงานได้อย่างถูกต้อง แต่จะต้องรวมกับพอร์ตbashซึ่งรวมถึงเลเยอร์การจำลอง POSIX สำหรับระบบไฟล์

มาในสองสายพันธุ์:

1. MSYS ซึ่งพยายาม จำกัด การแปล POSIX เป็นเส้นทางของไฟล์และอาจมี gotchas ที่ไม่พึงประสงค์เมื่อใช้เครื่องมือภายนอกที่ไม่ได้สร้างขึ้นมาโดยเฉพาะสำหรับมัน

2. cygwinซึ่งให้การจำลอง POSIX ที่สมบูรณ์ อย่างไรก็ตามโปรแกรมที่ได้นั้นมีแนวโน้มที่จะยังคงใช้เลเยอร์จำลองนั้น

สำหรับเหตุผลที่บน Windows, การสร้างเครื่องมือมาตรฐานคือไม่ได้makeที่ทุกคน แต่MSBuildที่ยังเป็นเครื่องมือที่ใช้ XML antใกล้ชิดในหลักการที่จะ

ในทางตรงกันข้ามantสร้างขึ้นใน Java สามารถเรียกใช้ทุกที่และมีเครื่องมือภายในที่เรียกว่า "งาน" สำหรับจัดการไฟล์และดำเนินการคำสั่งในลักษณะที่ไม่ขึ้นกับแพลตฟอร์ม มันเพียงพอที่หลากหลายจริงที่คุณสามารถมีเวลาได้ง่ายขึ้นการสร้างโปรแกรม C ใน Windows ใช้กว่าการใช้antmake

และอีกอันหนึ่งรองสุดท้าย:

แม้แต่โปรแกรม C ก็ไม่ได้ใช้อย่างเป็นธรรมชาติ

คุณอาจจะไม่ได้แจ้งให้ทราบในขั้นต้นนี้ แต่โปรแกรม C Makefileโดยทั่วไปจะไม่ได้มาพร้อมกับ พวกเขาจะมาพร้อมกับCMakeLists.txtหรือสคริปต์การกำหนดค่าซึ่งจะสร้างที่เกิดขึ้นจริงbash Makefileในทางตรงกันข้ามแหล่งที่มาของโปรแกรม Java ที่สร้างโดยใช้antนั้นมาพร้อมกับantสคริปต์ที่สร้างไว้ล่วงหน้า A Makefileเป็นผลิตภัณฑ์ของเครื่องมืออื่น ๆ - นั่นคือจำนวนที่makeไม่เหมาะสมที่จะเป็นเครื่องมือสร้างด้วยตัวเอง antเป็นแบบสแตนด์อโลนและจัดการกับทุกสิ่งที่คุณต้องการสำหรับกระบวนการสร้าง Java ของคุณโดยไม่มีข้อกำหนดเพิ่มเติมหรือการอ้างอิงใด ๆ

เมื่อคุณรันantบนแพลตฟอร์มใด ๆ มันแค่ใช้งานได้ (tm) makeคุณไม่สามารถรับกับ มันขึ้นอยู่กับแพลตฟอร์มและการกำหนดค่าอย่างไม่น่าเชื่อ

เว้นแต่ฉันจะไม่มีใครสันนิษฐานว่าไม่มีใครใช้ (mis) ใช้สำหรับ java เป็นสิ่งที่ผิด

"การจัดการโปรmakeเจ็กต์ด้วย GNU Make" (มีให้ใน GFDL) มีบทสมบูรณ์ที่ใช้กับโปรเจ็กต์ java

เนื่องจากมีรายการข้อดีข้อเสียในการใช้แทนเครื่องมืออื่น ๆ ที่คุณอาจต้องการดู (ดู: http://oreilly.com/catalog/make3/book/ )

Ant คือการปรับปรุงการกำหนดค่า XML ที่มุ่งเน้นเหนือ Makefiles และ Maven เป็นเครื่องมือสร้างการพึ่งพาขึ้นอยู่กับ Ant บางโครงการใช้ทั้งสาม ฉันคิดว่าโครงการ JDK เคยใช้ส่วนผสมของ makefiles และ ant

เหตุผลสำคัญอย่างหนึ่งคือทั้ง Ant และ Maven (และเครื่องมือ SCM, CI และ IDE ที่กำหนดเป้าหมายจาวาส่วนใหญ่เขียนด้วยภาษาจาวาโดย / สำหรับผู้พัฒนาจาวา สิ่งนี้ทำให้ง่ายต่อการรวมเข้ากับสภาพแวดล้อมการพัฒนาของคุณและอนุญาตให้เครื่องมืออื่น ๆ เช่นเซิร์ฟเวอร์ IDE และ CI เพื่อรวมส่วนต่างๆของไลบรารี ant / maven ภายในโครงสร้างการสร้าง / การปรับใช้

กาลครั้งหนึ่งฉันทำงานเกี่ยวกับโครงการ Java ที่ใช้ gmake ความทรงจำของฉันมืดมน แต่ IIRC เรามีปัญหาในการจัดการกับโครงสร้างไดเรกทอรีแพ็คเกจที่ javac คาดหวัง ฉันยังจำได้ว่าการสร้างไฟล์ JAR นั้นเป็นเรื่องยุ่งยากเว้นแต่คุณจะมีเรื่องไม่สำคัญ

ApacheAnt ไม่ใช่ทุกอย่างที่ Make ทำให้เป็นเรื่องเกี่ยวกับการอธิบายการอ้างอิงระหว่างไฟล์และวิธีการสร้างไฟล์ Ant เป็นเรื่องเกี่ยวกับการพึ่งพาระหว่าง "งาน" และเป็นวิธีหนึ่งในการรวมสคริปต์สร้างเข้าด้วยกัน

มันอาจช่วยให้คุณAntVsMake

Ant และ Maven เข้าใกล้กราฟพึ่งพาการสร้างและการจัดการจากมุมมองที่ 'ทันสมัย' มากขึ้น ... แต่ออสการ์กล่าวว่าพวกเขาสร้างปัญหาของตัวเองในขณะที่พยายามแก้ไขปัญหาเก่า ๆ ด้วยการทำ

ฉันไม่เคยใช้ GNU Make สำหรับโครงการ Java แต่ฉันเคยใช้jmk JMKน่าเศร้าที่มันไม่ได้รับการปรับปรุงตั้งแต่ปี 2002

มันมีฟังก์ชั่นเฉพาะของ Java แต่มีขนาดเล็กพอที่จะรวมไว้ใน tarball ต้นทางของคุณโดยไม่เพิ่มขนาดอย่างมีนัยสำคัญ

ทุกวันนี้ฉันเพิ่งสันนิษฐานว่านักพัฒนา Java คนใดที่ฉันแชร์รหัสด้วยมีการติดตั้ง Ant