Java-Programme durch PlugIns erweitern: Unterschied zwischen den Versionen

Aus Byte-Welt Wiki
Zur Navigation springenZur Suche springen
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>

Version vom 20. März 2010, 10:17 Uhr

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

Voraussetzungen

Als Voraussetzung für die Verwendung von Plugins sollten verschiedene Klassen und Interfaces vorhanden sein:

  1. Plugin-Interface - das die Plugins implementieren müssen. Hiermit wird festgelegt welche Funktionen das Plugin der Anwendung anbieten muss.
  2. Anwendung-Interface - das die Schnittstelle von den Plugins zur Anwendung darstellt, hiermit kann kontrolliert werden, was die Anwendungen dürfen und was sie sehen.
  3. Manager - gesonderte Klasse für das Laden, Starten und Beenden der Plugins.

Die Interfaces

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 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> package net.byte_welt.wiki; public interface PluginInterface{

 public boolean start();
 public boolean stop();
 public void setPluginManager(PluginManager manager);
 public void hello();

} </code=java> Zusätzlich wurde das Interface um die Methode hello erweitert, somit kann das Plugin von der Anwendung auch benachrichtigt werden.

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. <code=java> package net.byte_welt.wiki; public interface PluginManager{

 public void openWindow(String msg);

} </code=java> Unser Plugin-Manager erlaubt nur das Öffnen eines Fensters mit einem String als Nachricht.

Implementierungen

Durch die Interfaces muss für die Entwicklung des Plugins nur die Class- oder Java-Dateien weiter gegeben werden, die Implementierungen des PluginManagers dagegen nicht.

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 <code=java> package net.byte_welt.wiki; public class HelloPlugin implements PluginInterface{

 private PluginManager manager;
 public boolean start(){
   System.out.println("ich starte");
   return true;
 }
 public boolean stop(){
   System.out.println("ich stoppe");
   return true;
 }
 public void setPluginManager(PluginManager manager){
   this.manager = manager;
 }
 public void hello(){
   manager.openWindow("hallo");
 }

} </code=java>

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. <code=java> package net.byte_welt.wiki; import java.io.*; import java.util.jar.*; import java.net.*; public class PluginManagerImpl implements PluginManager{

 private Vector<PluginInterface> loadedplugins = new Vector<PluginInterface>();
 public void start(){
 ...
 }
 public void stop(){
 ...
 }
 public void loadPlugin(File file){
 ...
 }
 public void openWindow(String msg){
 ...
 }

} </code=java>

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. <code=java> public void start(){

 File[] files = new File("plugins").listFiles();
 for(File f:files)
   loadPlugin(f);
 for(PluginInterface pi:loadedplugins)
   pi.start();

} </code=java> Sind alle Plugins geladen werden sie gestartet.

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> public void stop(){

 for(PluginInterface pi:loadedplugins)
   pi.stop();

} </code=java>

LoadPlugin-Methode

Um Plugins zu laden, gibt es zwei Ansätze. Zum einen gibt es die Möglichkeit Class-Dateien aber auch JAR-Dateien zu 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. <code=java> //Erzeugen des JAR-Objekts JarFile file = new JarFile("Plugin.jar"); //Laden der MANIFEST.MF Manifest manifest = file.getManifest(); // auslesen der Attribute aus der Manifest Attributes attrib = manifest.getMainAttributes(); // holen der Mainclass aus den Attributen String main = attrib.getValue(Attributes.Name.MAIN_CLASS); </code=java>

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 erzeugt. <code=java> // laden der Klasse mit dem File als URL und der Mainclass Class cl = new URLClassLoader(new URL[]{new File("Plugin.jar").toURL()}).loadClass(main); // holen der Interfaces die die Klasse impementiert Class[] interfaces = cl.getInterfaces(); // Durchlaufen durch die Interfaces der Klasse und nachsehn ob es das passende Plugin implementiert boolean isplugin = false; for(int y = 0; y < interfaces.length && !isplugin; y++)

 if(interfaces[y].getName().equals("net.byte_welt.wiki.PluginInterface"))
   isplugin = true;

if(isplugin){

 PluginInterface plugin = (PluginInterface) cl.newInstance();
 loadedplugins.add(plugin);

} </code=java> 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.

Class-Dateien laden
  • wird nachgeliefert.


OpenWindow-Methode

Die openWindow-Methode ist für die Interaktion mit den Plugins nötig, über diese Methode kann ein Fenster geöffnet werden. <code=java> public void openWindow(String msg){

 javax.swing.JOptionPane.showMessageDialog(null, msg);

} </code=java>

Weblinks