Jar-Archiv erstellen

[thE_29]

Da sich viele beim Erstellen von Jar-Archiven alleine schon schwer tun, erweitere ich diese FAQ jetzt mal mit einem Howto fürs normale Jar-Archiv erstellen.

Erweitertes Thema: :arrow: jar-Dateien in jar-Dateien packen
Jar erstellen mit Batchdatei: :arrow: Jar-Datei mit Hilfe einer Batchdatei erstellen

Also, als erstes braucht man mal die *.class Dateien.

Diese macht man mit: [c]javac -cp meinclasspath[/c]

Hat man diese *.class Dateien so kann man mit dem Befehl [c]jar[/c] ein Jar-Archiv damit erstellen.

Zu dem kommen wir jetzt.

Hat man nur eine class Datei (oder vielleicht ein paar mehrere) und die liegen im selben Verzeichnis wie die .java Datei (also keine packages), so kann man ein Jar-Archiv mit diesem Befehl erstellen:

jar -cfv test.jar test1.class [test2.class] [test3.class] [....class]

(die [noparse][ ][/noparse] sind optionale Erweiterungen, wenn man mehrere class Dateien hat!)

Mit diesem Befehl wird ein Jar-Archiv mit dem Namen test.jar erstellt.

Ein Manifest.MF ist nicht zwingend notwendig um ein Jar-Archiv zu erstellen. Es ist aber von Vorteil wenn man eines einbindet, indem man den Class-Path und die Main-class angibt!


Bsp. Aufbau einer MANIFEST.MF:

Manifest-Version: 1.0
Main-Class: test1
[Class-Path: myextension1.jar myextension2.jar]
[i]Leerzeile[/i]

Nachtrag (danke an Dotlens): Wenn man am Schluß der Datei die Leerzeile vergißt, so kann man das Jar-Archiv zwar erstellen, aber beim Aufruf von java -jar test.jar kommt ein Fehler (er findet das letzte Attribut nicht). Also diese Leerzeile wird benötigt!!

Also, nach jedem Attributnamen (sei es jetzt Manifest-Version oder Main-Class) gehört ein Leerzeichen, da es sonst nicht funktioniert! Die Class-Path Variable (wenn benötigt) wird via Leerzeichen (keine ; oder : ) getrennt.

Ein Jar-Archiv, also mit einer Manifest.MF, erstellt man so:

jar -cvfm meinjar.jar meinmanifest.txt test.class

Die

MANIFEST.MF

muß vorher nicht so heißen (wird automatisch so erstellt). Man kann sie für Editierungsgründe, als .txt benennen, sodaß man leichter ßnderungen vornehmen kann.

Stimmt die Main-class und der Class-Path (falls er benötigt wird), so kann man das Programm so starten:

java -jar meinjar.jar

Falls man seine Quelldateien in einem Unterverzeichnis liegen hat (zum Beispiel [c]src[/c]) kann man jar dazu veranlassen, alle Dateien aus diesem Unterverzeichnis zu laden. Dafür gibt es das Argument [c]-C directory[/c].

EDIT (Ebenius): Achtung: JAR verhält sich unter Windows eigenartig, wenn man beim Schalter [c]-C[/c] Slashes ([c]/[/c]) statt Baskslashes ([c]\[/c]) verwendet.

Bsp.: Also ich habe folgendes Package:
at.jni.test

Die Main-Class lautet: at.jni.test.jnitmp (Dieser Eintrag, ist dann in die Manifest.MF zu übernehmen). Sie liegt in [c]src/at/jni/test/jnitmp.class[/c]

Man geht also ins oberste Verzeichnis. Würde dann so aussehen:

- meinjar.jar (wird erzeugt)
- meinmanifest.txt
- [src]
  - [at]
    - [jni]
      - [test]
        - jnitmp.class
        - jnitmp.java

Man kann es entweder so machen, dass er einem jedes File im Verzeichnis hinzufügt (also auch das .java File) oder man kann es explizit angeben.

So fügt jar alle Dateien aus dem Verzeichnis [c]src[/c] (sowohl die .class Datei als auch die .java Datei):

jar -cvfm meinjar.jar meinmanifest.txt -C src /

Will man das nicht, so muß man die Dateien einzeln angeben:

jar -cvf meinjar.jar -m meinmanifest.txt -C src at/jni/test/jnitmp.class

Der Schalter [c]-m manifest[/c] ist optional. Lässt man ihn weg, dann erstellt JAR ein einfaches Manifest.

