Rufen Sie "java -jar MyFile.jar" mit zusätzlicher Klassenpfadoption auf

91

Ich habe eine JAR-Datei erstellt, die alle meine kompilierten Inhalte enthält. Zusätzlich kopiert mein Ant Build Skript die erforderlichen Bibliotheken in einen Unterordner "libs". Die Struktur sieht folgendermaßen aus:

MyProgram.jar
libs/

Wenn ich jetzt versuche, mein Programm auszuführen, wird folgende Fehlermeldung angezeigt:

java -cp ".:/home/user/java/MyProgram/jar/libs" -jar MyProgram.jar
java.lang.ClassNotFoundException: org.postgresql.Driver
    at java.net.URLClassLoader$1.run(URLClassLoader.java:217)
    at java.security.AccessController.doPrivileged(Native Method)
    at java.net.URLClassLoader.findClass(URLClassLoader.java:205)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:321)
    at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:294)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:266)
    at java.lang.Class.forName0(Native Method)
    at java.lang.Class.forName(Class.java:186)
    at database.PostgresQL.getConnection(PostgresQL.java:38)
    at recommender.dao.Creative2IdxDAO.createCreatives2Idx(Creative2IdxDAO.java:19)
    at main.Main.calculateCorrelationMatrix(Main.java:51)
    at main.Main.main(Main.java:28)
java.lang.NullPointerException
    at recommender.dao.Creative2IdxDAO.createCreatives2Idx(Creative2IdxDAO.java:25)
    at main.Main.calculateCorrelationMatrix(Main.java:51)
    at main.Main.main(Main.java:28)

Warum passiert das?

toom
quelle

Antworten:

151

Sie verwenden entweder -jar oder -cp , Sie können die beiden nicht kombinieren. Wenn Sie zusätzliche JARs in den Klassenpfad einfügen möchten, sollten Sie diese entweder in das Manifest der Haupt-JAR einfügen und dann verwenden java -jaroder den vollständigen Klassenpfad (einschließlich der Haupt-JAR und ihrer Abhängigkeiten) einfügen und -cpdie Hauptklasse explizit in der Befehlszeile benennen

java -cp 'MyProgram.jar:libs/*' main.Main

