Schritt 1: Erstellen einer BAT-Datei

Zunächst schreiben wir uns eine BAT-Datei, die unser eigentliches Java-Programm, also die von uns erzeugte JAR-Datei aufruft. Das geht ganz einfach mit einem simplen Text-Editor. Erstellt eine Textdatei und ändert die Dateiendung auf BAT  In die BAT-Datei schreibt Ihr folgendes:

java -jar <Dateiname>.jar

Füllt den Platzhalter dabei mit dem korrekten Dateinamen eurer JAR-Datei. Diese Datei liegt im selben Verzeichnis wie die JAR-Datei. Ob Ihr alles korrekt gemacht habt, könnt Ihr testen, indem Ihr einen Doppelklick auf die BAT-Datei ausführt. Jetzt sollte sich das Java-Programm öffnen (selber Effekt wie ein Doppelklick auf die JAR-Datei selber).

Schritt 2: Konvertieren von BAT zu EXE

Die zuvor erstellte BAT-Datei soll nun zu einer EXE-Datei konvertiert werden. Hierfür kommt nun das bereits erwähnte Tool BAT to EXE Converter zum Einsatz. Das Tool kann entweder installiert werden oder Ihr benutzt die Mobile Version ohne Installation. Nachdem Ihr das Tool gestartet habt, seht Ihr folgendes Fenster.

Ganz oben im ersten Element verweist Ihr nun auf die BAT-Datei, die wir zu einer EXE-Datei konvertieren möchten. Hierfür kann man auch per Drag & Drop die Datei einfach in das Feld ziehen. Der Pfad stellt sich automatisch ein. Das Tool nimmt den Pfad der BAT-Datei automatisch als Ausgabepfad für die EXE-Datei an. Die Sichtbarkeit entscheidet darüber ob die Konsole (Ausführen der BAT-Datei) sichtbar bleibt oder nicht. Wenn beispielsweise eine GUI programmiert wurde, möchte man in der Regel nicht, dass die Konsole sichtbar ist. Je nach Architektur (PC) wählt Ihr 32 oder 64 Bit. In der falschen Einstellung gibt es eine Fehlermeldung. Als nächstes wechselt Ihr zum Reiter Einfügen.

Hier wird nun die von Euch erzeugte JAR-Datei hinzugefügt. Das hat den Effekt, dass Ihr später nur noch die einzelne EXE-Datei habt und keine weiteren Dateien, was sehr attraktiv ist um das Programm zu verteilen. Übrigens können hier auch extern notwendige DLL-Dateien mit eingebunden werden. Im nächsten Reiter Versionsinformationen können wir neben einem Icon (Format ICO) weitere Details über das Projekt angeben.

Die beiden letzten Reiter des Programms sind nicht weiter relevant und werden aus diesem Grund auch nicht weiter angesprochen. Es sind nun alle wichtigen Einstellungen vorgenommen und die EXE-Datei kann mit einem Klick auf Kompilieren erzeugt werden.

Optional: Externe Abhängigkeiten

Manchmal wird es der Fall sein, dass Euer Java-Programm noch von externen Komponenten abhängig ist. So werden möglicherweise weitere JAR-Dateien aus dem Unterordner lib benötigt. Oder auch DLL-Dateien. Während die DLL-Dateien einfach im Reiter Einfügen zur EXE-Datei hinzugefügt werden können funktioniert das mit den JAR-Dateien im Ordner lib leider nicht ganz so einfach. Erinnerung: Diese Anleitung gilt für die Nutzung der IDE Netbeans.Unter Netbeans gibt es jedoch die Möglichkeit alle extern verwendeten JAR-Dateien mit in die zu erstellende JAR-Datei einzubinden. Dazu sind lediglich ein paar Zeilen Code in der Build.xml Datei notwendig. Navigiert unter Netbeans in den Reiter Files und öffnet die Datei. Scrollt nun hinunter bis zu folgender Markierung:

</project>

Vor dieser Anweisung wird nun folgender Code hinzugefügt:

<!-- Pack all JAR files in one JAR file to create one executable JAR -->
<target name="package-for-store" depends="jar">
    <property name="store.jar.name" value="NAME"/>
    <property name="store.dir" value="store"/>
    <property name="store.jar" value="${store.dir}/${store.jar.name}.jar"/>
    <jar destfile="${store.dir}/temp_final.jar" filesetmanifest="skip">
        <zipgroupfileset dir="dist" includes="*.jar"/>
        <zipgroupfileset dir="dist/lib" includes="*.jar"/>
        <manifest>
            <attribute name="Main-Class" value="${main.class}"/>
        </manifest>
    </jar>
    <zip destfile="${store.jar}">
        <zipfileset src="${store.dir}/temp_final.jar"
        excludes="META-INF/*.SF, META-INF/*.DSA, META-INF/*.RSA"/>
    </zip>
    <delete file="${store.dir}/temp_final.jar"/>
    <exec dir="./store" executable="cmd">
          <arg line="/c create.bat"/>
    </exec>
</target>

Wichtig ist, dass Ihr in der 2. Zeile den Namen ( value=NAME ) euer JAR-Datei (ohne Endung) eintragt. Der Name der hier eingetragen wird bestimmt den Dateinamen der zusammengefassten JAR-Datei. Diese Zeile ist gemeint:

<property name="store.jar.name" value="NAME"/>

