Perché nessuno si usa fare per Java?

https://stackoverflow.com/questions/2209827

18-09-2019
|

Domanda

Quasi ogni progetto Java che ho visto o utilizza in Maven o Ant. Si tratta di strumenti sottili e penso che quasi ogni progetto può usarli. Ma che cosa mai è successo a fare ? E 'usato per una varietà di progetti non-Java e può facilmente gestire Java. Certo è necessario scaricare make.exe se si utilizza Windows, ma Ant e Maven anche non venire con il JDK.

C'è qualche difetto fondamentale con make quando viene utilizzato con Java? E 'solo perché Ant e Maven sono scritti in Java?

Soluzione

Il problema fondamentale con la Marca e Java è che creare opere sul presupposto che si dispone di indicare una dipendenza, e poi una regola per risolvere tale dipendenza.

Con C di base, che in genere "per convertire un file main.c in un file main.o, eseguire "cc main.c".

Si può fare in Java, ma si impara in fretta qualcosa.

Per lo più che il compilatore javac è lento a partire.

La differenza tra:

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

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

è notte e giorno.

esacerbare che con centinaia di classi, e diventa semplicemente insostenibile.

Poi si combinano con il fatto che Java tende ad essere organizzati come gruppi di file nelle directory, vs C e altri che tendono verso una struttura più piatta. Fare non ha molto supporto diretto a lavorare con le gerarchie di file.

Crea, inoltre, non è molto bravo a determinare quali file non sono aggiornati, ad un livello di raccolta.

Con Ant, andrà attraverso e riassumere tutti i file che sono fuori moda, e poi li compila in una volta sola. Fare sarà sufficiente chiamare il compilatore java su ogni singolo file. Avendo apportate non fare questo richiede abbastanza utensili esterna per dimostrare davvero che fanno non è del tutto all'altezza del compito.

Ecco perché alternative come Ant e Maven insorsero.

Altri suggerimenti

Il programma make venerabile gestisce separatamente compilato linguaggi come C e C ++ ragionevolmente bene. Si compila un modulo, usa #include a tirare nel testo di altri include i file, e scrive un file singolo oggetto come output. Il compilatore è molto un sistema di one-at-a-tempo, con un passo di collegamento separato per legare i file oggetto in un binario eseguibile.

Tuttavia, in Java, il compilatore deve in realtà di compilazione altre classi che importate con import. Anche se sarebbe possibile scrivere qualcosa che ha generato tutte le dipendenze necessarie dal codice sorgente di Java, in modo che make avrebbe costruito le classi nell'ordine corretto, uno alla volta, questo ancora non sarebbe gestire casi come dipendenze circolari.

Il compilatore Java può anche essere più efficiente memorizzando i risultati elaborati di altre classi durante la compilazione ulteriori classi che dipendono dai risultati di quelle già compilati. Questo tipo di valutazione automatica delle dipendenze non è davvero possibile con la sola make.

La domanda si basa su un presupposto errato: un numero non banale di sviluppatori fare uso make. Vedere Java creare strumenti: Ant vs Maven . Per quanto riguarda il motivo per cui uno sviluppatore non sarebbe uso make: molti sviluppatori non hanno mai utilizzato sia make, o usato e odiato con un fuoco che brucia più caldo di mille soli. Come tali, essi usano strumenti alternativi.

In realtà, rendere in grado di gestire la ricompilazione in un solo comando di tutti i file java obsoleti. Modificare la prima riga se non si desidera compilare tutti i file nella directory o vuole un ordine specifico ...

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+=$$<)

Tutte le altre risposte circa i meriti tecnici di ciascuna sono vere. Ant e Maven possono essere più adatto a Java di fare, o come sottolinea Hank Gay, essi non possono:)

Tuttavia, è chiesto se è importante che Ant e Maven sono scritti in Java. Anche se su StackOverflow non consideriamo questi pensieri (chiuso! Non-programmazione-correlate! Etc.), naturalmente, che fa parte della cosa. Su rotaie usiamo Rake, C tizi fanno uso, e in Java usiamo Ant e Maven. Mentre è vero che gli sviluppatori formica o Maven si occuperanno lo sviluppatore Java, forse meglio di altri, c'è anche un'altra domanda: che cosa si scrive in attività Ant? Giava. Se sei uno sviluppatore Java, che è una misura semplice.

Quindi sì, parte di essa è quello di utilizzare gli strumenti scritti nella lingua che si sta Tooling.

Ant e Maven in seguito sono stati progettati per risolvere alcuni mal di testa causati da Make (mentre la creazione di nuovi nel processo) E 'solo l'evoluzione.

