Compilazione in Java

La programmazione in un IDE è fantastica: coerenza delle dipendenze del codice, debug conveniente, test chiari, tema scuro. Quindi, grazie all'IDE, lo sviluppo si sta sviluppando a passi da gigante. Ma lei si rilassa. Ogni giorno, immergendosi nelle funzionalità dell'IDE, lo sviluppatore si abitua a impegnarsi con un pulsante o a costruire con due clic. La situazione è molto peggiore per chi è nuovo alla programmazione e lavora nell'IDE fin dall'inizio, ignorando il lavoro sulla riga di comando. Ad esempio, in Intellij IDEA, la compilazione di un'applicazione Java è dimostrata da una barra di caricamento nel pannello inferiore e tutti i parametri di compilazione, l'elaborazione del percorso di classe e altre delizie della vita Java rimangono dietro le quinte. Suggeriamo di parlare di compilazione in Java senza IDE. Per eseguire gli esempi in questo articolo, assicurati che sul tuo computer sia installato JDK 1.7 o versione successiva.

Come compilare un programma?

La compilazione nella programmazione è la riduzione del codice sorgente in bytecode per il successivo avvio del programma. La sequenza di azioni dal codice sorgente all'avvio del programma è simile alla seguente:

1. C'è il codice sorgente in un file chiamato ClassName.java;
2. Se non sono presenti errori nel codice, viene compilato in bytecode (nel file ClassName.class);
3. Il programma viene avviato.

In genere, ciascun programma è contenuto in una directory separata. Come semplice esempio, portiamo l'output sulla console:

class Test {
   public static void main(String[] args) {
      System.out.println("Это говорит приложение из командной строки");
   }
}

A cosa serve il comando javac?

Ok, il primo punto è fatto. Andiamo oltre per capire: come compilare? :) In questo ci aiuterà il comando javac, il cui argomento deve specificare il file richiesto:

javac Test.java

Se non sono presenti errori nel codice, accanto al file Test.java verrà visualizzato un file Test.class. Questo è il bytecode compilato. Ora bisogna lanciarlo. Qui usiamo il comando Java, che esegue il bytecode: Lo screenshot mostra che otteniamo alcuni geroglifici nell'output: ovviamente si tratta di una codifica errata. In genere ciò accade su un sistema Windows. Per visualizzare correttamente l'alfabeto cirillico nella console sono disponibili i seguenti comandi:

REM change CHCP to UTF-8
CHCP 65001
CLS

Cambiano la codepage corrente della shell per la durata della finestra corrente. Proviamo di nuovo:

D:\Java>java Test

Questo è ciò che dice l'applicazione dalla riga di comando. Sapere come funziona il comando javac è molto utile, poiché questo comando è la base di qualsiasi sistema di compilazione del progetto.

Compilazione ed esecuzione di più classi

Per lavorare con più classi è necessario un classpath. È simile a un file system in cui sono contenute le classi e i pacchetti fungono da cartelle. A questo punto vale la pena pensare a separare i file del codice sorgente dai file compilati. Di norma, i sorgenti si trovano nella directory src e le classi compilate sono in bin. Ad esempio, abbiamo una classe Boxe una classe BoxMachineche contiene un metodo main. Classe Box:

package src;

public class Box {
   private double size;

   public Box(double size) {
       this.size = size;
   }

   public String toString() {
       return "Box have size " + size;
   }
}

È nel pacchetto src, questo deve essere risolto. Classe BoxMachine:

package src;

public class BoxMachine {
   public static void main(String[] args) {
       for(int  i = 0; i < 5; i++) {
           System.out.println(new Box(Math.random()*10));
       }
   }
}

Questa classe si trova anche nel pacchetto src. Nel metodo main, crea cinque oggetti classe Boxdi dimensioni diverse e visualizza le informazioni su di essi nella console. Per compilare questo gruppo di classi, è necessario utilizzare il comando javac dalla directory principale (che contiene le cartelle src e bin) con gli argomenti:

