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

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?

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.

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).

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

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