Kompilacja w Javie

Programowanie w IDE jest świetne: spójność zależności kodu, wygodne debugowanie, przejrzyste testowanie, ciemny motyw. Tak więc, dzięki IDE, rozwój rozwija się skokowo. Ale ona się relaksuje. Każdego dnia, zanurzając się w funkcjonalności IDE, programista przyzwyczaja się do zatwierdzania jednym przyciskiem lub budowania dwoma kliknięciami. Znacznie gorzej sytuacja wygląda w przypadku osób początkujących w programowaniu, które od samego początku pracują w IDE, ignorując pracę z linii poleceń. Na przykład w Intellij IDEA kompilacja aplikacji Java jest prezentowana na pasku ładowania w dolnym panelu, a wszystkie parametry kompilacji, przetwarzanie ścieżki klas i inne przyjemności życia w Javie pozostają za kulisami. Sugerujemy rozmowę o kompilacji w Javie bez IDE. Aby uruchomić przykłady z tego artykułu, upewnij się, że na komputerze jest zainstalowany pakiet JDK 1.7 lub nowszy.

Jak skompilować program?

Kompilacja w programowaniu polega na redukcji kodu źródłowego do kodu bajtowego w celu późniejszego uruchomienia programu. Sekwencja działań od kodu źródłowego do uruchomienia programu wygląda następująco:

1. Kod źródłowy znajduje się w pliku o nazwie ClassName.java;
2. Jeśli w kodzie nie ma błędów, jest on kompilowany do kodu bajtowego (w pliku ClassName.class);
3. Program zostanie uruchomiony.

Zazwyczaj każdy program znajduje się w oddzielnym katalogu. Jako prosty przykład przenieśmy dane wyjściowe do konsoli:

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

Do czego służy polecenie javac?

OK, pierwszy punkt mamy już za sobą. Pójdźmy dalej, aby zrozumieć: jak skompilować? :) Pomoże nam w tym polecenie javac, którego argument musi wskazywać wymagany plik:

javac Test.java

Jeżeli w kodzie nie ma błędów, obok pliku Test.java pojawi się plik Test.class. To jest skompilowany kod bajtowy. Teraz trzeba go uruchomić. Tutaj używamy polecenia Java, które uruchamia kod bajtowy: Zrzut ekranu pokazuje, że na wyjściu otrzymujemy kilka hieroglifów: oczywiście jest to uszkodzone kodowanie. Zwykle dzieje się to w systemie Windows. Aby poprawnie wyświetlić cyrylicę w konsoli, służą następujące polecenia:

REM change CHCP to UTF-8
CHCP 65001
CLS

Zmieniają bieżącą stronę kodową powłoki na czas trwania bieżącego okna. Spróbujmy jeszcze raz:

D:\Java>java Test

Tak mówi aplikacja z wiersza poleceń. Znajomość działania polecenia javac jest bardzo przydatna, ponieważ polecenie to stanowi podstawę każdego systemu tworzenia projektów.

Kompilowanie i uruchamianie wielu klas

Aby pracować z wieloma klasami, potrzebujesz ścieżki klas. Przypomina system plików, w którym zawarte są klasy, a pakiety działają jak foldery. W tym momencie warto pomyśleć o oddzieleniu plików kodu źródłowego od plików skompilowanych. Z reguły źródła znajdują się w katalogu src, a skompilowane klasy w bin. Na przykład mamy klasę Boxi klasę BoxMachinezawierającą metodę main. Klasa Box:

package src;

public class Box {
   private double size;

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

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

Jest w pakiecie src, należy to naprawić. Klasa 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));
       }
   }
}

Klasa ta znajduje się także w pakiecie src. W metodzie maintworzy pięć obiektów klas Boxo różnych rozmiarach i wyświetla informacje o nich w konsoli. Aby skompilować tę grupę klas, należy użyć polecenia javac z katalogu głównego (zawierającego foldery src i bin) z argumentami:

