Compilazione ed esecuzione di Java senza IDE

Un tempo su reddit.com , nell'argomento Compilazione ed esecuzione di Java senza IDE , veniva posta la domanda: esiste un comando che compila un gruppo di file Java che si trovano all'interno di un pacchetto in una cartella separata (chiamiamolo bin ) e come potrei avviare nuovi file di classe? " L'autore dell'argomento, kylolink , spiega: "Quando ho iniziato a utilizzare Java, ho fatto affidamento su Eclipse per eseguire tutta la compilazione per me ed ero solo preoccupato di scrivere il codice." Ho visto questa domanda molte volte e, in effetti, questa è ciò che cosa mi ha spinto a pubblicare sul blog sistemi GPS e IDE: buoni o cattivi? Adoro i potenti IDE Java moderni e mi semplificano la vita quotidiana, ma ci sono anche vantaggi nel sapere come creare ed eseguire semplici esempi Java senza loro. Questo post spiega come fare proprio questo. Nel mio blog sull'apprendimento di Java con semplici test, ho scritto di come a volte mi piace utilizzare un semplice editor di testo e strumenti da riga di comando per scrivere, creare ed eseguire semplici applicazioni. Ho ora ho una buona idea di quanto "overhead" richiedono i miei IDE Java preferiti e prendo una decisione tempestiva se i vantaggi ottenuti utilizzando il framework sono sufficienti per giustificare il "overhead". Nella maggior parte delle applicazioni reali, non c'è dubbio che l'IDE VL valga molto. Tuttavia, per le applicazioni di esempio più semplici, questo non è sempre il caso. Il resto di questo post mostra come creare ed eseguire codice Java senza IDE per queste situazioni.

Scrittura ed esecuzione di codice Java

Per rendere l'esempio più chiaro, utilizzerò alcune classi Java molto semplici che sono correlate tra loro tramite composizione o ereditarietà e si trovano nello stesso pacchetto chiamato Dustin.examples . A due classi manca una funzione main; la terza classe, Main.java, ha una funzione mainche consente di dimostrare come eseguire la classe senza un IDE. Di seguito è riportato il codice per queste tre classi: 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);
   }
}

Lo screenshot seguente mostra la struttura delle directory con queste classi .java . Lo screenshot mostra che i file sorgente si trovano nella gerarchia di directory che rappresenta il nome del pacchetto ( dustin/examples perché le informazioni sul pacchetto sonodustin.examples ) e che questo pacchetto riflette la gerarchia delle directory si trova nella sottodirectory SRC. Ho anche creato una sottodirectory di classi (che attualmente è vuota) per ospitare i file .class compilati in modo che Javac non crei questa directory quando non esiste.

Costruire con JAVAC ed eseguire con Java

Non importa quale approccio si utilizza per creare codice Java (Ant, Maven, Gradle o IDE), alla fine si tratta di JAVAC. Le opzioni standard nello strumento della riga di comando JAVAC fornito da Oracle/Sun possono essere visualizzate eseguendo JAVAC -help e opzioni di estensione aggiuntive possono essere visualizzate eseguendo JAVAC -help -X. Ulteriori informazioni su come utilizzare queste opzioni possono essere trovate nella documentazione dello strumento JAVAC per Windows o Unix/Linux. Come dice la documentazione Javac, l'opzione -sourcepath può essere utilizzata per esprimere la directory in cui esistono i file sorgente. Nella struttura della mia directory mostrata nello screenshot qui sopra, ciò significa che, presupponendo che sto eseguendo il comando JAVAC dalla directory C:\Java\examples\javacAndJava\ , dovrei avere qualcosa di simile nel mio comando: Javac -sourcepath src SRC\Dustin\esempi\*. Giava . Lo screenshot seguente mostra i risultati di ciò. Poiché non abbiamo specificato una directory per i file .class , questi sono stati posizionati per impostazione predefinita nella stessa directory dei file .java di origine da cui sono stati composti. Possiamo usare l'opzione -dper risolvere questa situazione. Il nostro comando può essere eseguito ora, ad esempio, come Javac -sourcepath src -d classi src\Dustin\examples\*. Io tu . Come notato in precedenza, la cartella (classi) selezionata deve già esistere. Quando ciò accade, il comando posizionerà i file .class nella cartella specificata come mostrato nello screenshot seguente. Con i file sorgente Java compilati nei corrispondenti file .class nella directory specificata, possiamo avviare l'applicazione utilizzando il menu di avvio rapido del Strumento da riga di comando Java. Questo viene fatto semplicemente seguendo le istruzioni fornite nelle pagine Java -help o Java tools e specificando la posizione dei file .class con l' opzione -classpath( o -cp). L'utilizzo di entrambi gli approcci per specificare la directory delle classi in cui cercare i file .class è illustrato nello screenshot seguente. L'ultimo argomento è il nome completo (intero pacchetto Java) della classe che ha la funzione principale da eseguire. I comandi dimostrati nello screenshot seguente sono le classi Java -cp Dustin.examples.Main e le classi Java -classpath Dustin.examples.Main.

