Java ohne IDE kompilieren und ausführen

Einmal wurde auf reddit.com im Thema „Kompilieren und Ausführen von Java ohne IDE“ die Frage gestellt: Gibt es einen Befehl, der eine Gruppe von Java-Dateien, die sich in einem Paket befinden, in einem separaten Ordner kompiliert (nennen wir ihn „ bin“ )? , und wie würde ich vorgehen, um neue Klassendateien zu erstellen? „ Der Autor des Themas, kylolink , erklärt: „Als ich anfing, Java zu verwenden, verließ ich mich darauf, dass Eclipse die gesamte Kompilierung für mich erledigte, und machte mir nur Sorgen, den Code zu schreiben.“ Diese Frage habe ich schon oft gesehen, und tatsächlich auch diese ist es, was mich zu meinem Blogbeitrag „GPS-Systeme und IDEs: gut oder schlecht“ bewogen hat? Ich liebe leistungsstarke moderne Java-IDEs und sie erleichtern mir das tägliche Leben, aber es hat auch Vorteile, zu wissen, wie man einfache Java-Beispiele ohne sie erstellt und ausführt In diesem Beitrag geht es darum, wie man genau das macht. In meinem Blog zum Erlernen von Java mit einfachen Tests habe ich darüber geschrieben, dass ich manchmal gerne einen einfachen Texteditor und Befehlszeilentools verwende, um einfache Anwendungen zu schreiben, zu erstellen und auszuführen. Das habe ich Sie erhalten jetzt eine ziemlich gute Vorstellung davon, wie viel „Overhead“ meine Lieblings-Java-IDEs erfordern, und können frühzeitig entscheiden, ob die durch die Verwendung des Frameworks erzielten Vorteile ausreichen, um den „Overhead“ zu rechtfertigen. In den meisten realen Anwendungen besteht kein Zweifel daran, dass die VL-IDE viel wert ist. Bei den einfachsten Beispielanwendungen ist dies jedoch nicht immer der Fall. Der Rest dieses Beitrags zeigt, wie man in diesen Situationen Java-Code ohne IDE erstellt und ausführt.

Java-Code schreiben und ausführen

Um das Beispiel klarer zu machen, verwende ich einige sehr einfache Java-Klassen, die durch Zusammensetzung oder Vererbung miteinander verbunden sind und sich im selben Paket namens „ dustin.examples“ befinden . Bei zwei Klassen fehlt eine Funktion main; die dritte Klasse, Main.java, verfügt über eine Funktion main, mit der Sie demonstrieren können, wie die Klasse ohne IDE ausgeführt wird. Unten finden Sie den Code für diese drei Klassen: 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);
   }
}

Der folgende Screenshot zeigt die Verzeichnisstruktur mit diesen .java- Klassen . Der Screenshot zeigt, dass sich die Quelldateien in der Verzeichnishierarchie befinden, die den Paketnamen darstellt ( dustin/examples , da die Paketinformationen „ dustin.examples“ sind ) und dass dieses Paket die Verzeichnishierarchie widerspiegelt befindet sich im Unterverzeichnis SRC. Ich habe außerdem ein Unterverzeichnis „classes“ erstellt (das derzeit leer ist), um die kompilierten .class- Dateien aufzunehmen, damit Javac dieses Verzeichnis nicht erstellt, wenn es nicht existiert.

Erstellen mit JAVAC und Ausführen mit Java

Ganz gleich, mit welchem ​​Ansatz man Java-Code erstellt (Ant, Maven, Gradle oder IDE), am Ende kommt es auf JAVAC an. Die Standardoptionen im von Oracle/Sun bereitgestellten JAVAC-Befehlszeilentool können durch Ausführen von JAVAC -help angezeigt werden, und zusätzliche Erweiterungsoptionen können durch Ausführen von JAVAC -help -X angezeigt werden. Weitere Einzelheiten zur Verwendung dieser Optionen finden Sie in der JAVAC-Tool-Dokumentation für Windows oder Unix/Linux. Wie in der Javac-Dokumentation angegeben, kann die Option -sourcepath verwendet werden, um das Verzeichnis auszudrücken, in dem Quelldateien vorhanden sind. In meiner im Screenshot oben gezeigten Verzeichnisstruktur bedeutet dies, dass ich, vorausgesetzt, ich führe den JAVAC-Befehl aus dem Verzeichnis C:\Java\examples\javacAndJava\ aus , in meinem Befehl etwa Folgendes haben müsste: Javac -sourcepath src SRC\Dustin\examples\*. Java . Der folgende Screenshot zeigt die Ergebnisse davon. Da wir kein Verzeichnis für die .class- Dateien angegeben haben , wurden sie standardmäßig im selben Verzeichnis abgelegt wie die .java- Quelldateien , aus denen sie erstellt wurden. Wir können die Option nutzen, -dum diese Situation zu beheben. Unser Befehl kann jetzt beispielsweise als Javac -sourcepath src -dclasses src\Dustin\examples\* ausgeführt werden. Ich du . Wie bereits erwähnt, muss der ausgewählte Ordner (die Klassen) bereits vorhanden sein. Wenn dies geschieht, platziert der Befehl die .class- Dateien im angegebenen Ordner, wie im folgenden Screenshot gezeigt. Nachdem die Java-Quelldateien in entsprechende .class- Dateien im angegebenen Verzeichnis kompiliert wurden, können wir die Anwendung über das Schnellstartmenü des starten Java-Befehlszeilentool. Dies geschieht einfach, indem Sie den Anweisungen auf den Java-Hilfe- oder Java-Tools-Seiten folgen und den Speicherort der .class- Dateien mit der Option -classpath( oder -cp) angeben. Die Verwendung beider Ansätze zur Angabe des Klassenverzeichnisses, in dem nach .class- Dateien gesucht werden soll , wird im folgenden Screenshot veranschaulicht. Das letzte Argument ist der vollständige Name (des gesamten Java-Pakets) der Klasse, die die auszuführende Hauptfunktion hat. Die im folgenden Screenshot gezeigten Befehle sind Java-Klassen -cp dustin.examples.Main und Java-Klassen -classpath dustin.examples.Main.