jar -cvf meinjar.jar -C src at/jni/test/jnitmp.class[/cod]

Will man noch eine Index-Information haben - INDEX.LIST, so muß man nachdem man das Jar-Archiv erstellt hat, noch diesen Befehl ausführen:
[code]jar -i meinjar.jar

Nach diesem Befehl hat man im Verzeichnis META-INF eine INDEX.LIST.


Update.:

Will man seinen kompletten "classes" Ordner importieren, so sieht der Befehl dann so aus:

jar -cvfm test.jar manifest.MF -C classes /

Hier wird der Inhalt von classes in das Jar-File reingeschrieben, aber ohne den Ordner classes.


Desweiteren noch wichtig bei der Manifest.MF:

Ihr dürft nirgends zuviele Leerzeichen oder sonstiges lassen!! Lässt ihr hinter dem Namen ein Leerzeichn (bei Main-Class) so sucht er nach Namen<Leerzeichen>!! Natürlich heißt eure Klasse ja nicht so! Also aufpassen in der Manifest.MF die ist sehr knausrig!!
Und das Enter am Schluss nicht vergessen!!

 

[L-ectron-X]

Eine kleine Batchdatei, die das Erstellen vereinfachen kann.

Wenn man mit einem Editor und der Kommandozeile arbeitet, oder mit einem Code-Editor ohne Jar-Funktion, kann diese kleine Batchdatei viel Arbeit abnehmen.

Einfach die Datei mit Hilfe eines Texteditors modifizieren, unter einem Namen wie bspw. JarBatch.bat in deinem Projektverzeichnis speichern und per Doppelklick ausführen, das Programm erledigt dann den Rest korrekt und vollautomatisch.

@echo off
echo JarBatch - erzeugen von jar-Dateien
echo.
rem --> anpassen!
rem * Hier den Pfad zum SDK setzen!
set path=.;C:\j2sdk1.4.2_04\bin

rem * Manifestdatei vorbereiten und erzeugen.
echo Manifest-Version: 1.0>manifest.mf

rem --> anpassen!
rem * Bitte ClassPath hier angeben! Der Class-Path enthält eine Auflistung externer Jar-Dateien (optional)
rem * Die Auflistung beginnt immer ausgehend von der Main-Class. Hier liegen die Bibliotheken
rem * also in einem Verzeichnis namens lib unterhalb der Main-Class.
rem * Beispiel: Class-Path: ./lib/h2.jar ./lib/icons.jar
echo Class-Path: .>>manifest.mf

rem --> anpassen!
rem * Falls gewünscht, bitte auskommentieren und Image für Splashscreen hier angeben! (optional)
rem * echo Splashscreen-Image: splash.png>>manifest.mf

rem --> anpassen!
rem * Bitte Main-Class hier angeben! (Die Klasse mit der main()-Methode)
rem * Wenn die Main-Class in einem Package liegt, muss es mit angegeben werden.
echo Main-Class: MeinPackage.MeineKlasse>>manifest.mf

rem * Abschließende Leerzeile nicht vergessen!
echo.>>manifest.mf

if exist *.class goto create

rem * Kompilieren, falls noch nicht geschehen.
:compile
if not exist *.java goto errorjava
javac -O *.java

rem * Jar-Datei erzeugen.
:create
if not exist *.class goto errorjar
rem --> anpassen!
rem * Anwendungsbeispiel: jar cfvm ArchivName.jar manifest.mf *.class images sounds
rem * würde ein Manifest, alle class-Dateien und die Verzeichnisse images und sounds in ein eine Jar-Datei namens ArchivName.jar einfügen.
rem * Bitte Name der zu erstellenden jar-Datei hier angeben!
jar cfvm MeinProgramm.jar manifest.mf MeinPackage
echo Entsprechende Dateien wurden dem jar-Archiv hinzugefügt.
goto end

:errorjava
echo java-Dateien nicht gefunden!
echo class-Dateien konnten nicht erstellt werden.

:errorjar
echo class-Dateien konnten nicht gefunden werden!
echo jar-Archiv konnte nicht erstellt werden.

:end
rem * Manifest von Festplatte löschen
del manifest.mf

rem * Konsole für Ausgaben geöffnet lassen
echo.
pause

Die meisten großen Java-IDEs haben eine eingebaute Funktion zur Erstellung von ausführbaren Jar-Dateien.

Noch ein Link für die Elemente in der Manifest-Datei: http://download.oracle.com/javase/1.5.0/docs/guide/jar/jar.html#JAR Manifest