Kompilieren in Java

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:

1. Der Quellcode befindet sich in einer Datei namens ClassName.java.
2. Wenn der Code keine Fehler enthält, wird er in Bytecode kompiliert (in der Datei ClassName.class);
3. Das Programm startet.

Normalerweise ist jedes Programm in einem separaten Verzeichnis enthalten. Nehmen wir als einfaches Beispiel die Ausgabe an die Konsole:

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 Klasse Boxund 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 mainwerden fünf Klassenobjekte Boxunterschiedlicher 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-classGibt die Klasse an, die die Methode enthält mainund 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 jarDatei, 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 Verzeichnissen
• javac- Kompilierung von Java-Code
• java- Kompilierten Code ausführen

So sieht ein einfaches Kompilierungs-, Build- oder Bereinigungsskript aus:

<?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. compileerstellt ein Ergebnisverzeichnis mit darin enthaltenen Klassen und kompiliert die Klassen dann mithilfe von Javac in das erstellte Verzeichnis. runführt die kompilierten Klassen mit dem Java-Befehl aus. cleanlö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

Abschluss

Auf den ersten Blick erscheint die Möglichkeit, Code ohne IDE zu kompilieren und zusammenzustellen, nutzlos. Warum sollte man sich eigentlich mit Befehlszeilen und Google alle Befehle herumschlagen, wenn es doch eine gemütliche IDE mit Plugins, automatischer Überprüfung aller möglichen Dinge (moderne IDEs prüfen den IQ-Level nicht) und Integration mit gängigen Systemen gibt? Die Praxis zeigt jedoch, dass die Fähigkeit, Code ohne Entwicklungsumgebung zusammenzustellen und jeden Schritt dieses Prozesses zu verstehen, eine dringende Notwendigkeit ist. Diese Fähigkeit spart Ihnen und Ihrem Unternehmen jede Menge Nervenzellen und Zeit. Hier können Sie lernen, wie man die IDE verwendet, das Schreiben von Code üben und natürlich die Grundlagen der Java-Programmierung erlernen – bei JavaRush. Zeit, wieder mit dem Lernen anzufangen :)