Das Programmieren in einer IDE ist großartig: Kohärenz der Codeabhängigkeiten, bequemes Debuggen, klares Testen, dunkles Thema. Dank der IDE schreitet die Entwicklung also sprunghaft voran. Aber sie entspannt sich. Jeden Tag, wenn der Entwickler in die Funktionalität der IDE eintaucht, gewöhnt er sich daran, mit einem Knopf zu committen oder mit zwei Klicks zu erstellen. Viel schlimmer ist die Situation bei Programmierneulingen, die von Anfang an in der IDE arbeiten und die Arbeit an der Befehlszeile ignorieren. In Intellij IDEA beispielsweise wird die Kompilierung einer Java-Anwendung durch eine Ladeleiste im unteren Bereich demonstriert, und alle Kompilierungsparameter, Klassenpfadverarbeitung und andere Freuden des Java-Lebens bleiben hinter den Kulissen. Wir schlagen vor, über das Kompilieren in Java ohne IDE zu sprechen. Um die Beispiele in diesem Artikel auszuführen, stellen Sie sicher, dass JDK 1.7 oder höher auf Ihrem Computer installiert ist.
Wie kompiliere ich ein Programm?
Unter Kompilierung versteht man in der Programmierung die Reduzierung des Quellcodes in Bytecode für den anschließenden Start des Programms. Der Aktionsablauf vom Quellcode bis zum Programmstart sieht folgendermaßen aus:- Der Quellcode befindet sich in einer Datei namens ClassName.java.
- Wenn der Code keine Fehler enthält, wird er in Bytecode kompiliert (in der Datei ClassName.class);
- Das Programm startet.
class Test {
public static void main(String[] args) {
System.out.println("Это говорит приложение из командной строки");
}
}
Wofür wird der Javac-Befehl verwendet?
Okay, der erste Punkt ist erledigt. Gehen wir weiter, um zu verstehen: Wie kompiliert man? :) Dabei hilft uns der Befehl javac, dessen Argument die benötigte Datei angeben muss:
javac Test.java
Wenn der Code keine Fehler enthält, wird neben der Datei Test.java eine Datei Test.class angezeigt. Dies ist der kompilierte Bytecode. Jetzt muss es gestartet werden. Hier verwenden wir den Java-Befehl, der den Bytecode ausführt: Der Screenshot zeigt, dass wir in der Ausgabe einige Hieroglyphen erhalten: Dies ist offensichtlich eine fehlerhafte Kodierung. Normalerweise geschieht dies auf einem Windows-System. Um das kyrillische Alphabet in der Konsole korrekt anzuzeigen, gibt es folgende Befehle:
REM change CHCP to UTF-8
CHCP 65001
CLS
Sie ändern die aktuelle Shell-Codepage für die Dauer des aktuellen Fensters. Lass es uns erneut versuchen:
D:\Java>java Test
Dies sagt die Anwendung über die Befehlszeile. Zu wissen, wie der Befehl javac funktioniert, ist sehr nützlich, da dieser Befehl die Grundlage jedes Projekterstellungssystems ist.
Kompilieren und Ausführen mehrerer Klassen
Um mit mehreren Klassen arbeiten zu können, benötigen Sie einen Klassenpfad. Es ähnelt einem Dateisystem, in dem Klassen enthalten sind und Pakete als Ordner fungieren. An dieser Stelle lohnt es sich, darüber nachzudenken, die Quellcodedateien von den kompilierten Dateien zu trennen. In der Regel liegen die Quellen im src-Verzeichnis und die kompilierten Klassen im bin. Wir haben zum Beispiel eine KlasseBox
und eine Klasse BoxMachine
, die eine Methode enthält main
. Klasse Box
:
package src;
public class Box {
private double size;
public Box(double size) {
this.size = size;
}
public String toString() {
return "Box have size " + size;
}
}
Es befindet sich im src-Paket und muss behoben werden. Klasse 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));
}
}
}
Diese Klasse ist auch im src-Paket enthalten. In der Methode main
werden fünf Klassenobjekte Box
unterschiedlicher Größe erstellt und Informationen darüber auf der Konsole angezeigt. Um diese Klassengruppe zu kompilieren, müssen Sie den Befehl javac aus dem Hauptverzeichnis (das die Ordner src und bin enthält) mit den folgenden Argumenten verwenden:
javac -d bin ./src/*
-d
– ein Flag, nach dem Sie den Speicherort angeben sollten, an dem die kompilierten Klassen abgelegt werden sollen. Dies ist sehr praktisch, da die Übertragung von beispielsweise 1000 Unterrichtsstunden ein sehr arbeitsintensiver Prozess ist. bin
- Ordnernamen. ./src/*
– Speicherort der Quelldateien. *
gibt an, dass alle Dateien kompiliert werden müssen. Jetzt erscheinen die kompilierten Klassen im bin-Ordner. Um sie auszuführen, verwenden Sie den Java-Befehl aus demselben Verzeichnis, ebenfalls mit Argumenten:
java -classpath ./bin BoxMachine
-classpath
— ein Flag, nach dem Sie den Speicherort der kompilierten Klassen angeben sollten. Java sucht in diesem Verzeichnis nach der Hauptklasse und allen zugehörigen Klassen. ./bin
— der Name des Ordners, in dem sich die kompilierten Klassen befinden. BoxMachine
— Name der Hauptklasse. Wie im ersten Fall sollte nicht angegeben werden .class
, da es sich um den Namen einer Klasse und nicht um eine Datei handelt. Abschluss:
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
JAR-Dateien erstellen
Um die Portierung und Ausführung des Programms zu vereinfachen, können Sie die kompilierten Klassen in einer JAR-Datei – einem Klassenarchiv – sammeln. Der Hauptunterschied zu ZIP- oder RAR-Archiven besteht im Vorhandensein einer Manifestdatei. Dieses Manifest gibt die Hauptklasse an, die ausgeführt wird, wenn die JAR-Datei ausgeführt wird, den Klassenpfad und viele zusätzliche Informationen. Lassen Sie uns eine manifest.mf-Datei im Hauptverzeichnis erstellen. Sein Inhalt wird wie folgt sein:
main-class: src.BoxMachine
class-path: bin/
main-class
Gibt die Klasse an, die die Methode enthält main
und beim Start ausgeführt wird. class-path
– Pfad zu kompilierten Klassen oder zusätzlichen Bibliotheken. Jetzt ist es an der Zeit, mit dem Befehl jar ein echtes Programm ohne IDE zu erstellen:
jar -cmf manifest.mf box-machine.jar -C bin .
-cmf
– ein Flag, nach dem Sie den Pfad zur Manifestdatei angeben sollten. manifest.mf
– Pfad zum Manifest. box-machine.jar
– Name der Ausgabe-JAR-Datei. -С
— ein Flag, nach dem der Pfad zu den kompilierten Klassen angegeben wird. .
– der Pfad, in dem die JAR-Datei abgelegt wird. In unserem Fall ist dies das Hauptverzeichnis. Jetzt können Sie starten. Das Starten von JAR-Dateien erfolgt ebenfalls mit dem Java-Befehl, aber dann müssen Sie das Flag angeben -jar
: Es zeigt an, dass die Jar-Datei gestartet wird, und das zweite Argument ist der Pfad zur jar
Datei, einschließlich der Erweiterung :
java -jar box-machine.jar
Abschluss:
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
Kompilieren in Java ohne IDE: Ein Überblick über Build-Systeme
Obwohl die Befehlszeile relativ einfach zu verwenden ist, ist es sehr schwierig, mittlere und große Projekte damit zu erstellen. Dies nimmt viel Zeit in Anspruch und ist mit Fehlern unterschiedlichen Ausmaßes behaftet. Glücklicherweise gibt es Montagesysteme, die den Arbeitsprozess deutlich erleichtern. Mit mehreren Teams kann dieses System ein Projekt beliebiger Komplexität zusammenstellen, und die Fülle an Plugins, die während der Existenz solcher Systeme erstellt wurden, kann fast jedes Problem beseitigen.Wie kompiliere ich Java?
Die bekanntesten Java-Buildsysteme sind Ant, Maven und Gradle. Es gibt kein Gut oder Böse: Jeder von ihnen ist dazu geschaffen, bestimmte Probleme zu lösen. Schauen wir uns jeden von ihnen genauer an.Ameise
Ant ist ein Build-Tool, das ein Skript verwendet, das mithilfe einer XML-Datei beschrieben wird. XML-Dateistruktur:<?xml version="1.0"?>
<project name="NameПроекта" default="сценарийПоУмолчанию">
<target name="NameСценария">
// Действия сценария
<echo>Hello, World!</echo>
</target>
// Второй сценарий
// И тд
</project>
Erstellen wir im Hauptverzeichnis eine build.xml-Datei mit folgendem Inhalt:
<?xml version="1.0"?>
<project name="BoxMachine" default="test">
<target name="test">
<echo>First build in Ant!</echo>
</target>
</project>
Rufen Sie im selben Verzeichnis den ant-Befehl auf:
D:\Java>D:\Temp\ant\bin\ant
Buildfile: D:\Java\build.xml
test:
[echo] First build in Ant!
BUILD SUCCESSFUL
Total time: 0 seconds
Das Tag <target>
kann verschiedene Aufgaben angeben, mit denen Sie das Assembly- und Dateisystem verwalten können. Ant verfügt über mehr als 150 Befehle, die in der Dokumentation aufgeführt sind. Im folgenden Beispiel verwenden wir nur 5:
mkdir – Verzeichnisse erstellen delete
- Löschen von Dateien und Verzeichnissenjavac
- Kompilierung von Java-Codejava
- Kompilierten Code ausführen
<?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>
Das Skript beschreibt drei Aktionen: compile
, ,code>run und clean
. compile
erstellt ein Ergebnisverzeichnis mit darin enthaltenen Klassen und kompiliert die Klassen dann mithilfe von Javac in das erstellte Verzeichnis. run
führt die kompilierten Klassen mit dem Java-Befehl aus. clean
löscht das Ergebnisverzeichnis. Wenn Sie den ant-Befehl ohne Argumente im Hauptverzeichnis ausführen, wird die Kompilierungsaktion ausgeführt. Wenn eine bestimmte Aktion ausgeführt werden muss, wird diese im Argument angegeben.
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
Maven
Maven bietet einen etwas anderen Ansatz für Bauprojekte. Hier beschreibt der Entwickler vielmehr sein Projekt und die zusätzlichen Tools, die er verwendet, im Gegensatz zu Ant, wo der Build eine Abfolge von Aktionen ist. Maven ist bei Entwicklern aufgrund seines einfachen Abhängigkeitsmanagements und der bequemen Integration in alle Entwicklungsumgebungen beliebt. Bei der Arbeit mit Maven halten wir uns an folgende Projektstruktur: Build-Regeln, Abhängigkeiten usw. werden in der Datei pom.xml beschrieben. Normalerweise befindet es sich im Hauptprojektordner. Beim Start überprüft Maven die Dateistruktur und Syntax und warnt Sie vor Fehlern. Erstellen Sie im Hauptverzeichnis neben den Ordnern bin und src eine pom.xml-Datei und fügen Sie Folgendes hinzu:<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>
Führen Sie als Nächstes den Befehl mvn in der Befehlszeile aus:
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] ------------------------------------------------------------------------
Jetzt gibt es im bin-Ordner einen src-Ordner, der die kompilierten Klassen enthält. In pom.xml definiert das Build-Tag den Zweck der Build-Kompilierung, die Verzeichnisse des Quellcodes und der Kompilierungsergebnisdateien sowie den Projektnamen. Maven verfügt über eine Vielzahl von Build-Zielen und Plugins zum Ausführen von Tests, zum Erstellen von Jar-Dateien, zum Erstellen von Distributionen und für andere Aufgaben.
Gradle
Dies ist das jüngste Build-System, das auf Ant und Maven basiert. Der Hauptunterschied besteht darin, dass es auf der Grundlage eines azyklischen Graphen arbeitet, um die Reihenfolge der Aufgaben zu bestimmen. Dies ist sehr nützlich für komplexere Aufgaben, wie z. B. inkrementelle Builds und Builds mit mehreren Projekten. Beim Erstellen mit Gradle empfiehlt es sich außerdem, sich an die Ordnerstruktur des Maven-Projekts zu halten. Die Datei zum Bauen in Gradle heißt übrigens build.gradle und sieht deutlich kleiner aus als die von Maven. Beispiel für unsere Kurse:apply plugin: 'java'
apply plugin: 'application'
sourceSets {
main {
java {
srcDirs 'src'
}
}
}
sourceSets.main.output.classesDir = file("bin")
mainClassName = "src.BoxMachine"
defaultTasks 'compileJava', 'run'
Die Datei enthält Plugins, definiert das Verzeichnis der Quellcodedateien (wenn die Maven-Projektstruktur nicht verwendet wird), das Verzeichnis der Build-Ergebnisse, den Namen der Hauptklasse und Standardaufgaben. Der Befehl gradle in dem Verzeichnis, in dem sich die Datei build.gradle befindet, ist für den Start des Builds verantwortlich:
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
GO TO FULL VERSION