Die Datei wird gespeichert. Im Anschluss müsst Ihr euer gesamtes Projekt Bauen, und zwar mit Clean and Build. Wenn das erledigt ist, navigiert ihr wieder zu der Build.xml Datei und führt einen Rechtsklick auf sie aus. Hier ist nun folgendes auszuwählen:  Run Target  Other Targets Package-for-store.Jetzt ist die neue JAR-Datei, die alle Abhängigkeiten (externe JAR-Dateien) im Ordner Store zu finden. Wenn Ihr diese nun mit dem BAT to EXE Converter Tool einbindet (auch notwendige DLLs mit einbinden), erhaltet Ihr eine einzige EXE-Datei.

Update (08.04.2017) Es gibt eine alternative bzw. elegantere Möglichkeit, die das Erstellen einer EXE aus einer JAR Datei mit Netbeans völlig automatisiert erledigt. Bei dieser Methode seht ihr auch keine DLL Dateien oder ähnliches mehr, die erst entpackt werden müssten um nutzbar zu sein. Die Beschreibung dieser automatisierten Methode findet Ihr nachfolgend:

Automatisches Erzeugen der EXE-Datei

Wir brauchen für diese Variante nach wie vor das BAT-to-EXE-Tool. Der Clou an dieser automatisierten Methode ist jedoch, dass wir diesmal die portable Version (keine Installation notwendig) des Tools sowie die Ansprache über die Kommandizeile verwenden. Anbei eine Liste der Dateien die benötigt werden:

• Die portable Version des Bat-To-Exe-Tools (findet Ihr im > portable < Ordner des Downloads)
• Die BAT-Datei (wie oben in diesem Artikel beschrieben), die lediglich die JAR-Datei aufruft ( java -jar <Dateiname>.jar)
• externe DLL Dateien soweit vorhanden
• und eine weitere Batch-Datei

All diese Dateien ladet Ihr in den folgenden Ordner, der sich in eurem Projektordner befindet:

Projektordner/store/

Zusätzlich erzeugt Ihr den folgenden Ordner (in diesem findet Ihr dann immer die aktualisierte EXE-Datei):

Projektordner/store/exe/

Die angesprochene weitere Batch-Datei wird benötigt, damit Netbeans mit Hilfe dieser das portable Bat-To-Exe-Tool automatisiert über die Kommandozeile ansprechen kann, um letztendlich die gewünschte EXE-Datei aus unserem Java-Projekt bzw. JAR-Datei zu erzeugen. Hier der Inhalt, der in der neuen > create.bat < Datei stehen muss:

del "exe\<NameDeinerExe>.exe"
Bat_To_Exe_Converter.exe -bat <NameDeinerBat>.bat -save exe/<NameDeinerExe>.exe -icon <NameDeinerIconDatei>.ico -invisible -x64 -temp -include <NameExternerDLL>.dll -include <NameDeinerJAR>.jar

Kurze Erläuterung zu den jeweiligen Dateinamen: Ich würde den Namen der EXE, der BAT, der JAR und der (optionalen) ICO-Datei alle gleich wählen. Sprich, wenn Euer Java-Projekt “Apfel” heißen würde, dann habt Ihr entsprechend die Dateien:

• Apfel.exe (diese Datei wollen wir erzeugen)
• Apfel.bat (diese Datei enthält nur den Aufruf der Apfel.jar – Beschreibeung siehe Artikel)
• Apfel.jar (diese Datei erzeugt Netbeans über Run Target > Other > Package-For-Store)
• Apfel.ico (diese Datei würde dann das Icon eurer EXE darstellen)
• sonstige DLL Dateien behalten natürlich ihre Namen

Zusätzlich entfernen wir jetzt noch folgende zwei Zeilen aus der > build.xml < Datei (in die Ihr nach wie vor den Code, siehe Beschreibung oben, eingefügt habt):

<delete dir="${store.dir}"/>
<mkdir dir="${store.dir}"/>

Nachdem Ihr diese zwei Zeilen entfernt habt, fügt Ihr diese vor </target> ein:

<echo message="Creating ${application.title}.exe"/> 
<exec dir="./store" executable="cmd">
<arg line="/c create.bat"/>
</exec>

Der <target> Block in der build.xml sollte nun also wie folgt aussehen:

<target name="package-for-store" depends="jar">
   <property name="store.jar.name" value="NAME"/>
   <property name="store.dir" value="store"/>
   <property name="store.jar" value="${store.dir}/${store.jar.name}.jar"/>
   <echo message="Packaging ${application.title} into a single JAR at ${store.jar}"/>
   <jar destfile="${store.dir}/temp_final.jar" filesetmanifest="skip">
      <zipgroupfileset dir="dist" includes="*.jar"/>
      <zipgroupfileset dir="dist/lib" includes="*.jar"/>
      <manifest>
         <attribute name="Main-Class" value="${main.class}"/>
      </manifest>
   </jar>
   <zip destfile="${store.jar}">
      <zipfileset src="${store.dir}/temp_final.jar"
      excludes="META-INF/*.SF, META-INF/*.DSA, META-INF/*.RSA"/>
   </zip>
   <delete file="${store.dir}/temp_final.jar"/>

   <echo message="Creating ${application.title}.exe"/> 
   <exec dir="./store" executable="cmd">
      <arg line="/c create.bat"/>
   </exec>
</target>

Wenn Ihr jetzt ein Package-For-Store ausführt, packt Netbeans zunächst alle JAR-Files, die Euer Projekt möglicherweise beeinhaltet gebündelt zu einer JAR zusammen und erzeugt im Anschluss direkt eine entsprechende EXE-Datei, die zudem unsichtbar alle (optional) DLL-Dateien enthält um das Programm zu starten. Abseits von Netbeans, kann die EXE-Datei natürlich auch erzeugt werden, indem Ihr einfach einen Doppelklick auf die > create.bat < Datei ausführt 🙂