Jar-File soll externe class-Datei benutzen

[nethwa]

Moin moin,

ich probiere gerade wieder etwas mit Java rum und da ich zu diesem Thema keine direkte Antwort finde wollte ich hier einfach mal nachfragen:

Ist es unter Java möglich, dass, wenn man eine Jar-Datei startet, diese im Verlauf des Arbeitens externe class-Dateien verwendet? Ich habe bereits versucht einfach die Ordnerstruktur zu verwenden und so zur class-Datei zu verweisen, das hat allerdings nicht funktioniert.

Und nicht dass man mich jetzt falsch versteht - ich will nicht, dass die jar-Datei erst in einem IDE gestartet wird oder dass eine externe Jar-Date verwendet wird. Ich will einfach nur, dass der Benutzer die jar-Datei starten kann und ggf. zusätzliche class-Dateien (zB von mathematischen Algorithmen, diese sollten dann die Konventionen vordefinierter Interfaces und ABC's erfüllen) die in einem bestimmten Ordner liegen oder angegeben werden laden und verwenden kann.

Ein paar Hinweise oder Anregungen dazu würden mich schon sehr sehr freuen,

Vielen Dank im Vorraus,
nethwa

 

[bygones]

am einfachsten ist es diese zusaetzlichen class Dateien beim Start deines Jars zu laden - woher soll waehrend der Laufzeit das programm wissen, dass sich der Ordner geaendert hat.

Im grunde willst du ein Plugin system und da gibt es meines Wissens einige Threads im Forum - ein wichtiger Teil ist zb der URLClassLoader

 

[nethwa]

Ich hatte vergessen die Struktur zu Erläutern Tut mir leid^^

Also die classes sollen nicht on-the-fly geladen werden - die jar-Datei selbst provided eine weitere Prozesstruktur, in der die classes dann erst verwendet werden sollen, es wird quasi ein zweiter Prozess gestartet, wo die externen Klassen erst zur Verwendung kommen.

Bei starten der jar-Datei wird zuerst eine GUI geöffnet, wo der Benutzer Einstellungen vornehmen und, wenn benötigt, externe classes auswählen. Der Start-Knopf beendet dann die gui und übergibt sämtliche benötigten Parameter (Einstellungen und classes) an eine andere Klasse, die in der jar provided wird. Diese startet dann nacheinander die classes mit den gewünschten Einstellungen und gibt anschließend die Ergebnisse aus.
Da die externen classes die Voraussetzungen der Interfaces der jar-Datei erfüllen, sollte das eigentlich kein Problem sein, da die Liste der classes als Typ einfach das Interfaces gegeben hat (sollte eine Voraussetzung nicht erfüllt sein wird natürlich die Exception gefangen).

 

[nethwa]

Ich hatte vergessen die Struktur zu Erläutern Tut mir leid^^

Also die classes sollen nicht on-the-fly geladen werden - die jar-Datei selbst provided eine weitere Prozesstruktur, in der die classes dann erst verwendet werden sollen, es wird quasi ein zweiter Prozess gestartet, wo die externen Klassen erst zur Verwendung kommen.

Bei starten der jar-Datei wird zuerst eine GUI geöffnet, wo der Benutzer Einstellungen vornehmen und, wenn benötigt, externe classes auswählen. Der Start-Knopf beendet dann die gui und übergibt sämtliche benötigten Parameter (Einstellungen und classes) an eine andere Klasse, die in der jar provided wird. Diese startet dann nacheinander die classes mit den gewünschten Einstellungen und gibt anschließend die Ergebnisse aus.
Da die externen classes die Voraussetzungen der Interfaces der jar-Datei erfüllen, sollte das eigentlich kein Problem sein, da die Liste der classes als Typ einfach das Interfaces gegeben hat (sollte eine Voraussetzung nicht erfüllt sein wird natürlich die Exception gefangen).

Hab mich schnell mal registriert (sorry für den Doppelpost).
Das mit dem Plugin-System werde ich mir aber gleich mal ansehen, vielleicht ist das doch das, was ich meine, danke sehr.

 

[bygones]

ja ist das klassische Plugin System - damit solltest du recht gut fahren

 

[irgendjemand]

also in dem fall könnte man sich das ganze ziemlich einfach machen in dem man im MANIFEST des jar als class-path einfach den entsprechenden unter-ordner angibt ... dadurch werden diese dann ebefalls geladen ...

zur prozessstruktur : is denke ich ein wenig overkill ... startest du denn wirklich einen seperaten prozess oder läuft alles innerhalb ein und derselben VM ab ?

auch könnte man bei dir fertige dinge anwenden ... stich worte wären z.b. SPI *ServiceProviderInterface* in verbindung mit dem ServiceLoader *gibt hier ein paar themen ... auch drüben auf Java @ tutorials.de: Tutorials, Forum & Hilfe gibt es zu SPI und plugin-system einige threads* ... OSGI *modul-basierte plattform* ... und natürlich das wichtigste : URLClassLoader

du könntest dir auch was einiges schreiben ...

ich habe z.b. selbst ein sehr stabiles plugin-system ...
ich poste dir einfach mal den source *leicht abgewandelt und auf das wesentliche gekürzt* ... ist zwar nicht ganz sauber und leider auch nicht mehr ganz so aktuell ... aber sehr robust und funktionsfähig ... *ich muss den code langsam echt mal updaten mit den ideen die ich noch dafür habe ... sorry für dieses "out-of-date" wirr-warr*

Plugin.java *ist das interface welches von den klassen implementiert werden muss*

public interface Plugin
{
	public void loadPlugin(PluginLoader loader) throws Exception;
	public void startPlugin() throws Exception;
	public void stopPlugin() throws Exception;
}

PluginLoader.java *ein interface welches von der klasse zu implementieren ist welche die "Plugin"s läd*

public interface PluginLoader
{
	public Object invoke(String pluginName, String pluginMethod, Object... args) throws Exception;
	public void shutdown();
}

LoaderImpl.java *eine zusammengeschnittene beispiel implementierung eines loaders*

public class LoaderImpl implements PluginLoader
{
	private Vector<Plugin> plugins=null;
	private PluginFilenameFilter pluginFilenameFilter=null;
	public static void main(String[] args) { (new LoaderImpl()).load(); }
	private LoaderImpl()
	{
		pluginFilenameFilter=new PluginFilenameFilter();
		plugins=new Vector<Plugin>();
	}
	private void load()
	{
		try
		{
			File pluginDir=new File("plugins");
			File[] pluginJars=pluginDir.listFiles(pluginFilenameFilter);
			for(File pluginJar : pluginJars)
			{
				String name="FAIL";
				JarFile jarFile=new JarFile(pluginJar);
				for(Enumeration<JarEntry> entries=jarFile.entries(); entries.hasMoreElements(); )
				{
					JarEntry entry=entries.nextElement();
					if(entry.getName().endsWith("Plugin.rsf"))
						name=(new BufferedReader(new InputStreamReader(jarFile.getInputStream(entry)))).readLine();
				}
				jarFile.close();
				if(name.equals("FAIL"))
					continue;
				URLClassLoader urlCL=new URLClassLoader(new URL[] { pluginJar.toURI().toURL() });
				Class<?> clazz=urlCL.loadClass(name);
				Plugin plugin=(Plugin)clazz.newInstance();
				plugin.loadPlugin(this);
				plugins.add(plugin);
			}
			for(Plugin plugin : plugins) { plugin.startPlugin(); }
		}
		catch(Exception e) { e.printStackTrace(); System.exit(1); }
	}
	public Object invoke(String pluginName, String methodName, Object... args) throws Exception
	{
		for(Plugin plugin : plugins)
		{
			Class<?> clazz=plugin.getClass();
			if(clazz.getName().equals(pluginName))
			{
					for(Method method : clazz.getDeclaredMethods())
					{
						if(method.getName().equals(methodName))
							return method.invoke(plugin, args);
					}
			}
		}
		return null;
	}
	public void shutdown()
	{
		for(Plugin plugin : plugins)
		{
			try { plugin.stopPlugin(); }
			catch(Exception e) { e.printStackTrace(); }
		}
		System.exit(0);
	}
	static final class PluginFilenameFilter implements FilenameFilter
	{
		public boolean accept(File path, String name)
		{
			if((name.toLowerCase().endsWith(".jar"))&&(!name.equals("Launcher.jar")))
				return true;
			else
				return false;
		}
	}
}

SamplePlugin.java *ein einfaches beispiel plugin*

public class SamplePlugin implements Plugin
{
	private PluginLoader pluginLoader=null;
	public void loadPlugin(PluginLoader pluginLoader) throws Exception { this.pluginLoader=pluginLoader; }
	public void startPlugin() throws Exception
	{
	}
	public void stopPlugin() throws Exception
	{
	}
}

das sample-plugin muss im ordner "plugins" in einem JAR liegen welches neben der CLASS und dem MANIFEST eine weitere datei enthält welche auf "Plugin.rsf" enden muss ... z.b. "SamplePlugin.rsf" ...
der inhalt dieser datei ist lediglich der volle class-name ...
wenn also deine SamplePlugin z.b. im package "something.plugins" liegt gehört in die rsf die zeile "something.plugins.SamplePlugins" ...

auch ist es dank der impl möglich methoden anderer plugins zu callen ...
dazu muss lediglich der volle class-name , der methoden-name sowie die methoden-parameter übergeben werden *entweder als Object-Array oder *dank der dynamischen programmierung* als einzelne parameter*

wenn "something.plugins.SamplePlugin" also z.b. die methode "machWas(int, Object)" der klasse "another.classes.AnotherPlugin" callen will sähe der aufruf so aus

pluginLoader.invoke("another.classes.AnotherPlugin", "machWas", 5, complexObjectReference);

das ganze wird dann im pluginloader wie zu sehen über reflections umgesetzt


wie gesagt ... das wäre jetzt mal so MEIN plugin-system als beispiel ...
ich selbst habe vor das ganze noch soweit zu ändern das man anstatt eines extra file einen manifest-eintrag verwendet um den zu ladenen klassen-namen zu bekommen ...
oder auch eine dynamische option WELCHE plugins überhaupt geladen werden sollen *für dich wichtig*
das könnte man z.b. so umsetzen das man den FilenameFilter ändert ...

ich hoffe ich kann dir damit wenigstens etwas helfen ...

 

[nethwa]

Also nen ganzes Plugin-System für ein einzelnes kleines Projekt zu schreiben wär nicht das richtige (zumal sich das mit dem Framwork beißen würde, mit dem ich arbeite [MASON-Framework für agentenbasierte Systeme]).
Ich werde erstmal probieren, dass ein jar-File alle Klassen aus einem Ordner mit einliest beim Start und das darüber zu machen.

Wenn ich eine galante Lösung gefunden habe schreib ich die hier noch rein^^

 

[irgendjemand]

Ich werde erstmal probieren, dass ein jar-File alle Klassen aus einem Ordner mit einliest beim Start und das darüber zu machen.

wie bereits gesagt ... DAS geht einfach in dem du ins MANIFEST folgende zeile schreibst

"Class-Path: plugins"

und dann alle klassen in den unter-ordner "plugins" packst ...

aber wie ich das so rausgelesen habe willst du ja eine selektive auswahl der klassen die überhaupt geladen werden ... und da wist du wohl um ein etwas größes konstrukt mit selektivem URLClassLoader bzw ServiceLoader nicht herumkommen ...

 

[nethwa]

wie bereits gesagt ... DAS geht einfach in dem du ins MANIFEST folgende zeile schreibst

"Class-Path: plugins"

und dann alle klassen in den unter-ordner "plugins" packst ...

Genau damit wollte ich das testen und erstmal verwenden.

aber wie ich das so rausgelesen habe willst du ja eine selektive auswahl der klassen die überhaupt geladen werden ... und da wist du wohl um ein etwas größes konstrukt mit selektivem URLClassLoader bzw ServiceLoader nicht herumkommen ...

Das wird erst bei größeren Mengen an Klassen und sehr komplizierten Algorithmen nötig, aber ich glaube nicht, dass das Programm so exzessiv genutzt werden wird, als dass das nötig wäre.

Danke auf jedenfall für die Hilfe an alle