javac -d bin ./src/*

-d- un flag dopo il quale dovresti indicare la posizione in cui andranno le classi compilate. Questo è molto conveniente, poiché trasferire, ad esempio, 1000 classi è un processo ad alta intensità di manodopera. bin- nome della cartella. ./src/*— posizione dei file sorgente. *indica che tutti i file devono essere compilati. Ora le classi compilate appaiono nella cartella bin. Per eseguirli, utilizzare il comando Java dalla stessa directory, anch'esso con argomenti:

java -classpath ./bin BoxMachine

-classpath— un flag dopo il quale dovresti indicare la posizione delle classi compilate. Java cercherà la classe principale e tutte quelle correlate in questa directory. ./bin— il nome della cartella in cui si trovano le classi compilate. BoxMachine— nome della classe principale. Come nel primo caso, non va specificato .class, poiché si tratta del nome di una classe, non di un file. Conclusione:

D:\Java>java -classpath ./bin src.BoxMachine
Box have size 4.085985295359718
Box have size 8.63682158248986
Box have size 6.027448124299726
Box have size 7.288317703877914
Box have size 1.106181659384694

Creazione di file JAR

Per rendere il programma facile da trasferire ed eseguire, puoi raccogliere le classi compilate in un file jar, un archivio di classi. La differenza principale rispetto agli archivi zip o rar è la presenza di un file manifest. Questo manifest specifica la classe principale che verrà eseguita quando viene eseguito il file jar, il classpath e molte informazioni aggiuntive. Creiamo un file manifest.mf nella directory principale. Il suo contenuto sarà il seguente:

main-class: src.BoxMachine
class-path: bin/

main-classspecifica la classe che contiene il metodo maine verrà eseguita all'avvio. class-path— percorso di classi compilate o librerie aggiuntive. Adesso è il momento di costruire un vero programma senza IDE usando il comando jar:

jar -cmf manifest.mf box-machine.jar  -C bin .

-cmf— un flag dopo il quale dovresti specificare il percorso del file manifest. manifest.mf- percorso verso il manifesto. box-machine.jar— nome del file jar di output. -С— un flag dopo il quale viene indicato il percorso delle classi compilate. .- il percorso in cui verrà posizionato il file jar. Nel nostro caso, questa è la directory principale. Ora puoi lanciare. Anche l'avvio dei file jar viene eseguito utilizzando il comando java, ma poi è necessario specificare il flag -jar: indica che il file Jar viene avviato e il secondo argomento è il percorso del jarfile, inclusa l'estensione :

java -jar box-machine.jar

Conclusione:

Box have size 5.5495235762547965
Box have size 9.695870044165662
Box have size 2.3408385788129227
Box have size 7.2790741216674135
Box have size 2.3620854470160513

Compilazione in Java senza IDE: una panoramica dei sistemi di compilazione

Nonostante la relativa facilità d'uso della riga di comando, è molto difficile realizzare progetti di medie e grandi dimensioni utilizzandola. Ciò richiede molto tempo ed è irto di errori di vario grado. Fortunatamente esistono sistemi di assemblaggio che rendono il processo di lavoro molto più semplice. Con diversi team, questo sistema può assemblare un progetto di qualsiasi complessità e l'abbondanza di plugin creati durante l'esistenza di tali sistemi può eliminare quasi ogni mal di testa.

Come compilare Java?

I sistemi di build Java più famosi sono Ant, Maven e Gradle. Non esiste il buono o il cattivo: ognuno di essi è creato per risolvere determinati problemi. Diamo un'occhiata a ciascuno di essi in modo più dettagliato.

Formica

Ant è uno strumento di compilazione che utilizza uno script descritto utilizzando un file xml. struttura del file xml:

<?xml version="1.0"?>
<project name="NameПроекта" default="сценарийПоУмолчанию">
    <target name="NameСценария">
  //  Действия сценария
        <echo>Hello, World!</echo>
    </target>
  //  Второй сценарий
  //  И тд
</project>

Creiamo un file build.xml nella directory principale con il seguente contenuto:

<?xml version="1.0"?>
<project name="BoxMachine" default="test">
   <target name="test">
       <echo>First build in Ant!</echo>
   </target>
</project>

Nella stessa directory, chiama il comando ant:

D:\Java>D:\Temp\ant\bin\ant
Buildfile: D:\Java\build.xml

test:
     [echo] First build in Ant!

BUILD SUCCESSFUL
Total time: 0 seconds

Il tag <target>può specificare varie attività che consentono di gestire l'assembly e il file system. Ant ha oltre 150 comandi disponibili, elencati nella documentazione. Nell'esempio seguente ne utilizziamo solo 5:

• mkdir - creazione di directory
• delete- Cancellazione di file e directory
• javac- Compilazione del codice Java
• java- esecuzione del codice compilato

Ecco come appare un semplice script di compilazione, creazione o pulizia:

<?xml version="1.0"?>
<project name="BoxMachine" default="compile">
   <target name="compile">
       <mkdir dir="result/classes"/>
       <javac destdir="result/classes" includeantruntime="false">
           <src path="src"/>
       </javac>
   </target>
   <target name="run" depends="compile">
       <java classname="BoxMachine" classpath="result/classes"/>
   </target>
   <target name="clean">
       <delete dir="result"/>
   </target>
</project>

Lo script descrive tre azioni: compile, ,code>run e clean. compilecrea una directory dei risultati con le classi al suo interno, quindi utilizza javac per compilare le classi nella directory creata. runesegue le classi compilate con il comando java. cleanelimina la directory dei risultati. Se esegui il comando ant senza argomenti nella directory principale, verrà eseguita l'azione di compilazione. Se è necessario eseguire un'azione specifica, viene specificata nell'argomento.

D:\Java>D:/Temp/ant/bin/ant compile
Buildfile: D:\Java\build.xml

compile:
    [mkdir] Created dir: D:\Java\result\classes
    [javac] Compiling 2 source files to D:\Java\result\classes

BUILD SUCCESSFUL
Total time: 1 second

Esperto di

Maven offre un approccio leggermente diverso ai progetti di costruzione. Qui lo sviluppatore descrive piuttosto il suo progetto e gli strumenti aggiuntivi che utilizza, a differenza di Ant, dove la compilazione è una sequenza di azioni. Maven è popolare tra gli sviluppatori grazie alla sua semplice gestione delle dipendenze e alla comoda integrazione con tutti gli ambienti di sviluppo. Quando lavoriamo con Maven, aderiamo alla seguente struttura del progetto: regole di creazione, dipendenze, ecc. sono descritte nel file pom.xml. In genere si trova nella cartella principale del progetto. All'avvio, Maven controlla la struttura e la sintassi del file, avvisandoti degli errori. Nella directory principale, accanto alle cartelle bin e src, crea un file pom.xml, aggiungi al suo interno:

<project>
  <modelVersion>4.0.0</modelVersion>
  <groupId>ru.javarush.testmaven</groupId>
  <artifactId>testMavenWithoutIde</artifactId>
  <version>1.0.0</version>

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

Successivamente, esegui il comando mvn sulla riga di comando:

D:\Java>mvn
[INFO] Scanning for projects...
[INFO]
[INFO] -------------< ru.javarush.testmaven:testMavenWithoutIde >--------------
[INFO] Building testMavenWithoutIde 1.0.0
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ testMavenWithoutIde ---
[WARNING] Using platform encoding (Cp1251 actually) to copy filtered resources, i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory D:\Java\src\main\resources
[INFO]
[INFO] --- maven-compiler-plugin:3.1:compile (default-compile) @ testMavenWithoutIde ---
[INFO] Changes detected - recompiling the module!
[WARNING] File encoding has not been set, using platform encoding Cp1251, i.e. build is platform dependent!
[INFO] Compiling 2 source files to D:\Java\bin
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 15.521 s
[INFO] Finished at: 2019-06-25T20:18:05+03:00
[INFO] ------------------------------------------------------------------------

Ora c'è una cartella src nella cartella bin che contiene le classi compilate. In pom.xml, il tag build definisce lo scopo della build: compilazione, le directory del codice sorgente e dei file dei risultati della compilazione, nonché il nome del progetto. Maven offre una varietà di target di build e plug-in per l'esecuzione di test, la creazione di file Jar, la creazione di distribuzioni e altre attività.

Gradle

Questo è il sistema di build più giovane, basato su Ant e Maven. La differenza principale è che funziona sulla base di un grafico aciclico per determinare l'ordine dei compiti. Ciò è molto utile per attività più complesse, come build incrementali e multiprogetto. Quando si crea con Gradle, si consiglia inoltre di attenersi alla struttura delle cartelle del progetto Maven. A proposito, il file per la creazione in Gradle si chiama build.gradle e sembra molto più piccolo di quello di Maven. Esempio per le nostre lezioni:

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

sourceSets {
   main {
       java {
           srcDirs 'src'
       }
   }
}
sourceSets.main.output.classesDir = file("bin")

mainClassName = "src.BoxMachine"

defaultTasks 'compileJava', 'run'

Il file include plugin, definisce la directory dei file del codice sorgente (se non viene utilizzata la struttura del progetto Maven), la directory dei risultati della compilazione, il nome della classe principale e le attività predefinite. Il comando gradle nella directory in cui si trova il file build.gradle è responsabile dell'avvio della build:

d:\Java>D:\Temp\gradle\bin\gradle

Welcome to Gradle 5.4.1!

Here are the highlights of this release:
 - Run builds with JDK12
 - New API for Incremental Tasks
 - Updates to native projects, including Swift 5 support

For more details see https://docs.gradle.org/5.4.1/release-notes.html

Starting a Gradle Daemon (subsequent builds will be faster)

> Task :help

Welcome to Gradle 5.4.1.

To run a build, run gradle <task> ...

To see a list of available tasks, run gradle tasks

To see a list of command-line options, run gradle --help

To see more detail about a task, run gradle help --task <task>

For troubleshooting, visit https://help.gradle.org

BUILD SUCCESSFUL in 52s
1 actionable task: 1 executed

Conclusione

A prima vista, la capacità di compilare e assemblare codice senza un IDE sembra inutile. In effetti, perché preoccuparsi delle righe di comando e di Google tutti i comandi quando esiste un accogliente IDE con plug-in, controllo automatico di tutto il possibile (gli IDE moderni non controllano il livello di QI) e integrazione con i sistemi più diffusi. Tuttavia, la pratica dimostra che la capacità di assemblare codice senza un ambiente di sviluppo e di comprendere ogni fase di questo processo è una necessità urgente. Questa abilità farà risparmiare molte cellule nervose e tempo per te e la tua azienda. Puoi imparare come utilizzare l'IDE, esercitarti a scrivere codice e, ovviamente, acquisire i fondamenti della programmazione Java qui, su JavaRush. È ora di tornare a studiare :)