Bauen und Laufen mit Ant

Für die einfachsten Java-Anwendungen ist es recht einfach, JAVAC und Java zum Erstellen bzw. Ausführen der Anwendung zu verwenden, wie gerade gezeigt. Wenn Anwendungen etwas komplexer werden (z. B. Code, der in mehr als einem Paket/Verzeichnis vorhanden ist oder komplexere Abhängigkeitsklassen von Bibliotheken und Frameworks Dritter), kann dieser Ansatz unhandlich werden. Apache Ant ist das älteste der „großen drei“ Java-Build-Tools und wurde in Tausenden von Anwendungen und Bereitstellungen verwendet. Wie ich in einem früheren Blog-Beitrag gesagt habe, ist es einfach, eine sehr einfache Ant-Build-Datei zu erstellen, insbesondere wenn sie mit einer Vorlage beginnt, wie ich sie in diesem Beitrag beschrieben habe. Die folgende Codeliste gilt für die build.xml- Datei von Ant , die verwendet werden kann, um .java- Dateien in .class-Dateien zu komponieren und dann die Klasse „ dustin.examples.Main“ auszuführen , wie oben mit JAVAC und Java gemacht. 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>

Ich habe die Ant-Eigenschaften nicht verwendet und die gemeinsamen Ziele, die ich normalerweise einbeziehe (z. B. „pure“ und „Javadoc“), nicht einbezogen, um dieses Beispiel so einfach wie möglich zu halten und es nahe am vorherigen Beispiel mit JAVAC und Java zu halten . Beachten Sie auch, dass ich „debug“ für die JAVAC-Ant-Aufgabe auf „true“ gesetzt habe, da dies im Falle eines Ant-Fehlers nicht zutrifft, bei der Standardeinstellung von JAVAC jedoch zutrifft. Es überrascht nicht, dass Javac-Task und Java-Ant-Task JAVAC-Befehlstools und Java ähneln. Da ich den Standardnamen verwendet habe, erwartet Ant eine Build-Datei, wenn diese nicht explizit angegeben ist (build.xml), und weil ich das „Run“-Ziel als „Standard“ für diesen Build angegeben habe und weil ich „compile“ als Abhängigkeitslauf eingebunden habe das „Run“-Ziel und da sich Ant auf dem Pfad meiner Umgebung befand, musste ich in der Befehlszeile nur Ant dazu bringen, das Ant-Beispiel im Verzeichnis mit der Datei build.xml zu kompilieren und auszuführen . Dies wird im folgenden Screenshot dargestellt. Obwohl ich das Kompilieren und Ausführen einer einfachen Java-Anwendung mit Ant demonstriert habe, neige ich dazu, nur mit Ant zu kompilieren und mit Java auszuführen (oder einem Skript, das Java aufruft, wenn der Klassenpfad umfangreich ist).

Bauen und Ausführen mit Maven

Obwohl Ant das erste zentrale Java-Build-Tool war, erlangte Apache Maven schließlich seinen Ruhm vor allem aufgrund der Einführung einer konventionsbasierten Konfiguration und der Unterstützung gemeinsam genutzter Bibliotheks-Repositorys. Maven ist einfach zu verwenden, wenn der Code und die generierten Objekte seinem Standardverzeichnislayout folgen. Leider folgt mein Beispiel nicht dieser Verzeichnisstruktur, aber Maven ermöglicht es uns, die erwartete Standardverzeichnisstruktur zu überschreiben. Die folgende Liste enthält Code für eine Maven-POM-Datei, die anstelle der Quell- und Zielverzeichnisse verwendet wird und die anderen mindestens erforderlichen Elemente für einen Maven-Build mit Maven 3.2.1 bereitstellt. 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>