Costruire e correre con Ant

Per le applicazioni Java più semplici, è abbastanza semplice utilizzare JAVAC e Java rispettivamente per creare ed eseguire l'applicazione, come appena dimostrato. Poiché le applicazioni diventano un po' più complesse (ad esempio, codice esistente in più di un pacchetto/directory o classi di dipendenza più complesse su librerie e framework di terze parti), questo approccio può diventare ingombrante. Apache Ant è il più antico dei "tre grandi" strumenti di creazione Java ed è stato utilizzato in migliaia di applicazioni e distribuzioni. Come ho detto in un post precedente sul blog, un file di build Ant molto semplice è facile da creare, soprattutto se inizia con un modello come quello delineato in questo post. Il seguente elenco di codici riguarda il file build.xml di Ant , che può essere utilizzato per comporre file .java in file .class e quindi eseguire la classedustin.examples.Main come è stato fatto in precedenza con JAVAC e 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>

Non ho utilizzato le proprietà Ant e non ho incluso gli obiettivi comuni che di solito includo (come "puro" e "Javadoc") per mantenere questo esempio il più semplice possibile e mantenerlo vicino all'esempio precedente utilizzando JAVAC e Java . Tieni inoltre presente che ho abilitato "debug" impostato su "true" per l'attività JAVAC Ant perché questo non è vero in caso di errore di Ant, ma è vero con l'impostazione predefinita di JAVAC. Non sorprende che l'attività Javac e l'attività Java Ant assomiglino agli strumenti di comando JAVAC e Java. Poiché ho utilizzato il nome predefinito, Ant si aspetta un file di build quando non è specificato esplicitamente (build.xml) e poiché ho fornito il target "Esegui" come "predefinito" per questa build e poiché ho incluso "compile" come esecuzione dipendente il target "Esegui" e poiché Ant era sul percorso del mio ambiente, tutto quello che dovevo fare sulla riga di comando era fare in modo che Ant compilasse ed eseguisse l'esempio di fornt nella directory con il file build.xml . Questo è mostrato nello screenshot seguente. Anche se ho dimostrato di compilare ed eseguire una semplice applicazione Java con Ant, tendo a compilare solo con Ant ed eseguire con Java (o uno script che chiama Java se il classpath è pesante).

Costruire ed eseguire con Maven

Sebbene Ant sia stato il primo strumento di creazione Java di base, Apache Maven alla fine ha guadagnato la sua fama in gran parte grazie all'adozione della configurazione basata su convenzioni e al supporto per i repository di librerie condivise. Maven è facile da usare quando il codice e gli oggetti generati seguono il layout di directory standard. Sfortunatamente, il mio esempio non segue questa struttura di directory, ma Maven ci consente di sovrascrivere la struttura di directory predefinita prevista. L'elenco seguente è il codice per un file Maven POM che viene utilizzato al posto delle directory di origine e di destinazione e fornisce gli altri elementi minimi richiesti per una build Maven utilizzando 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>