(Ich verwende die dir/*Syntax, mit der der javaBefehl angewiesen wird, alle .jarDateien aus einem bestimmten Verzeichnis zum Klassenpfad hinzuzufügen . Beachten Sie, dass die Datei *durch die Shell vor Erweiterung geschützt werden muss, weshalb ich einfache Anführungszeichen verwendet habe.)

Sie erwähnen, dass Sie Ant verwenden, sodass Sie für den alternativen Manifest-Ansatz die <manifestclasspath>Aufgabe von ant verwenden können, nachdem Sie die Abhängigkeiten kopiert haben, aber bevor Sie die JAR erstellen.

<manifestclasspath property="myprogram.manifest.classpath" jarfile="MyProgram.jar">
  <classpath>
    <fileset dir="libs" includes="*.jar" />
  </classpath>
</manifestclasspath>

<jar destfile="MyProgram.jar" basedir="classes">
  <manifest>
    <attribute name="Main-Class" value="main.Main" />
    <attribute name="Class-Path" value="${myprogram.manifest.classpath}" />
  </manifest>
</jar>

Wenn dies vorhanden ist, java -jar MyProgram.jarfunktioniert es ordnungsgemäß und enthält auch alle libsJAR-Dateien im Klassenpfad.

Ian Roberts
quelle
Hinzufügen zu oben, oder denken Sie daran, die erforderlichen JAR-Einträge in der Datei MANIFEST.MF hinzuzufügen.
Himanshu Bhardwaj
@HimanshuBhardwaj in der Tat, ich habe ein Beispiel hinzugefügt, wie man das mit macht<manifestclasspath>
Ian Roberts
Was ist mit dem ':' in der 'MyProgram.jar: libs / *' los? Ist das ein Trennzeichen?
Gobliins
Der Doppelpunkt @Gobliins ist das Trennzeichen zwischen Elementen in einem Pfad unter Linux- und Mac-Betriebssystemen. Unter Windows würden Sie ;stattdessen Semikolon ( ) verwenden, da unter Windows der Doppelpunkt für Laufwerksbuchstaben verwendet wird. Das OP verwendete in seiner Frage Doppelpunkte und Schrägstriche, was darauf hindeutet, dass sie unter Linux oder Mac ausgeführt werden.
Ian Roberts
5
Wenn sich die Optionen gegenseitig ausschließen, sollte die Befehlszeile eine Warnung ausgeben, wenn beide verwendet werden. Wer hat Zeit für diese Trivia?!
JJS
22

Wenn die -jarOption verwendet wird, wird die -cpOption ignoriert. Die einzige Möglichkeit, den Klassenpfad festzulegen, besteht in der Verwendung der Manifestdatei im JAR.

Es ist einfacher, einfach die -cpOption zu verwenden, Ihre JAR-Datei hinzuzufügen und dann die Hauptklasse explizit aufzurufen.

Vorausgesetzt, der /home/user/java/MyProgram/jar/libsOrdner enthält JAR-Dateien (im Gegensatz zu Klassendateien), funktioniert dies nicht. Sie können keinen Ordner mit einer JAR-Datei angeben, sondern müssen jede JAR-Datei einzeln im Klassenpfad angeben (es lohnt sich, ein einfaches Shell-Skript zu schreiben, um dies für Sie zu tun, wenn eine erhebliche Anzahl von Jars vorhanden ist).

Jonathan
quelle
0

Es ist ein bisschen schwierig. Das folgende Skript ist ein Versuch, den Klassenpfad aus dem Manifest der JAR-Datei abzurufen und anschließend zusätzliche Klassenpfadeinträge hinzuzufügen. Ich hatte gemischte Ergebnisse damit, möchte das Skript aber trotzdem teilen, damit es hier voll funktionsfähig wird.

Das Skript hat zwei Namen

  • Showmanifest
  • Calljar

durch Hardlinking der beiden Dateien zusammen mit

ln calljar showmanifest

Mit calljar -h können Sie die Verwendung sehen.

#!/bin/bash
#set -x
# show the manifest of a jar file
# 2012-07-18
# author WF

#
# show usage
#
usage() {
 echo "usage: showmanifest (jarfile | directory jarfile) " 1>&2
 echo "usage: calljar directory jarfile classpath pattern arguments" 1>&2
 echo "             -h|--help " 1>&2
 echo "               show this help and exit" 1>&2
 echo "             -m|--mainclass javaclass" 1>&2
 echo "               mainclass to use (otherwise manifest is inspected)" 1>&2
 exit 1
}

#
# show the manifest of the given jar file
#
show() {
  dir="$1"
  jar="$2"
    fulljar=`find "$dir" -name "$jar"`
    cd /tmp
    mkdir show$$
    cd show$$
    jar xvf $fulljar META-INF/MANIFEST.MF
    cat META-INF/MANIFEST.MF
    cd /tmp
    rm -rf show$$
}

#
# show the classpath of the manifest
#
calljar() {
  dir="$1"
    jar="$2"
    classpath="$3"
    pattern="$4"
    arguments="$5"
    cmd=`show "$dir" "$jar"   | awk -v extracp="$classpath" -v dir="$dir" -v pattern="$pattern" -v jar="$jar" -v mainclass="$mainclass" -v args="$arguments" '
/Main-Class: / { if (mainclass=="") mainclass=$2 }
/^Class-Path:/ { 
  incp=1; 
    cp=$0; 
    gsub("Class-Path: ","",cp) 
    next
}
/^ .*$/ && incp { 
    line=substr($0,2)
  # remove carriage return (if any)
  cp=cp line
}
END { 
  # we do not like carriage returns
  gsub("\\r","",cp)
  gsub("\\r","",mainclass)
    # we do not like blanks ...
  gsub(" ","",cp)
    gsub(pattern,":"dir"/"pattern,cp)
  print "java -cp " extracp cp ":"dir"/"jar " " mainclass " " args
}
    '`
  #echo $cmd
    $cmd
}


# echo $# arguments found: $*
# parse command line options
while true; do
# echo "option $1"
  case "$1" in
    # options without arguments
    -h|--help) usage;;
         # for options with required arguments, an additional shift is required
        -m|--mainclass) mainclass=$2; shift;;
      (--) shift; break;;
      (-*) echo "$0: error - unrecognized option $1" 1>&2; usage;;
    (*) dir=$1;shift;break;;
  esac
  shift
done

#echo "argcount=$#"
case  $# in
  0) dir=`dirname "$dir"`
       jar=`basename "$dir"`
         show "$dir" "$jar";;
  1) jar="$1"
         show "$dir" "$jar";;
  2) usage;;
    3) usage;;
  *) jar="$1"; shift;
         classpath="$1"; shift;
         pattern="$1"; shift;
         arguments="$@";
    #echo "mainclass=${mainclass}"
    #echo "classpath=${classpath}"

  #echo calljar "${dir}" "${jar}" "${classpath}" "$pattern" "$arguments"
    calljar "$dir" "$jar" "$classpath" "$pattern" "$arguments"
    ;;
esac
Wolfgang Fahl
quelle
-1

Für schnelle, einmalige Tests einer App können Sie die erforderlichen Abhängigkeits-JAR-Dateien einfach mit dem Verzeichnis verknüpfen, das die Haupt-App-JAR-Datei enthält.

Beispiel (für eine App, app.jardie die Eclipse SWT-Bibliothek verwendet, in der in meinem Fall installiert wurde /usr/share/java):

$ ln -s /usr/share/java/swt.jar .
$ java -jar app.jar
ack
quelle