Da die obige pom.xml- Datei das „defaultGoal“ von „compile“ definiert und weil die pom.xml- Dateien die Standard-POM-Benutzerdefiniert sind, nach denen die ausführbare Maven-Datei (MVN) sucht, und weil sich das Maven-Installationsverzeichnis nur auf meinem Pfad befindet Ich muss „MVN“ ausführen, um .class-Dateien zu kompilieren, wie im folgenden Screenshot erwähnt. Ich kann die kompilierte Anwendung auch von Maven aus mit dem Mvn Exec-Befehl ausführen: Java -Dexec.mainClass = dustin.examples.Main , was im folgenden Screenshot zu sehen ist. Wie bei Ant neige ich dazu, Maven nicht zum Ausführen meiner einfachen Java-Anwendung zu verwenden, sondern stattdessen Java für kompilierten Code zu verwenden (oder ein Skript zu verwenden, das Java direkt für lange Klassen aufruft).

Bauen und Ausführen mit Gradle

Gradle ist das neueste, trendigste und eleganteste der drei wichtigsten Java-Build-Tools. Ich bin manchmal skeptisch gegenüber dem Wesen dessen, was im Trend liegt, aber ich habe viele Dinge gefunden, die mir an Gradle gefallen (geschrieben in Groovy statt XML, integrierte Ant-Unterstützung, integrierte Ivy-Unterstützung, Konfiguration nach Konvention, die einfach ist). neu zu konfigurieren, Maven-Repository-Unterstützung usw.). Das folgende Beispiel zeigt einen Gradle-Build, der zum Kompilieren und Ausführen einer einfachen Anwendung verwendet werden kann, die den Hauptbeispielcode für diesen Beitrag darstellt. Ich habe dieses angepasste Beispiel im Simple Gradle Java Plugin Customization-Blog vorgestellt. 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'

Die ersten beiden Zeilen aus der Datei build.gradle geben die Verwendung des Java-Plugins und des Anwendungs-Plugins an, was dazu führt, dass eine Reihe von Funktionen automatisch in diesen Build integriert werden. Durch die Definition von „sourceSets“ und „sourceSets.main.output.classesDir“ können Sie die Standard-Java-Verzeichnisse des Gradle-Plugins für Java-Quellcode bzw. kompilierte Binärklassen überschreiben. „MainClassName“ ermöglicht Ihnen die explizite Angabe, welche Klasse innerhalb der ausgeführt werden soll Anwendungs-Plugin. Die Zeile „defaultTasks“ definiert die Aufgaben, die ausgeführt werden, indem Sie einfach „Gradle“ in die Befehlszeile eingeben: „compileJava“ ist die vom Java-Plugin bereitgestellte Standardaufgabe und „Run“ ist die vom Anwendungs-Plugin bereitgestellte Standardaufgabe. Da ich die Assemblys build.gradle benannt habe und die Standardaufgaben deshalb als „compileJava“ und „Run“ angegeben habe und weil ich das Gradle-Installationsverzeichnis bin in meinem Pfad habe, musste ich zum Erstellen und Ausführen der Beispiele nur tippen 'Gradle' und dies wird im folgenden Screenshot demonstriert. Selbst der größte Skeptiker muss zugeben, dass Gradle-Builds für dieses einfache Beispiel sehr rutschig sind. Es kombiniert die Prägnanz, sich auf bestimmte Konventionen und Annahmen zu verlassen, mit einem sehr einfachen Mechanismus zum Überschreiben von Standardwerten bei Bedarf. Auch die Tatsache, dass es in Groovy statt in XML vorliegt, ist sehr attraktiv! Wie bei Ant und Maven tendiere ich dazu, nur mit diesen Tools zu bauen und kompilierte .class-Dateien direkt aus Java oder einem Skript auszuführen, das Java aufruft. Übrigens neige ich dazu, diese .classes zum Start auch in einem JAR zu archivieren, aber das würde den Rahmen dieses Artikels sprengen.

Abschluss

Eine IDE ist oft nicht erforderlich, um einfache Anwendungen und Beispiele zu erstellen, und kann sogar teurer sein als die Kosten für die Erstellung einfacher Beispiele. In einem solchen Fall ist es ganz einfach, JAVAC und Java zu verwenden, um die Beispiele direkt zu erstellen und auszuführen. Als Beispiele für eine stärkere Einbindung werden Build-Tools wie Ant, Maven oder Gradle attraktiver. Die Tatsache, dass viele Entwicklungsumgebungen diese Build-Dienstprogramme unterstützen, bedeutet, dass ein Entwickler mit einem integrierten Tool, das zu einem früheren Zeitpunkt im Prozess erstellt wurde, zur IDE migrieren kann, wenn festgestellt wird, dass IDE-Unterstützung erforderlich ist, wenn aus einer einfachen Anwendung ein vollwertiges Projekt wird .