javac -d bin ./src/*

-d— flaga, po której należy wskazać lokalizację, do której trafią skompilowane klasy. Jest to bardzo wygodne, gdyż przeniesienie np. 1000 zajęć jest procesem bardzo pracochłonnym. bin- Nazwa folderu. ./src/*— lokalizacja plików źródłowych. *wskazuje, że wszystkie pliki muszą zostać skompilowane. Teraz skompilowane klasy pojawiają się w folderze bin. Aby je uruchomić, użyj polecenia Java z tego samego katalogu, również z argumentami:

java -classpath ./bin BoxMachine

-classpath— flaga, po której należy wskazać lokalizację skompilowanych klas. Java będzie szukać klasy głównej i wszystkich powiązanych w tym katalogu. ./bin— nazwa folderu, w którym znajdują się skompilowane klasy. BoxMachine— nazwa klasy głównej. Podobnie jak w pierwszym przypadku nie należy podawać .class, gdyż jest to nazwa klasy, a nie pliku. Wniosek:

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

Tworzenie plików JAR

Aby ułatwić przenoszenie i uruchamianie programu, możesz zebrać skompilowane klasy w pliku jar - archiwum klas. Główną różnicą w stosunku do archiwów ZIP lub RAR jest obecność pliku manifestu. Ten manifest określa główną klasę, która zostanie uruchomiona podczas wykonywania pliku jar, ścieżkę klasy i wiele dodatkowych informacji. Utwórzmy plik manifest.mf w katalogu głównym. Jego zawartość będzie następująca:

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

main-classokreśla klasę zawierającą metodę main, która będzie wykonywana podczas uruchamiania. class-path— ścieżka do skompilowanych klas lub dodatkowych bibliotek. Teraz czas zbudować prawdziwy program bez IDE za pomocą polecenia jar:

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

-cmf— flaga, po której należy podać ścieżkę do pliku manifestu. manifest.mf— ścieżka do manifestu. box-machine.jar— nazwa wyjściowego pliku jar. -С— flaga, po której wskazywana jest ścieżka do skompilowanych klas. .— ścieżka, w której zostanie umieszczony plik jar. W naszym przypadku jest to katalog główny. Teraz możesz uruchomić. Uruchamianie plików jar odbywa się również za pomocą polecenia Java, ale wtedy należy podać flagę -jar: wskazuje ona, że ​​plik Jar jest uruchamiany, a drugim argumentem jest ścieżka do jarpliku wraz z rozszerzeniem :

java -jar box-machine.jar

Wniosek:

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

Kompilacja w Javie bez IDE: przegląd systemów kompilacji

Pomimo względnej łatwości użycia wiersza poleceń, bardzo trudno jest za jego pomocą budować średnie i duże projekty. Zajmuje to dużo czasu i jest obarczone błędami różnego stopnia. Na szczęście istnieją systemy montażu, które znacznie ułatwiają proces pracy. Dzięki kilku zespołom system ten może złożyć projekt o dowolnej złożoności, a obfitość wtyczek stworzonych podczas istnienia takich systemów może wyeliminować niemal każdy ból głowy.

Jak skompilować Javę?

Najbardziej znane systemy kompilacji Java to Ant, Maven i Gradle. Nie ma dobra i zła: każdy z nich jest stworzony, aby rozwiązać określone problemy. Przyjrzyjmy się każdemu z nich bardziej szczegółowo.

Mrówka

Ant to narzędzie do budowania, które wykorzystuje skrypt opisany za pomocą pliku xml. struktura pliku xml:

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

Stwórzmy w głównym katalogu plik build.xml o następującej zawartości:

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

W tym samym katalogu wywołaj polecenie 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

Znacznik <target>może określać różne zadania, które pozwalają zarządzać zespołem i systemem plików. Ant udostępnia ponad 150 poleceń, które są wymienione w dokumentacji. W poniższym przykładzie używamy tylko 5:

• mkdir – tworzenie katalogów
• delete- usuwanie plików i katalogów
• javac- Kompilacja kodu Java
• java- uruchamianie skompilowanego kodu

Tak wygląda prosty skrypt kompilacji, kompilacji lub czyszczenia:

<?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>

Skrypt opisuje trzy akcje - compile, ,code>run i clean. compiletworzy katalog wyników zawierający klasy, a następnie używa javac do skompilowania klas do utworzonego katalogu. runuruchamia skompilowane klasy za pomocą polecenia Java. cleanusuwa katalog wyników. Jeśli uruchomisz polecenie ant bez argumentów w katalogu głównym, zostanie uruchomiona akcja kompilacji. Jeśli należy wykonać konkretną akcję, jest ona określona w argumencie.

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

Mavena

Maven oferuje nieco inne podejście do projektów budowlanych. Tutaj deweloper raczej opisuje swój projekt i dodatkowe narzędzia, z których korzysta, w przeciwieństwie do Anta, gdzie kompilacja jest sekwencją działań. Maven jest popularny wśród programistów ze względu na łatwe zarządzanie zależnościami i wygodną integrację ze wszystkimi środowiskami programistycznymi. Pracując z Mavenem kierujemy się następującą strukturą projektu: Reguły budowania, zależności itp. opisane są w pliku pom.xml. Zazwyczaj znajduje się on w głównym folderze projektu. Podczas uruchamiania Maven sprawdza strukturę i składnię pliku, ostrzegając o błędach. W głównym katalogu obok folderów bin i src utwórz plik pom.xml, dodaj w nim:

<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>

Następnie uruchom komendę mvn w wierszu poleceń:

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] ------------------------------------------------------------------------

Teraz w folderze bin znajduje się folder src, w którym znajdują się skompilowane klasy. W pom.xml znacznik build określa cel kompilacji - kompilację, katalogi z kodem źródłowym i plikami wynikowymi kompilacji, a także nazwę projektu. Maven ma wiele celów kompilacji i wtyczek do uruchamiania testów, tworzenia plików Jar, tworzenia dystrybucji i innych zadań.

Gradle

To najmłodszy system kompilacji, który opiera się na Ant i Maven. Główną różnicą jest to, że działa w oparciu o wykres acykliczny w celu ustalenia kolejności zadań. Jest to bardzo przydatne w przypadku bardziej złożonych zadań, takich jak kompilacje przyrostowe i kompilacje obejmujące wiele projektów. Podczas budowania za pomocą Gradle zaleca się również trzymanie się struktury folderów projektu Maven. Nawiasem mówiąc, plik do budowania w Gradle nazywa się build.gradle i wygląda na znacznie mniejszy niż plik w Mavenie. Przykład dla naszych zajęć:

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

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

mainClassName = "src.BoxMachine"

defaultTasks 'compileJava', 'run'

Plik zawiera wtyczki, określa katalog plików kodu źródłowego (jeśli nie jest używana struktura projektu Maven), katalog wyników kompilacji, nazwę klasy głównej i domyślne zadania. Za uruchomienie kompilacji odpowiedzialna jest komenda gradle w katalogu, w którym znajduje się plik build.gradle:

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

Wniosek

Na pierwszy rzut oka możliwość kompilacji i asemblowania kodu bez IDE wydaje się bezużyteczna. Rzeczywiście, po co zawracać sobie głowę wierszami poleceń i Google wszystkimi poleceniami, skoro jest wygodne IDE z wtyczkami, automatyczne sprawdzanie wszystkiego, co możliwe (nowoczesne IDE nie sprawdzają poziomu IQ) i integracja z popularnymi systemami. Praktyka pokazuje jednak, że umiejętność złożenia kodu bez środowiska programistycznego i zrozumienia każdego etapu tego procesu jest pilną koniecznością. Ta umiejętność pozwoli zaoszczędzić mnóstwo komórek nerwowych i czasu Tobie i Twojej firmie. Możesz nauczyć się korzystać z IDE, poćwiczyć pisanie kodu i oczywiście poznać podstawy programowania w Javie tutaj - w JavaRush. Czas wrócić do nauki :)