... Poco dopo, diversi progetti Java open source sono resi conto che Ant potrebbe risolvere i problemi che avevano con Makefiles ....

http://ant.apache.org/faq.html#history

Sia che risolvono nulla o semplicemente creare un formato di più per imparare è un argomento soggettivo. La verità è che è praticamente la storia di ogni nuova invenzione: Il creatore dice che risolve un sacco di problemi e gli utenti originali dire quelle sono le virtù.

Il vantaggio principale che ha, è la possibilità di integrare con Java.

Credo che una storia simile sarebbe con rake per esempio.

Uno dei principali problemi risolti da Maven (e Ivy-enabled configurazioni Ant) su make è automatizzato risoluzione delle dipendenze e il download dei vostri vasetti di dipendenza.

Credo che la spiegazione più probabile è che diversi fattori scoraggiato l'uso del make all'interno della comunità Java in un periodo critico di tempo (alla fine del 1990):

Poiché Java comprende piattaforme multiple, i programmatori Java in generale non erano così abili a strumenti Unix così come lo erano i programmatori generalmente confinati in un ambiente Unix (ad esempio, C e Perl programmatori). Si noti che questo è IN GENERE. Senza dubbio ci sono e sono stati dotati programmatori Java con una profonda comprensione di Unix.
Di conseguenza, essi sono stati meno abili a marca e non sapevano come utilizzare in modo efficace fare.
Anche se è possibile scrivere un Makefile breve e semplice che si compila in modo efficiente Java, particolare attenzione è tenuto a farlo in un modo indipendente dalla piattaforma.
Di conseguenza c'era un appetito per uno strumento di compilazione indipendente dalla piattaforma intrinsecamente.
E 'in questo ambiente che Ant e Maven in seguito sono stati creati.

In breve, mentre fanno certamente può essere utilizzato per progetti Java, c'è stato un momento di opportunità per rendere di fatto Java tool di creazione. Quel momento è passato.

Fai script tendono ad essere la piattaforma intrinsecamente dipendente. Java si suppone che sia indipendente dalla piattaforma. Quindi avere un sistema di compilazione che funziona solo su una piattaforma per un sourcebase multi-piattaforma è kindof un problema.

A meno che io non sono un presupposto nessuno è (mis) usando fanno per Java è sbagliato.

"gestione dei progetti con GNU Make" (disponibile sotto GFDL) contiene un capitolo completo dedicato all'utilizzo make con progetti Java.

