Eine jar verwenden, die intern auf eine andere jar zugreift

[LargeBearCat]

Hallo,
ich verwende die berühmte Jama Bibliothek als eine jar (Jama.jar) in meiner Klasse (sie heiße MyClass.java). Jama hat den package Namen "Jama". Meine Klasse hat den package Namen "myClass". Beim Exportieren von MyClass mit Eclipse habe ich Jama.jar dem Build Path hinzugefügt. Außerdem habe ich unter "Order and Export" angegeben, dass Jama.jar mitexportiert wird. Ich bekomme dann MyClass.jar, dessen Dateigröße deutlich größer ist als Jama.jar. Sie wurde also vermutlich mitverpackt.

Ich habe dann noch ein Testprogramm (Test.java), das mein MyClass.jar verwendet. Test.java greift nicht direkt auf Jama.jar zu. Doch jedes Mal, wenn MyClass auf Jama zugreift, kommt es zum Absturz, weil Jama nicht gefunden wurde. Wenn ich in meinem Testprogramm Jama.jar nochmals separat hinzufüge, funktioniert es. Aber ich möchte, dass Jama.jar innerhalb von MyClass.jar bereits verwendet werden kann. Wo habe ich den Fehler gemacht?

Danke vielmals!

 

[irgendjemand]

kann man ohne code nichts sagen ... würde aber darauf tippen das du entweder beim laden einen fehler machst oder der export schiefgelaufen ist ...

so wie es sich anhört hat deine IDE die lib entpackt und mit in dein build-jar eingepackt ...
dann reichen einfach import-anweisungen weil dann alle klassen mit dem laden der jar verfügbar sind

eine andere möglichkeit wäre auch beide jars separat zu haben und dann im manifest "jama.jar" im CP zu nennen ...

wieder eine andere art wäre das laden via URLClassLoader ...

auch jar-in-jar ist mit speziellen loadern möglich ...


usw ...

ohne etwas code , fehlermeldungen und vielleicht dein build-jar als attachment wird das rätzel raten ...

 

[LargeBearCat]

Danke für deine Antwort.

Ich werde bald ein bisschen Code hinzufügen.

Schneller Nachtrag: Das Wort Bibliothek ist schlecht gewählt. Ich habe alle Jama *.class Dateien einfach nur in eine jar gepackt. Das Package heißt Jama. Das jar-File heißt Jama.jar. Ich habe dann eine MyClass Klasse, die Jama.jar als externes jar über eclipse build path importiert. MyClass.class wird dann ohne Fehlermeldung von eclipse in MyClass.jar exportiert.

Das ist ja eigentlich ein ganz rudimentärer Vorgang. Ich wollte erstmal wissen, ob mein beschriebener Weg vom Prinzip her überhaupt richtig ist. Dass ich es nicht mit einem Anfängerfehler zu tun habe. So wie ich dich verstanden habe, habe ich eigentlich alles richtig gemacht...

 

[diggaa1984]

Schneller Nachtrag: Das Wort Bibliothek ist schlecht gewählt. Ich habe alle Jama *.class Dateien einfach nur in eine jar gepackt. Das Package heißt Jama. Das jar-File heißt Jama.jar. Ich habe dann eine MyClass Klasse, die Jama.jar als externes jar über eclipse build path importiert. MyClass.class wird dann ohne Fehlermeldung von eclipse in MyClass.jar exportiert.

Ist das das "Java Matrix Package"? Verwende doch statt es selbst zu packen erstmal gleich die bereitgestellte .jar

Dann würde ich auch erstmal ein "internen" Test mit der MyClass laufen lassen um zu sehen ob es da auch ohne Probleme funktioniert. Also eine kleine Testklasse die im selben Projekt liegt wie die MyClass. Wenn das auch klappt, dann kommt der Teil mit der weiteren externen Testklasse, die dann selbst nur MyClass.jar verwenden soll.

 

[LargeBearCat]

Danke für deine Antwort!

Ja ich habe Jama.jar bereits in MyClass ausprobiert. Es geht.

Ich hätte außerdem wohl zuerst dieses oft behandelte Thema in anderen Beiträgen lesen sollen. Was ich daraus entnehme ist, dass es so einfach nicht geht. Wenn ich beide jars dann im Testprogramme einbinde, geht es ja auch. Aber eigentlich habe ich gedacht, dass das alles ganz trivial ist, vor allem wenn man bedenkt, wie lange es Java schon gibt. Mich nerven langsam diese ständigen Workaroundlösungen für scheinbar ganz banale Probleme.

 

