Java-Programme durch PlugIns erweitern - Versionsgeschichte

L-ectron-x: /* Weblinks */

2026-07-01T14:38:32Z

Weblinks

← Nächstältere Version		Version vom 1. Juli 2026, 14:38 Uhr
Zeile 216:		Zeile 216:

	=Weblinks=		=Weblinks=
	*[~~http~~://~~www.~~java-blog-buch.de/d-plugin-entwicklung-in-java/ Java Blog Buch: Plugin-Entwicklung in Java]		*[https://java-blog-buch.bytes4fun.de/d-plugin-entwicklung-in-java/ Java Blog Buch: Plugin-Entwicklung in Java]


	[[Kategorie:Tutorials (Java)]]		[[Kategorie:Tutorials (Java)]]
	[[Kategorie:Java]]		[[Kategorie:Java]]

Knyklak: Kommentare geändert, Code bearbeitet (Variablen ausgelagert), neuen Abschnitt mit gesamter Methode angelegt

2021-12-10T12:15:20Z

Kommentare geändert, Code bearbeitet (Variablen ausgelagert), neuen Abschnitt mit gesamter Methode angelegt

← Nächstältere Version		Version vom 10. Dezember 2021, 12:15 Uhr
Zeile 71:		Zeile 71:
	import java.util.jar.*;		import java.util.jar.*;
	import java.net.*;		import java.net.*;

	public class PluginManagerImpl implements PluginManager{		public class PluginManagerImpl implements PluginManager{

	private List<PluginInterface> loadedplugins = new ArrayLIst<>();		private List<PluginInterface> loadedplugins = new ArrayLIst<>();

	public void start(){		public void start(){
	...		//..
	}		}
	public void stop(){		public void stop(){
	...		//..
	}		}
	public void loadPlugin(File file){		public void loadPlugin(File file){
	...		//..
	}		}
	public void openWindow(String msg){		public void openWindow(String msg){
	...		//..
	}		}
	}		}
Zeile 115:		Zeile 118:
	Um ein Plugin aus einer JAR-Datei zu laden, muss deren Pfad und die [[Main-Class]] bekannt sein. Im Gegensatz zu einer normalen Anwendung ist die Main-Class bei einem Plugin die [[Klasse]], die das [[Interface]] für die Plugin-Schnittstelle implementiert. Es ist aber auch möglich, alle Klassen der JAR zu durchlaufen.		Um ein Plugin aus einer JAR-Datei zu laden, muss deren Pfad und die [[Main-Class]] bekannt sein. Im Gegensatz zu einer normalen Anwendung ist die Main-Class bei einem Plugin die [[Klasse]], die das [[Interface]] für die Plugin-Schnittstelle implementiert. Es ist aber auch möglich, alle Klassen der JAR zu durchlaufen.
	<syntaxhighlight lang="java">		<syntaxhighlight lang="java">
	//Erzeugen des JAR-Objekts		//Erzeugen des JAR-Objekts durch die Eingabe der eingelesenen File in file
	JarFile file = new JarFile(~~"Plugin.jar"~~);		JarFile file = new JarFile(file);
	//Laden der MANIFEST.MF		//Laden der MANIFEST.MF
	Manifest manifest = file.getManifest();		Manifest manifest = file.getManifest();
Zeile 127:		Zeile 130:
	Aus dem [[JAR-Datei#MANIFEST.MF\|Manifest]]-Objekt lassen sich jetzt beliebige Daten auslesen, jedoch werden hier nur die Informationen über die Main-Class benötigt. Mit diesen Daten lässt sich jetzt das Plugin laden, dazu wird ein neuer [[ClassLoader (Java) \|ClassLoader]] erzeugt.		Aus dem [[JAR-Datei#MANIFEST.MF\|Manifest]]-Objekt lassen sich jetzt beliebige Daten auslesen, jedoch werden hier nur die Informationen über die Main-Class benötigt. Mit diesen Daten lässt sich jetzt das Plugin laden, dazu wird ein neuer [[ClassLoader (Java) \|ClassLoader]] erzeugt.
	<syntaxhighlight lang="java">		<syntaxhighlight lang="java">
	// ~~laden~~ der ~~Klasse mit dem File als~~ URL ~~und~~ der ~~Mainclass~~		//Festlegen wo das PluginInterface liegt
	~~Class cl~~ = new URLClassLoader(new URL[]{~~new File("Plugin.jar").toURL()~~}).loadClass(main);		String PLUGININTERFACECLASS_STRING = "net.byte_welt.wiki.PluginInterface";
	// holen ~~der Interfaces~~ die ~~die Klasse~~ impementiert		// Laden der Datei und Konvertierung von einer Datei, zu einer URI und dann zu einer URL
			URL urlFile = file.toURI().toURL();
			// Laden der Klasse durch den URLClassLoader
			URLClassLoader classLoader = new URLClassLoader(new URL[] { urlFile });
			// Class aus dem classLoader holen
			Class cl = classLoader.loadClass(main);
			// Interfaces aus der Klasse holen, die dort impementiert sind
	Class[] interfaces = cl.getInterfaces();		Class[] interfaces = cl.getInterfaces();
	// Durchlaufen durch die Interfaces der Klasse und ~~nachsehn~~ ob es das passende Plugin implementiert		// Durchlaufen durch die Interfaces der Klasse und nachsehen ob es das passende Plugin implementiert
	boolean isplugin = false;		boolean isplugin = false;
	for(int y = 0; y < interfaces.length && !isplugin; y++)		for(int y = 0; y < interfaces.length && !isplugin; y++)
	if(interfaces[y].getName().equals(~~"net.byte_welt.wiki.PluginInterface"~~))		if(interfaces[y].getName().equals(PLUGININTERFACECLASS_STRING))
	isplugin = true;		isplugin = true;
	if(isplugin){		if(isplugin){
Zeile 140:		Zeile 149:
	loadedplugins.add(plugin);		loadedplugins.add(plugin);
	}		}

			//Schließen von JarFile und ClassLoader um Fehler zu vermeiden
			//jarFile.close();
			classLoader.close();
	</syntaxhighlight>		</syntaxhighlight>
	Anschließend werden die Interfaces der Klasse betrachtet, ob es sich wirklich um ein Plugin handelt. Ist es ein Plugin wird eine neue Instanz erzeugt und diese abgespeichert.		Anschließend werden die Interfaces der Klasse betrachtet, ob es sich wirklich um ein Plugin handelt. Ist es ein Plugin wird eine neue Instanz erzeugt und diese abgespeichert.

			=====JAR-Dateien laden (Die Methode komplett)=====
			Um ein Plugin aus einer JAR-Datei zu laden, muss deren Pfad und die [[Main-Class]] bekannt sein. Im Gegensatz zu einer normalen Anwendung ist die Main-Class bei einem Plugin die [[Klasse]], die das [[Interface]] für die Plugin-Schnittstelle implementiert. Es ist aber auch möglich, alle Klassen der JAR zu durchlaufen.
			<syntaxhighlight lang="java">

			//Festlegen wo das PluginInterface liegt
			private static final String PLUGININTERFACECLASS_STRING = "net.byte_welt.wiki.PluginInterface";

			public void loadPlugin(File file) {
			try {
			// Erzeugen des JAR-Objekts durch die Eingabe der eingelesenen File in file
			JarFile jarFile = new JarFile(file);
			// Laden der MANIFEST.MF
			Manifest manifest = jarFile.getManifest();
			// Auslesen der Attribute aus der Manifest-Datei
			Attributes attrib = manifest.getMainAttributes();
			// Mainclass aus den Attributen laden
			String main = attrib.getValue(Attributes.Name.MAIN_CLASS);
			// Laden der Datei und Konvertierung von einer Datei, zu einer URI und dann zu
			// einer URL
			URL urlFile = file.toURI().toURL();
			// Laden der Klasse durch den URLClassLoader
			URLClassLoader classLoader = new URLClassLoader(new URL[] { urlFile });
			// Class aus dem classLoader holen
			Class cl = classLoader.loadClass(main);
			// Interfaces aus der Klasse holen, die dort impementiert sind
			Class[] interfaces = cl.getInterfaces();
			// Durchlaufen durch die Interfaces der Klasse und nachsehen ob es das
			// PluginInterface implementiert und somit ein Plugin ist
			boolean isplugin = false;
			for (int y = 0; y < interfaces.length && !isplugin; y++)
			if (interfaces[y].getName().equals(PLUGININTERFACECLASS_STRING))
			isplugin = true;
			// Wenn es ein Plugin ist, dann lade die Datei bzw. das Plugin
			if (isplugin) {
			PluginInterface plugin = (PluginInterface) cl.newInstance();
			// Zu den geladenen Plugin hinzufügen
			loadedplugins.add(plugin);
			}
			// Schließen von JarFile und ClassLoader um Fehler zu vermeiden
			jarFile.close();
			classLoader.close();
			} catch (ClassNotFoundException \| InstantiationException \| IllegalAccessException \| IOException e) {
			System.out.println("Plugin konnte nicht geladen werden!");
			e.printStackTrace();
			}
			}
			</syntaxhighlight>

	=====Class-Dateien laden=====		=====Class-Dateien laden=====

L-ectron-X: /* PluginManager */

2018-11-03T10:00:28Z

PluginManager

← Nächstältere Version		Version vom 3. November 2018, 10:00 Uhr
Zeile 65:		Zeile 65:

	===PluginManager===		===PluginManager===
	Der Plugin-Manager kann für zwei Aufgaben verwendet werden. Er kann dem Plugin übergeben werden und zusätzlich kann er die Kontrolle der Plugins übernehmen. Unser Pluginmanager übernimmt beide Aufgaben, daher implementiert er das PluginManager-Interface. Zusätzlich werden die Methoden ''loadPlugin'', ''start'' und ''stop'' implementiert.		Der Plugin-Manager kann für zwei Aufgaben verwendet werden. Er kann dem Plugin übergeben werden und zusätzlich kann er die Kontrolle der Plugins übernehmen. Unser Pluginmanager übernimmt beide Aufgaben, daher implementiert er das PluginManager-Interface. Zusätzlich werden die [[Methode\|Methoden]] ''loadPlugin'', ''start'' und ''stop'' implementiert.
	<syntaxhighlight lang="java">		<syntaxhighlight lang="java">
	package net.byte_welt.wiki;		package net.byte_welt.wiki;
Zeile 72:		Zeile 72:
	import java.net.*;		import java.net.*;
	public class PluginManagerImpl implements PluginManager{		public class PluginManagerImpl implements PluginManager{
	private ~~Vector~~<PluginInterface> loadedplugins = new ~~Vector~~<~~PluginInterface~~>();		private List<PluginInterface> loadedplugins = new ArrayLIst<>();
	public void start(){		public void start(){
	...		...
Zeile 93:		Zeile 93:
	public void start(){		public void start(){
	File[] files = new File("plugins").listFiles();		File[] files = new File("plugins").listFiles();
	for(File f:files)		for(File f : files)
	loadPlugin(f);		loadPlugin(f);
	for(PluginInterface pi:loadedplugins)		for(PluginInterface pi : loadedplugins)
	pi.start();		pi.start();
	}		}
	</syntaxhighlight>		</syntaxhighlight>
	Sind alle Plugins geladen werden sie gestartet.		Sind alle Plugins geladen, werden sie gestartet.

	====Stop-Methode====		====Stop-Methode====
	Mit der ''stop''-Methode wird den Plugins signalisiert, dass sie ~~runterfahren~~ sollen. Dies ist der Fall, wenn z.B. das Programm beendet wird.<syntaxhighlight lang="java">		Mit der ''stop''-Methode wird den Plugins signalisiert, dass sie herunterfahren sollen. Dies ist der Fall, wenn z.B. das Programm beendet wird.<syntaxhighlight lang="java">
	public void stop(){		public void stop(){
	for(PluginInterface pi:loadedplugins)		for(PluginInterface pi : loadedplugins)
	pi.stop();		pi.stop();
	}		}
Zeile 110:		Zeile 110:

	====LoadPlugin-Methode====		====LoadPlugin-Methode====
	Um Plugins zu laden, gibt es zwei Ansätze. Zum einen gibt es die Möglichkeit [[Class-Datei]]en aber auch [[JAR-Datei]]en zu laden.		Um Plugins zu laden, gibt es zwei Ansätze. Zum einen gibt es die Möglichkeit [[Class-Datei\|Class-Dateien]] aber auch [[JAR-Datei\|JAR-Dateien]] zu laden.

	=====JAR-Dateien laden=====		=====JAR-Dateien laden=====
	Um ein Plugin aus einer JAR-Datei zu laden, muss deren Pfad und die Main-Class bekannt sein. Im Gegensatz zu einer normalen Anwendung ist die Main-Class bei einem Plugin die Klasse, die das Interface für die Plugin-Schnittstelle implementiert. Es ist aber auch möglich, alle Klassen der JAR zu durchlaufen.		Um ein Plugin aus einer JAR-Datei zu laden, muss deren Pfad und die [[Main-Class]] bekannt sein. Im Gegensatz zu einer normalen Anwendung ist die Main-Class bei einem Plugin die [[Klasse]], die das [[Interface]] für die Plugin-Schnittstelle implementiert. Es ist aber auch möglich, alle Klassen der JAR zu durchlaufen.
	<syntaxhighlight lang="java">		<syntaxhighlight lang="java">
	//Erzeugen des JAR-Objekts		//Erzeugen des JAR-Objekts
Zeile 125:		Zeile 125:
	</syntaxhighlight>		</syntaxhighlight>

	Aus dem Manifest-Objekt lassen sich jetzt beliebige Daten auslesen, jedoch werden hier nur die Informationen über die Main-Class benötigt. Mit diesen Daten lässt sich jetzt das Plugin laden, dazu wird ein neuer [[ClassLoader (Java) \|ClassLoader]] erzeugt.		Aus dem [[JAR-Datei#MANIFEST.MF\|Manifest]]-Objekt lassen sich jetzt beliebige Daten auslesen, jedoch werden hier nur die Informationen über die Main-Class benötigt. Mit diesen Daten lässt sich jetzt das Plugin laden, dazu wird ein neuer [[ClassLoader (Java) \|ClassLoader]] erzeugt.
	<syntaxhighlight lang="java">		<syntaxhighlight lang="java">
	// laden der Klasse mit dem File als URL und der Mainclass		// laden der Klasse mit dem File als URL und der Mainclass
Zeile 145:		Zeile 145:
	=====Class-Dateien laden=====		=====Class-Dateien laden=====
	* wird nachgeliefert.		* wird nachgeliefert.


	===OpenWindow-Methode===		===OpenWindow-Methode===

L-ectron-X am 8. März 2018 um 19:49 Uhr

2018-03-08T19:49:54Z

← Nächstältere Version		Version vom 8. März 2018, 19:49 Uhr
Zeile 17:		Zeile 17:
	===Das Plugin-Interface===		===Das Plugin-Interface===
	Das Interface für die Plugins muss keine Methoden (Markerinterface), kann aber auch beliebig viele definieren. Es hat sich bewärt, dass das Plugin-Interface mindestens zwei Methoden besitzt '''start()''' und '''stop()'''. Außerdem eine Methode um die Manager-Klasse zu setzen, sollte das Plugin auf irgendwelche Eigenschaften der Anwendung zugreifen können.		Das Interface für die Plugins muss keine Methoden (Markerinterface), kann aber auch beliebig viele definieren. Es hat sich bewärt, dass das Plugin-Interface mindestens zwei Methoden besitzt '''start()''' und '''stop()'''. Außerdem eine Methode um die Manager-Klasse zu setzen, sollte das Plugin auf irgendwelche Eigenschaften der Anwendung zugreifen können.
	<~~code~~=java>		<syntaxhighlight lang="java">
	package net.byte_welt.wiki;		package net.byte_welt.wiki;
	public interface PluginInterface{		public interface PluginInterface{
Zeile 25:		Zeile 25:
	public void hello();		public void hello();
	}		}
	</~~code=java~~>		</syntaxhighlight>
	Zusätzlich wurde das Interface um die Methode ''hello'' erweitert, somit kann das Plugin von der Anwendung auch benachrichtigt werden.		Zusätzlich wurde das Interface um die Methode ''hello'' erweitert, somit kann das Plugin von der Anwendung auch benachrichtigt werden.

	===Das PluginManager-Interface===		===Das PluginManager-Interface===
	Das Interface für den Pluginmanager bildet die Schnittstelle vom Plugin zur Anwendung. Hier werden alle Methoden aufgeführt die das Plugin aufrufen darf.		Das Interface für den Pluginmanager bildet die Schnittstelle vom Plugin zur Anwendung. Hier werden alle Methoden aufgeführt die das Plugin aufrufen darf.
	<~~code~~=java>		<syntaxhighlight lang="java">
	package net.byte_welt.wiki;		package net.byte_welt.wiki;
	public interface PluginManager{		public interface PluginManager{
	public void openWindow(String msg);		public void openWindow(String msg);
	}		}
	</~~code=java~~>		</syntaxhighlight>
	Unser Plugin-Manager erlaubt nur das Öffnen eines Fensters mit einem String als Nachricht.		Unser Plugin-Manager erlaubt nur das Öffnen eines Fensters mit einem String als Nachricht.

Zeile 43:		Zeile 43:
	===Hello-Plugin===		===Hello-Plugin===
	Unser Plugin soll beim Aufruf der ''hello()''-Methode nur ein Fenster öffnen und dort ''Hallo'' ausgeben, daher fällt die Implementierung sehr einfach aus. Die ''start()''- und ''stop()''-Methoden werden garnicht benötigt, würde der Text aus einer [[Datenbank]] oder [[Datei]] gelesen werden könnte dies in der ''start''-Methode erledigt werden		Unser Plugin soll beim Aufruf der ''hello()''-Methode nur ein Fenster öffnen und dort ''Hallo'' ausgeben, daher fällt die Implementierung sehr einfach aus. Die ''start()''- und ''stop()''-Methoden werden garnicht benötigt, würde der Text aus einer [[Datenbank]] oder [[Datei]] gelesen werden könnte dies in der ''start''-Methode erledigt werden
	<~~code~~=java>		<syntaxhighlight lang="java">
	package net.byte_welt.wiki;		package net.byte_welt.wiki;
	public class HelloPlugin implements PluginInterface{		public class HelloPlugin implements PluginInterface{
Zeile 62:		Zeile 62:
	}		}
	}		}
	</~~code=java~~>		</syntaxhighlight>

	===PluginManager===		===PluginManager===
	Der Plugin-Manager kann für zwei Aufgaben verwendet werden. Er kann dem Plugin übergeben werden und zusätzlich kann er die Kontrolle der Plugins übernehmen. Unser Pluginmanager übernimmt beide Aufgaben, daher implementiert er das PluginManager-Interface. Zusätzlich werden die Methoden ''loadPlugin'', ''start'' und ''stop'' implementiert.		Der Plugin-Manager kann für zwei Aufgaben verwendet werden. Er kann dem Plugin übergeben werden und zusätzlich kann er die Kontrolle der Plugins übernehmen. Unser Pluginmanager übernimmt beide Aufgaben, daher implementiert er das PluginManager-Interface. Zusätzlich werden die Methoden ''loadPlugin'', ''start'' und ''stop'' implementiert.
	<~~code~~=java>		<syntaxhighlight lang="java">
	package net.byte_welt.wiki;		package net.byte_welt.wiki;
	import java.io.*;		import java.io.*;
Zeile 86:		Zeile 86:
	}		}
	}		}
	</~~code=java~~>		</syntaxhighlight>

	====Start-Methode====		====Start-Methode====
	Die ''start''-Methode wird aufgerufen, wenn die Anwendung gestartet wird und alle vorhandenen Plugins geladen werden sollen. Die Pfade zu den vorhandenen Plugins lassen sich z.B. extra speichern, oder es wird gesagt, alles was im Ordner '''plugins''' liegt gilt als Plugin. In unserem Fall wird gesagt, was im Ordner '''plugins''' liegt wird geladen, dafür wird nur die ''loadPlugin''-Methode aufgerufen.		Die ''start''-Methode wird aufgerufen, wenn die Anwendung gestartet wird und alle vorhandenen Plugins geladen werden sollen. Die Pfade zu den vorhandenen Plugins lassen sich z.B. extra speichern, oder es wird gesagt, alles was im Ordner '''plugins''' liegt gilt als Plugin. In unserem Fall wird gesagt, was im Ordner '''plugins''' liegt wird geladen, dafür wird nur die ''loadPlugin''-Methode aufgerufen.
	<~~code~~=java>		<syntaxhighlight lang="java">
	public void start(){		public void start(){
	File[] files = new File("plugins").listFiles();		File[] files = new File("plugins").listFiles();
Zeile 98:		Zeile 98:
	pi.start();		pi.start();
	}		}
	</~~code=java~~>		</syntaxhighlight>
	Sind alle Plugins geladen werden sie gestartet.		Sind alle Plugins geladen werden sie gestartet.

	====Stop-Methode====		====Stop-Methode====
	Mit der ''stop''-Methode wird den Plugins signalisiert, dass sie runterfahren sollen. Dies ist der Fall, wenn z.B. das Programm beendet wird.<~~code~~=java>		Mit der ''stop''-Methode wird den Plugins signalisiert, dass sie runterfahren sollen. Dies ist der Fall, wenn z.B. das Programm beendet wird.<syntaxhighlight lang="java">
	public void stop(){		public void stop(){
	for(PluginInterface pi:loadedplugins)		for(PluginInterface pi:loadedplugins)
	pi.stop();		pi.stop();
	}		}
	</~~code=java~~>		</syntaxhighlight>

	====LoadPlugin-Methode====		====LoadPlugin-Methode====
Zeile 114:		Zeile 114:
	=====JAR-Dateien laden=====		=====JAR-Dateien laden=====
	Um ein Plugin aus einer JAR-Datei zu laden, muss deren Pfad und die Main-Class bekannt sein. Im Gegensatz zu einer normalen Anwendung ist die Main-Class bei einem Plugin die Klasse, die das Interface für die Plugin-Schnittstelle implementiert. Es ist aber auch möglich, alle Klassen der JAR zu durchlaufen.		Um ein Plugin aus einer JAR-Datei zu laden, muss deren Pfad und die Main-Class bekannt sein. Im Gegensatz zu einer normalen Anwendung ist die Main-Class bei einem Plugin die Klasse, die das Interface für die Plugin-Schnittstelle implementiert. Es ist aber auch möglich, alle Klassen der JAR zu durchlaufen.
	<~~code~~=java>		<syntaxhighlight lang="java">
	//Erzeugen des JAR-Objekts		//Erzeugen des JAR-Objekts
	JarFile file = new JarFile("Plugin.jar");		JarFile file = new JarFile("Plugin.jar");
Zeile 123:		Zeile 123:
	// holen der Mainclass aus den Attributen		// holen der Mainclass aus den Attributen
	String main = attrib.getValue(Attributes.Name.MAIN_CLASS);		String main = attrib.getValue(Attributes.Name.MAIN_CLASS);
	</~~code=java~~>		</syntaxhighlight>

	Aus dem Manifest-Objekt lassen sich jetzt beliebige Daten auslesen, jedoch werden hier nur die Informationen über die Main-Class benötigt. Mit diesen Daten lässt sich jetzt das Plugin laden, dazu wird ein neuer [[ClassLoader (Java) \|ClassLoader]] erzeugt.		Aus dem Manifest-Objekt lassen sich jetzt beliebige Daten auslesen, jedoch werden hier nur die Informationen über die Main-Class benötigt. Mit diesen Daten lässt sich jetzt das Plugin laden, dazu wird ein neuer [[ClassLoader (Java) \|ClassLoader]] erzeugt.
	<~~code~~=java>		<syntaxhighlight lang="java">
	// laden der Klasse mit dem File als URL und der Mainclass		// laden der Klasse mit dem File als URL und der Mainclass
	Class cl = new URLClassLoader(new URL[]{new File("Plugin.jar").toURL()}).loadClass(main);		Class cl = new URLClassLoader(new URL[]{new File("Plugin.jar").toURL()}).loadClass(main);
Zeile 140:		Zeile 140:
	loadedplugins.add(plugin);		loadedplugins.add(plugin);
	}		}
	</~~code=java~~>		</syntaxhighlight>
	Anschließend werden die Interfaces der Klasse betrachtet, ob es sich wirklich um ein Plugin handelt. Ist es ein Plugin wird eine neue Instanz erzeugt und diese abgespeichert.		Anschließend werden die Interfaces der Klasse betrachtet, ob es sich wirklich um ein Plugin handelt. Ist es ein Plugin wird eine neue Instanz erzeugt und diese abgespeichert.

Zeile 149:		Zeile 149:
	===OpenWindow-Methode===		===OpenWindow-Methode===
	Die ''openWindow''-Methode ist für die Interaktion mit den Plugins nötig, über diese Methode kann ein Fenster geöffnet werden.		Die ''openWindow''-Methode ist für die Interaktion mit den Plugins nötig, über diese Methode kann ein Fenster geöffnet werden.
	<~~code~~=java>		<syntaxhighlight lang="java">
	public void openWindow(String msg){		public void openWindow(String msg){
	javax.swing.JOptionPane.showMessageDialog(null, msg);		javax.swing.JOptionPane.showMessageDialog(null, msg);
	}		}
	</~~code=java~~>		</syntaxhighlight>

	=Weblinks=		=Weblinks=

L-ectron-x am 2. Juni 2012 um 15:40 Uhr

2012-06-02T15:40:06Z

← Nächstältere Version		Version vom 2. Juni 2012, 15:40 Uhr
Zeile 1:		Zeile 1:
			{\| align=center border=0 cellpadding=3 cellspacing=3 style="border: 1px solid #E0E0E0; background-color: #F8F8F8"
			\|-
			\| style="font-size: 90%" \| [[Bild:Unvollstaendig.png]] Dieser Artikel ist unvollständig. Hilf mit ihn zu verbessern, erweitere ihn oder beteilige dich an der Diskussion.
			\|}

	Damit [[Programm]]e leicht um neue Teile erweitert werden können, ist es hilfreich und komfortabel, diese mit einer [[Plugin]]-[[Schnittstelle]] auszustatten.		Damit [[Programm]]e leicht um neue Teile erweitert werden können, ist es hilfreich und komfortabel, diese mit einer [[Plugin]]-[[Schnittstelle]] auszustatten.

Zeile 152:		Zeile 157:
	=Weblinks=		=Weblinks=
	*[http://www.java-blog-buch.de/d-plugin-entwicklung-in-java/ Java Blog Buch: Plugin-Entwicklung in Java]		*[http://www.java-blog-buch.de/d-plugin-entwicklung-in-java/ Java Blog Buch: Plugin-Entwicklung in Java]

	~~{\| align=center border=0 cellpadding=3 cellspacing=3 style="border: 1px solid #E0E0E0; background-color: #F8F8F8"~~
	\|-
	~~\| style="font-size: 90%" \| [[Bild:Unvollstaendig.png]] Dieser Artikel ist unvollständig. Hilf mit ihn zu verbessern, erweitere ihn oder beteilige dich an der Diskussion.~~
	\|}


	~~<noinclude>[[Kategorie:Vorlagen]]</noinclude>~~


	[[Kategorie:Tutorials (Java)]]		[[Kategorie:Tutorials (Java)]]
	[[Kategorie:Java]]		[[Kategorie:Java]]

L-ectron-x am 2. Juni 2012 um 15:39 Uhr

2012-06-02T15:39:16Z

← Nächstältere Version		Version vom 2. Juni 2012, 15:39 Uhr
Zeile 152:		Zeile 152:
	=Weblinks=		=Weblinks=
	*[http://www.java-blog-buch.de/d-plugin-entwicklung-in-java/ Java Blog Buch: Plugin-Entwicklung in Java]		*[http://www.java-blog-buch.de/d-plugin-entwicklung-in-java/ Java Blog Buch: Plugin-Entwicklung in Java]

			{\| align=center border=0 cellpadding=3 cellspacing=3 style="border: 1px solid #E0E0E0; background-color: #F8F8F8"
			\|-
			\| style="font-size: 90%" \| [[Bild:Unvollstaendig.png]] Dieser Artikel ist unvollständig. Hilf mit ihn zu verbessern, erweitere ihn oder beteilige dich an der Diskussion.
			\|}


			<noinclude>[[Kategorie:Vorlagen]]</noinclude>


	[[Kategorie:Tutorials (Java)]]		[[Kategorie:Tutorials (Java)]]
	[[Kategorie:Java]]		[[Kategorie:Java]]

L-ectron-X: hat Java-Programm pluginfähig machen nach Java-Programme durch PlugIns erweitern verschoben

2010-04-04T09:34:11Z

hat Java-Programm pluginfähig machen nach Java-Programme durch PlugIns erweitern verschoben

← Nächstältere Version	Version vom 4. April 2010, 09:34 Uhr
(kein Unterschied)

L-ectron-X am 20. März 2010 um 10:17 Uhr

2010-03-20T10:17:59Z

← Nächstältere Version		Version vom 20. März 2010, 10:17 Uhr
Zeile 1:		Zeile 1:
	Damit [[Programm]]e leicht um neue Teile erweitert werden können, ist es hilfreich diese mit einer [[Plugin]]-[[Schnittstelle]] auszustatten.		Damit [[Programm]]e leicht um neue Teile erweitert werden können, ist es hilfreich und komfortabel, diese mit einer [[Plugin]]-[[Schnittstelle]] auszustatten.

	==Voraussetzungen==		==Voraussetzungen==
	Als Voraussetzung für die Verwendung von Plugins sollten verschiedene [[Klasse]]n und [[Interface (Java) \| Interface]]s vorhanden sein:		Als Voraussetzung für die Verwendung von Plugins sollten verschiedene [[Klasse]]n und [[Interface (Java) \| Interface]]s vorhanden sein:
	# '''Plugin-Interface''' - das die Plugins implementieren müssen. Hiermit wird festgelegt welche Funktionen das Plugin der Anwendung anbieten muss.		# '''Plugin-Interface''' - das die Plugins implementieren müssen. Hiermit wird festgelegt welche Funktionen das Plugin der Anwendung anbieten muss.
	# '''Anwendung-Interface''' - das die Schnittstelle von den Plugins zur [[Anwendung]] darstellt, hiermit kann kontrolliert werden was die Anwendungen dürfen und was sie sehen.		# '''Anwendung-Interface''' - das die Schnittstelle von den Plugins zur [[Anwendung]] darstellt, hiermit kann kontrolliert werden, was die Anwendungen dürfen und was sie sehen.
	# '''Manager''' - gesonderte Klasse für das Laden, Starten und Beenden der Plugins.		# '''Manager''' - gesonderte Klasse für das Laden, Starten und Beenden der Plugins.

	==Die Interfaces==		==Die Interfaces==
	Das gesamte Plugin-System könnte auch ohne Interfaces geschrieben werden, jedoch ist dies unsicherer. ~~Weil wenn dafür~~ die Klassen der Anwendung ~~eingebunden werden müssen und mit [[Entwicklungsumgebung]]en wie [[Eclipse]] kann der [[Programmierer]]~~ alle [[Methoden~~]] sehen und auf diese zugreifen~~. ~~Die Interfaces schließen dies nicht aus aber bilden~~ eine ~~saubere Trennung~~.		Das gesamte Plugin-System könnte auch ohne Interfaces geschrieben werden, jedoch ist dies unsicherer. Interfaces standardisieren durch vordefinierte Methoden die Entwicklung und Verwendung von Klassen, was innerhalb der Anwendung sicher stellt, dass nachgerüstete Klassen alle benötigten Methoden bereit stellen. Dadurch ist mit einfachen Mitteln eine gewisse Vielgestaltigkeit möglich.

	===Das Plugin-Interface===		===Das Plugin-Interface===
	Das Interface für die Plugins ~~kann~~ keine Methoden ~~umfassen~~, aber auch viele ~~verschiedene~~. Es ~~sollte nach meiner derzeitigen Auffassung jedoch immer~~ zwei Methoden ~~besitzen~~ '''start''' und '''stop'''. Außerdem eine Methode um die Manager-Klasse zu setzen, sollte das Plugin auf irgendwelche Eigenschaften der Anwendung zugreifen können.		Das Interface für die Plugins muss keine Methoden (Markerinterface), kann aber auch beliebig viele definieren. Es hat sich bewärt, dass das Plugin-Interface mindestens zwei Methoden besitzt '''start()''' und '''stop()'''. Außerdem eine Methode um die Manager-Klasse zu setzen, sollte das Plugin auf irgendwelche Eigenschaften der Anwendung zugreifen können.
	<code=java>		<code=java>
	package net.byte_welt.wiki;		package net.byte_welt.wiki;
Zeile 24:		Zeile 24:

	===Das PluginManager-Interface===		===Das PluginManager-Interface===
	Das Interface für den Pluginmanager bildet die Schnittstelle vom Plugin zur Anwendung~~, hier~~ werden alle Methoden aufgeführt die das Plugin aufrufen darf.		Das Interface für den Pluginmanager bildet die Schnittstelle vom Plugin zur Anwendung. Hier werden alle Methoden aufgeführt die das Plugin aufrufen darf.
	<code=java>		<code=java>
	package net.byte_welt.wiki;		package net.byte_welt.wiki;
Zeile 31:		Zeile 31:
	}		}
	</code=java>		</code=java>
	Unser ~~Pluginmanager~~ erlaubt nur das Öffnen eines Fensters mit einem String als Nachricht.		Unser Plugin-Manager erlaubt nur das Öffnen eines Fensters mit einem String als Nachricht.

	==Implementierungen==		==Implementierungen==
Zeile 60:		Zeile 60:

	===PluginManager===		===PluginManager===
	Der ~~Pluginmanager~~ kann für zwei Aufgaben verwendet werden~~, einmal~~ kann er dem Plugin übergeben werden und zusätzlich kann er die Kontrolle der Plugins übernehmen. Unser Pluginmanager übernimmt beide Aufgaben, daher implementiert er das PluginManager-Interface. Zusätzlich werden die Methoden ''loadPlugin'', ''start'' und ''stop'' implementiert.		Der Plugin-Manager kann für zwei Aufgaben verwendet werden. Er kann dem Plugin übergeben werden und zusätzlich kann er die Kontrolle der Plugins übernehmen. Unser Pluginmanager übernimmt beide Aufgaben, daher implementiert er das PluginManager-Interface. Zusätzlich werden die Methoden ''loadPlugin'', ''start'' und ''stop'' implementiert.
	<code=java>		<code=java>
	package net.byte_welt.wiki;		package net.byte_welt.wiki;
Zeile 84:		Zeile 84:

	====Start-Methode====		====Start-Methode====
	Die ''start''-Methode wird aufgerufen, wenn die Anwendung gestartet wird und alle vorhandenen Plugins geladen werden sollen. Die Pfade zu den vorhandenen Plugins lassen sich z.B. extra speichern oder es wird gesagt alles was im Ordner '''plugins''' liegt gilt als Plugin. In unserem Fall wird gesagt was im Ordner '''plugins''' liegt wird geladen, dafür wird nur die ''loadPlugin''-Methode aufgerufen.		Die ''start''-Methode wird aufgerufen, wenn die Anwendung gestartet wird und alle vorhandenen Plugins geladen werden sollen. Die Pfade zu den vorhandenen Plugins lassen sich z.B. extra speichern, oder es wird gesagt, alles was im Ordner '''plugins''' liegt gilt als Plugin. In unserem Fall wird gesagt, was im Ordner '''plugins''' liegt wird geladen, dafür wird nur die ''loadPlugin''-Methode aufgerufen.
	<code=java>		<code=java>
	public void start(){		public void start(){
Zeile 105:		Zeile 105:

	====LoadPlugin-Methode====		====LoadPlugin-Methode====
	Um Plugins zu laden gibt es zwei Ansätze~~, zum~~ einen gibt es die Möglichkeit [[Class-Datei]]en aber auch [[JAR-Datei]]en zu laden.		Um Plugins zu laden, gibt es zwei Ansätze. Zum einen gibt es die Möglichkeit [[Class-Datei]]en aber auch [[JAR-Datei]]en zu laden.

	=====JAR-Dateien laden=====		=====JAR-Dateien laden=====
	Um ein Plugin aus einer JAR-Datei zu laden muss deren Pfad und die ~~Mainclass~~ bekannt sein. Im Gegensatz zu einer normalen Anwendung ist die ~~Mainclass~~ bei einem Plugin die Klasse, die das Interface für die ~~Pluginschnittstelle~~ implementiert. Es ist aber auch ~~Möglich~~ alle Klassen der JAR ~~durchzulaufen~~.		Um ein Plugin aus einer JAR-Datei zu laden, muss deren Pfad und die Main-Class bekannt sein. Im Gegensatz zu einer normalen Anwendung ist die Main-Class bei einem Plugin die Klasse, die das Interface für die Plugin-Schnittstelle implementiert. Es ist aber auch möglich, alle Klassen der JAR zu durchlaufen.
	<code=java>		<code=java>
	//Erzeugen des JAR-Objekts		//Erzeugen des JAR-Objekts
Zeile 120:		Zeile 120:
	</code=java>		</code=java>

	Aus dem Manifest-Objekt lassen sich jetzt beliebige Daten auslesen, jedoch werden hier nur die Informationen über die ~~Mainclass~~ benötigt. Mit diesen Daten lässt sich jetzt das Plugin laden, dazu wird ein neuer [[ClassLoader (Java) \|ClassLoader]] erzeugt.		Aus dem Manifest-Objekt lassen sich jetzt beliebige Daten auslesen, jedoch werden hier nur die Informationen über die Main-Class benötigt. Mit diesen Daten lässt sich jetzt das Plugin laden, dazu wird ein neuer [[ClassLoader (Java) \|ClassLoader]] erzeugt.
	<code=java>		<code=java>
	// laden der Klasse mit dem File als URL und der Mainclass		// laden der Klasse mit dem File als URL und der Mainclass
Zeile 139:		Zeile 139:

	=====Class-Dateien laden=====		=====Class-Dateien laden=====
	* ~~Da muss ich gerade passen das hab ich noch nicht ausprobiert, das sollte ähnlich wie mit den JAR Dateien laufen~~.		* wird nachgeliefert.


	===OpenWindow-Methode===		===OpenWindow-Methode===
	Die ''openWindow''-Methode ist für die Interaktion mit den Plugins, ~~sie können~~ über diese Methode ein Fenster ~~öffnen lassen~~.		Die ''openWindow''-Methode ist für die Interaktion mit den Plugins nötig, über diese Methode kann ein Fenster geöffnet werden.
	<code=java>		<code=java>
	public void openWindow(String msg){		public void openWindow(String msg){
	javax.swing.JOptionPane.showMessageDialog(null,msg);		javax.swing.JOptionPane.showMessageDialog(null, msg);
	}		}
	</code=java>		</code=java>

Jango am 14. März 2010 um 09:32 Uhr

2010-03-14T09:32:08Z

← Nächstältere Version		Version vom 14. März 2010, 09:32 Uhr
Zeile 149:		Zeile 149:
	}		}
	</code=java>		</code=java>
	~~[[Kategorie:Tutorials (Java)]]~~
	~~[[Kategorie:Java]]~~

	=Weblinks=		=Weblinks=
	*[http://www.java-blog-buch.de/d-plugin-entwicklung-in-java/ Java Blog Buch: Plugin-Entwicklung in Java]		*[http://www.java-blog-buch.de/d-plugin-entwicklung-in-java/ Java Blog Buch: Plugin-Entwicklung in Java]


			[[Kategorie:Tutorials (Java)]]
			[[Kategorie:Java]]

Pcworld: +Java-Blog-Buch-Link

2010-03-13T15:43:27Z

+Java-Blog-Buch-Link

← Nächstältere Version		Version vom 13. März 2010, 15:43 Uhr
Zeile 151:		Zeile 151:
	[[Kategorie:Tutorials (Java)]]		[[Kategorie:Tutorials (Java)]]
	[[Kategorie:Java]]		[[Kategorie:Java]]

			=Weblinks=
			*[http://www.java-blog-buch.de/d-plugin-entwicklung-in-java/ Java Blog Buch: Plugin-Entwicklung in Java]