Poiché il file pom.xml sopra definisce il "defaultGoal" di "compile" e poiché il file pom.xml è la personalizzazione POM predefinita cercata dall'eseguibile Maven (MVN) e poiché la directory bin di installazione di Maven si trova sul mio percorso, solo Devo eseguire "MVN" per compilare i file .class come menzionato nello screenshot seguente. Posso anche eseguire l'applicazione compilata da Maven utilizzando il comando Mvn Exec: Java -Dexec.mainClass =dustin.examples.Main , che si osserva nello screenshot seguente. Come con Ant, tendo a non utilizzare Maven per eseguire la mia semplice applicazione Java, ma utilizzo invece Java sul codice compilato (o utilizzo uno script che chiama Java direttamente su classi a lunga esecuzione).

Costruire e gestire con Gradle

Gradle è il più nuovo, trendy ed elegante dei tre principali strumenti di creazione Java. A volte sono scettico sull'essenza di ciò che è di moda, ma ho trovato molte cose che mi piacciono di Gradle (scritto in Groovy invece che in XML, supporto Ant integrato, supporto Ivy integrato, configurazione per convenzione facile da riconfigurare, supporto del repository Maven e così via). L'esempio seguente mostra una build Gradle che può essere utilizzata per compilare ed eseguire una semplice applicazione, che è il codice di esempio principale per questo post. Ho presentato questo esempio adattato sul blog 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'

Le prime due righe del file build.gradle indicano l'uso del plugin Java e del plugin dell'applicazione, con il risultato che una serie di funzionalità verranno automaticamente integrate in questa build. La definizione di "sourceSets" e "sourceSets.main.output.classesDir" consente di sovrascrivere le directory Java predefinite del plugin Gradle per il codice sorgente Java e le classi binarie compilate, rispettivamente. "MainClassName" consente di specificare esplicitamente quale classe deve essere eseguita all'interno del Plugin dell'applicazione. La riga "defaultTasks" definisce le attività che verranno eseguite semplicemente digitando "Gradle" sulla riga di comando: "compileJava" è l'attività predefinita fornita dal plug-in Java e "Esegui" è l'attività predefinita fornita dal plug-in dell'applicazione. Poiché ho chiamato gli assembly build.gradle ed è per questo che ho specificato le attività predefinite come 'compileJava' ed 'Esegui' e poiché ho la directory bin di installazione di Gradle nel mio percorso, tutto quello che dovevo fare per creare ed eseguire gli esempi era digitare 'Gradle' e questo è dimostrato nello screenshot seguente. Anche il più grande scettico deve ammettere che le build di Gradle sono molto sfuggenti per questo semplice esempio. Combina la concisione di fare affidamento su determinate convenzioni e ipotesi con un meccanismo molto semplice per ignorare le impostazioni predefinite quando necessario. Anche il fatto che sia in Groovy invece che in XML è molto interessante! Come con Ant e Maven, tendo a costruire solo con questi strumenti e ad eseguire file .class compilati direttamente da Java o da uno script che chiama Java. A proposito, tendo ad archiviare anche questi file .classes in un jar per il lancio, ma questo va oltre lo scopo di questo articolo.

Conclusione

Un IDE spesso non è necessario per creare semplici applicazioni ed esempi e può essere anche più costoso di quanto costerebbe creare semplici esempi. In tal caso, è abbastanza semplice utilizzare JAVAC e Java per creare ed eseguire direttamente gli esempi. Come esempio di maggiore coinvolgimento, uno strumento di creazione come Ant, Maven o Gradle diventa più attraente. Il fatto che molti ambienti di sviluppo supportino queste utilità di compilazione significa che uno sviluppatore può migrare all'IDE utilizzando uno strumento integrato creato in precedenza nel processo se viene stabilito che il supporto IDE era necessario quando una semplice applicazione si trasformava in un progetto a tutti gli effetti .