[irgendjemand]

warum würg-a-raund ?
das ist nun mal ganz normale spezifikation das man zusatz-libs im classpath mit aufführt ...
darum gibt es im manifest auch das entsprechende attribut ...
das funktioniert dann so das du deine app in ein jar packst und in dessen manifest im classpath die jars der verwendeten libs aufnimmst ... und diese jars legst du dann in den selben ordner wie dein jar ...

genau so hat man sich das auch von anfang an gedacht ...

da finde ich es schon eher einen viel größeren würg-a-raund was die meisten IDEs und build-tools mit "libs" machen : diese werden "entpackt" und dann in das "build-jar" mit eingepackt ...
das einzige was ich daraus ableiten kann : man hat halt alles in einem FAT jar *so heißt auch glaub ich das eclipse plugin : "fat jar"* ... aber ansonsten ist es eigentlich nicht wirklich im sinne des cp-attributes des manifest ...

wobei das noch die einfach variante ist ...
lustig wird das ganze wirklich erst wenn du anfängst mit "URLClassLoader" rumzuspielen ...

 

[LargeBearCat]

Es liegt doch daran, dass Export die externe jar nicht mit eingebunden hat. Wenn ich aber in eine executable jar exportiere, funktioniert es. Aber ich will es lieber machen, so wie du es vorgeschlagen hast.

Beispiel:
Jama.jar:Anhang anzeigen Jama.jar

Ich habe ein Eclipse Java Projekt MyClass. Im Projekt habe ich MyClass.java und MyClassTest.java. Jama.jar wurde als external jar über build path importiert.

MyClass.java:

package myclass;
import Jama.*;

public class MyClass
{	
	public void testMethod()
	{
		Matrix testMatrix=new Matrix(2,2);
		System.out.println(testMatrix.get(0, 0));
	}
}

MyClassTest.java ruft Methode auf und alles ist gut.

package myclass;

public class MyClassTest
{
	   public static void main(String[] args)
	   {
		    MyClass myObject=new MyClass();
			myObject.testMethod();
	   }
	
}

Exportieren: File-->Export-->jar-file. Eclipse erzeugt merkwürdigerweise kein Manifest. Also habe ich auf der dritten Seite selbst ein Manifest (ohne Dateiendung) angegeben. Ist hier was zu beachten?

Manifest:

Manifest-Version: 1.0
Class-Path: Jama.jar

Nach dem Export befinden sich Jama.jar, Manifest und die neu erzeugte MyClass.jar im gleichen Ordner. Man sieht aber bereits an der Größe von MyClass.jar, dass Jama.jar nicht mit reingelegt wurde. Bevor ich diese Testklassen geschrieben habe, habe ich es nicht gesehen.

Ich habe ein zweites Projekt TestClass mit der Klasse TestClass.java, die MyClass.jar als externe jar über Build Path importiert.

import myclass.*;

public class TestClass
{
	public static void main(String[] args)
	{
		MyClass myObject=new MyClass();
		myObject.testMethod();
	}
}

Ich bekomme die Fehlermeldung:

Exception in thread "main" java.lang.NoClassDefFoundError: Jama/Matrix
at myclass.MyClass.testMethod(MyClass.java:8)
at TestClass.main(TestClass.java:8)
Caused by: java.lang.ClassNotFoundException: Jama.Matrix
at java.net.URLClassLoader$1.run(URLClassLoader.java:202)
at java.security.AccessController.doPrivileged(Native Method)
at java.net.URLClassLoader.findClass(URLClassLoader.java:190)
at java.lang.ClassLoader.loadClass(ClassLoader.java:307)
at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:301)
at java.lang.ClassLoader.loadClass(ClassLoader.java:248)
... 2 more

 

[diggaa1984]

also ich hab eigentlich eine gleiche konstellation, nur nutze ich maven und alles is hübsch ^^
Ich habe eine Klassensammlung XY.jar, die ich selbst erstelle. Diese nutzt 6-7 weitere jars, die nicht mit eingepackt werden, sondern parallel zur XY.jar im selben Ordner liegen.

Mein Hauptprogramm bezieht sich nun nur auf die XY.jar und alles is hübsch.
Aber das wird durch Maven alles automatisiert (sicherlich gemäß meinen Vorgaben).