Java: NoClassDefFoundError: org/json/JSONException

Question

Also, ich habe den ganzen Tag mit diesem Problem verbracht.
Ich bin mir sicher, dass ich den korrekten Klassenpfad verwende.
Auch habe ich andere Pakete als Abhängigkeiten, und sie funktionieren perfekt.

Ich habe eine Klasse, die org.json verwendet. *
Es gibt auch einige andere äußere Pakete in dieser Klasse verwendet.
All diese Abhängigkeiten werden als JAR-Dateien in meinem/path/to/libs/abgelegt.
json-20160212.jar ist unter ihnen.

ich mit meiner Quellen bin Kompilieren geht

javac \ 
    -cp "src/:/path/to/libs/json-20160212.jar:/path/to/libs/other.jar:/path/to/libs/another.jar" \ 
    -d dst/ \ 
    src/com/example/Source.java 

Compilation ohne Probleme.
Dann erstelle ich Jar aus meinen Klassen-Dateien.
Manifest:

Main-Class: com.example.Source 
Class-Path: /path/to/libs/json-20160212.jar 
    /path/to/libs/other.jar 
    /path/to/libs/another.jar 

Befehlszeile:
jar cfm output.jar manifest -C dst/ ./com

Ich erhalte Glas mit diesem Manifest:

Manifest-Version: 1.0 
Class-Path: /path/to/libs/json-20160212.jar /path/to/libs/other.jar /p 
ath/to/libs/another.jar 
Created-By: 1.7.0_101 (Oracle Corporation) 
Main-Class: com.example.Source 

Wie ich verstanden habe, das ist ok für manifest kompiliert habe geteilte Linien.

Nun, ich meine app von der Kommandozeile ausgeführt wird und diese Fehlermeldung erhalten:

Exception in thread "Thread-0" java.lang.NoClassDefFoundError: org/json/JSONException 
    at com.example.Source.run(Source.java:30) 
Caused by: java.lang.ClassNotFoundException: org.json.JSONException 
    at java.net.URLClassLoader$1.run(URLClassLoader.java:366) 
    at java.net.URLClassLoader$1.run(URLClassLoader.java:355) 
    at java.security.AccessController.doPrivileged(Native Method) 
    at java.net.URLClassLoader.findClass(URLClassLoader.java:354) 
    at java.lang.ClassLoader.loadClass(ClassLoader.java:425) 
    at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:308) 
    at java.lang.ClassLoader.loadClass(ClassLoader.java:358) 
    ... 1 more 

Wie ich weiß, das bedeutet, dass org.json.JSONException bei der Kompilierung in Ordnung war, aber zur Laufzeit fehlt .
Aber was muss ich mit dieser Info machen?
Ich habe diese Datei. Es war während der Kompilierung und zur Laufzeit an seinem Platz.
Auch gibt es andere Abhängigkeiten, und ihre Gläser sind auch an diesem Ort.

Wenn ich JSON-Nutzung aus meiner App entfernen, funktioniert alles einwandfrei.
Also kann ich Schluss machen, dass es das Paket org.json selbst ist, das das Problem macht.

Was muss ich tun, damit es funktioniert?

UPDATE

Jetzt habe ich gemacht dies ändert:

Meine Verzeichnisstruktur:

libs/ 
    json-20160212.jar 
    other.jar 
    another.jar 
src/ 
    com/ 
     example/ 
      Source.java 
dst/ 

Manifest:

Main-Class: com.example.Source 
Class-Path: libs/json-20160212.jar 
    libs/other.jar 
    libs/another.jar 

Compilation:

javac \ 
    -cp "src/:libs/json-20160212.jar:libs/other.jar:libs/another.jar" \ 
    -d dst/ \ 
    src/com/example/Source.java 

Jarchiving:

jar cfm dst/output.jar manifest -C dst/ ./com ./libs 

Ich erhalte Glas mit der Struktur, wie ausgenommen:

META-INF/ 
META-INF/MANIFEST.MF 
com/ 
com/example/ 
com/example/Source.class 
libs/ 
libs/json-20160212.jar 
libs/other.jar 
libs/another.jar 

Und ich bin es mit java -jar dst/output.jar läuft.
Ergebnis ist das gleiche: java.lang.NoClassDefFoundError: org/json/JSONException

Answer 1

So ist die Lösung:

Wie ich verstehe habe, ist der einzige Weg, um den Inhalt der JAR-Dateien zuzugreifen, die in Ihrem Glas sind, ist Ihre eigenen Klassenlader zu schreiben.
Ohne es müssen JAR-Dateien extrahiert werden und dieser extrahierte Inhalt muss in output.jar enthalten sein.

Answer 2

Das Problem ist Ihre Laufzeit Klassenpfad. Es gibt keine Magie mit diesem Fehler. Es bedeutet ganz einfach, dass sich org.json.JSONException nicht auf Ihrem Klassenpfad für die Laufzeit befindet. Suchen Sie das Jar, das diese Klasse enthält, und fügen Sie es in Ihren Klassenpfad zur Laufzeit ein.

Beachten Sie, dass die für die Laufzeit benötigten jars/classes nicht unbedingt mit denen identisch sind, die zum Kompilieren benötigt werden. In Ihrem Klassenpfad für die Laufzeit benötigen Sie häufig mehr als den Klassenpfad für die Kompilierung. Wenn JSONException im Code, den Sie kompilieren, nicht explizit verwendet wird, muss es nicht in Ihrem Kompilierungsklassenpfad enthalten sein. Wenn jedoch eine der Abhängigkeiten zu Ihrem Code JSONException benötigt und sich nicht auf Ihrem Klassenpfad befindet, erhalten Sie einen NoClassDefFoundError.

Ein anderes Problem, das möglicherweise auftreten kann, ist, dass Sie 2 verschiedene Versionen des Json-Jar auf Ihrem Klassenpfad haben. Normalerweise wird die erste Version der Klasse im Klassenpfad geladen und die andere ignoriert. Wenn das erste Jar nicht die Version/Signatur von JSONException hatte, die Sie benötigten, aber die zweite, würde die korrekte Klasse immer noch ignoriert werden, da sie weiter unten im Klassenpfad lag.

Answer 3

Das Problem scheint zu sein, dass Sie die abhängigen Gläser zu Ihrem resultierenden Glas nicht hinzufügen.

ich einen ähnlichen Test jar erstellt haben, mit der folgenden Struktur (Überprüfung jar tf mit) ...

META-INF/
META-INF/MANIFEST.MF
BeanIt.class
TestBean.class
lib/
lib/opencsv-3.7.jar
lib/commons-lang3-3.4.jar

Mein Manifest ...

Main-Class: BeanIt
Class-Path: lib/opencsv-3.7.jar lib/commons-lang3-3.4.jar

Um dieses Glas zu schaffen , müssen Sie einen Befehl etwas ähnliches wie diese ...

jar cfm App.jar MANIFEST.MF BeanIt.class TestBean.class lib 

Sie können sehen, dass ich meine lib folde hinzugefügt habe r an das Jar und bezog sich auf seinen Inhalt auf dem Klassenpfad im Manifest.

So können Sie Ihre vorhandene lib aktualisieren, so ...

jar uf App.jar path 

Pfad ist der Stammpfad Ihres Verzeichnisses path/to/lib. Und es wird einfach das zu Ihrem Glas hinzufügen.

Sie können Ihr Glas zuerst überprüfen mit jar tf, um zu sehen, was es enthält.

Wenn Sie immer noch Schwierigkeiten haben, es zum Laufen zu bekommen, dann können Sie sich eine "FAT JAR" -Lösung anschauen, bei der Sie alle internen JARS-Klassen erweitern und alle zu einem JAR zusammenfassen, das alle notwendigen Klassen enthält. Sie verwenden Entscheidungsmechanismen, um Klassenkonflikte in verschiedenen JARs zu behandeln. Tools wie sbt-assembly oder OneJar sind möglicherweise das, was Sie hier benötigen, wenn Sie nicht in der Lage sind, Ihr JAR so zu entwickeln, wie Sie es erwarten.