Dato che contiene una lunga (e, si spera fiera) l'elenco dei pro e dei contro di utilizzare fanno al posto di altri strumenti si potrebbe desiderare di dare un'occhiata lì. (Vedi: http://oreilly.com/catalog/make3/book/ )

Risposta breve: Perché make non è buona. Anche sul fronte C che si vede molte alternative popping up.

Risposta lunga: make ha diversi difetti che lo rendono poco adatto per la compilazione C, e inadatta a tutti per la compilazione Java. È possibile forzare la compilazione Java, se si vuole, ma si aspettano incorrere in problemi, alcuni dei quali non hanno una soluzione o una soluzione adatta. Qui ci sono alcuni:

risoluzione delle dipendenze

make prevede intrinsecamente file di avere una dipendenza ad albero a vicenda, in cui un file è l'uscita della costruzione di molti altri. Questo ritorce già in C quando si tratta di file di intestazione. make richiede una specifica-make file include da generare per rappresentare la dipendenza di un file C sulle file di intestazione, quindi una modifica a quest'ultimo causerebbe la prima da ricostruire. Tuttavia, dato che il file C in sé non viene ricreata (solo ricostruito), fare spesso richiede specificando la destinazione come .PHONY. Fortunatamente, GCC supporta la generazione automatica di tali file.

In Java, la dipendenza può essere circolare, e non c'è strumento per le dipendenze classe auto-generazione in formato make. compito ant di Depend può, invece, leggere il file di classe direttamente, determinare quali classi importa, ed eliminare il file di classe se qualcuno di loro non sono aggiornati. Senza questo, qualsiasi dipendenza non banale può provocare voi che siete costretti ad usare ripetuto pulito costruisce, eliminando ogni vantaggio di utilizzare un tool di creazione.

Spazi nei nomi dei file

Mentre né Java né C incoraggiano l'uso di spazi nei nomi dei file di codice sorgente, in make questo può essere un problema, anche se gli spazi sono nel percorso del file. Si consideri, ad esempio, se il codice sorgente esiste in C:\My Documents\My Code\program\src. Questo sarebbe sufficiente a rompere make. Questo perché make considera i nomi di file come stringhe. ant tratta percorsi come oggetti speciali.

La scansione dei file per costruire

make richiede esplicitamente ambiente che file devono essere costruiti per ogni destinazione. ant permette di specificare una cartella che è quello di essere auto-digitalizzata per i file di origine. Può sembrare un vantaggio minore, ma considerare che in Java ogni nuova classe richiede un nuovo file. L'aggiunta di file al progetto può diventare un grande veloce seccatura.

E il problema più grande con make:

fanno è

POSIX-dipendente

Il motto di Java è "compilare una volta correre ovunque". Ma limitando che la compilazione per sistemi POSIX-based, in cui il supporto Java è in realtà il peggiore, non è l'intenzione.

regole Costruire in make sono essenzialmente piccoli script bash. Anche se v'è un porto di make a Windows, per farlo funzionare correttamente, deve essere fornito in bundle con una porta di bash, che comprende uno strato di emulazione POSIX per il file system.

Questo è disponibile in due varietà:

MSYS che cerca di limitare la traduzione POSIX su file percorsi, e possono quindi avere grattacapi sgradevoli durante l'esecuzione non strumenti esterni realizzati appositamente per esso.
cygwin che fornisce un'emulazione POSIX completa. I programmi risultanti, tuttavia, tendono a fare affidamento ancora su quello strato di emulazione.

Per questo motivo, in Windows, il tool di creazione di serie non è nemmeno make a tutti, ma piuttosto MSBuild, che è anche uno strumento basato su XML, più vicino in linea di principio ant.

Al contrario, ant è costruito in Java, può essere eseguito in tutto il mondo, e contiene strumenti interni, chiamati "compiti", per manipolare file e l'esecuzione di comandi in modo indipendente dalla piattaforma. E 'sufficientemente versatile che si può effettivamente avere un tempo più facile la costruzione di un programma C in Windows utilizzando ant rispetto all'utilizzo di make.

E un'ultima minore uno:

programmi

Anche C non usano fare nativamente

Si può inizialmente non notare questo, ma i programmi C in genere non vengono forniti con un Makefile. Essi vengono forniti con un CMakeLists.txt, o di uno script di configurazione bash, che genera il Makefile vero e proprio. Al contrario, la sorgente di un programma Java costruito utilizzando ant viene fornito con uno script ant pre-costruita. Un Makefile è un prodotto di altri strumenti - Questo è quanto make non è adatto per essere uno strumento di compilazione per conto suo. ant è autonomo, e si occupa di tutto il necessario per il processo di compilazione Java, senza ulteriori requisiti o le dipendenze.

Quando si esegue ant su qualsiasi piattaforma, funziona da solo (tm). Non si può ottenere che con make. E 'incredibilmente piattaforma e la configurazione dipendente.

Ant è un miglioramento orientato configurazione XML sopra Makefiles e Maven è una dipendenza miglioramento strumento di compilazione su Ant. Alcuni progetti utilizzano tutti e tre. Credo che i progetti JDK usato per usare un mix di makefile e formica.

Un grande motivo è che sia Ant e Maven (e la maggior parte java mirati SCM, CI e strumenti IDE) sono scritti in Java da / per gli sviluppatori Java. Questo rende più semplice da integrare nel vostro ambiente di sviluppo e permette ad altri strumenti come i server IDE e CI per integrare porzioni delle librerie / Maven formica all'interno dell'infrastruttura build / distribuzione.

Una volta ho lavorato su un progetto Java che ha utilizzato gmake. Il mio ricordo è nebuloso, ma IIRC abbiamo avuto un momento difficile trattare con la struttura di directory pacchetto che javac si aspetta. Ricordo anche che la costruzione di file JAR era una seccatura a meno che non si aveva qualcosa di banale.

Apache Ant non è nulla di simile Marchio. Fare sta descrivendo le dipendenze tra i file, e come costruire i file. Ant è sulle dipendenze tra i "compiti", ed è davvero più di un modo di incollaggio costruire script insieme.

si può aiuta a AntVsMake

Ant e Maven avvicinare il grafico di compilazione delle dipendenze e la gestione di esso da una visione più 'moderno' ... Ma, come dice Oscar, hanno creato i loro problemi durante il tentativo di risolvere i vecchi problemi con il make.

Non ho mai usato GNU Make per progetti Java, ma ho usato per usare JMK . Purtroppo non è stato aggiornato dal 2002.

Aveva alcune funzionalità Java-specifici, ma era abbastanza piccolo da includere nel pacchetto dei sorgenti senza aumentare in modo significativo la sua dimensione.

Oggi ho appena assumo ogni sviluppatore I Codice quota di Java con ha installato Ant.

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow