Bearbeiten von „Java-Programme durch PlugIns erweitern“

{| 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.

==Voraussetzungen==
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.
# '''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.

==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.
<syntaxhighlight lang="java">
package net.byte_welt.wiki;
public interface PluginInterface{
  public boolean start();
  public boolean stop();
  public void setPluginManager(PluginManager manager);
  public void hello();
}
</syntaxhighlight>
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.
<syntaxhighlight lang="java">
package net.byte_welt.wiki;
public interface PluginManager{
  public void openWindow(String msg);
}
</syntaxhighlight>
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-Datei | Class]]- oder [[Java-Dateien]] weiter gegeben  werden, die [[Implementierung]]en 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
<syntaxhighlight lang="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");
  }
}
</syntaxhighlight>

===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 [[Methode|Methoden]] ''loadPlugin'', ''start'' und ''stop'' implementiert.
<syntaxhighlight lang="java">
package net.byte_welt.wiki;
import java.io.*;
import java.util.jar.*;
import java.net.*;

public class PluginManagerImpl implements PluginManager{

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

  public void start(){
  //..
  }
  public void stop(){
  //..
  }
  public void loadPlugin(File file){
  //..
  }
  public void openWindow(String msg){
  //..
  }
}
</syntaxhighlight>

====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.
<syntaxhighlight lang="java">
public void start(){
  File[] files = new File("plugins").listFiles();
  for(File f : files)
    loadPlugin(f);
  for(PluginInterface pi : loadedplugins)
    pi.start();
}
</syntaxhighlight>
Sind alle Plugins geladen, werden sie gestartet.

====Stop-Methode====
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(){
  for(PluginInterface pi : loadedplugins)
    pi.stop();
}
</syntaxhighlight>

====LoadPlugin-Methode====
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=====
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">
//Erzeugen des JAR-Objekts durch die Eingabe der eingelesenen File in file
JarFile file = new JarFile(file);
//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);
</syntaxhighlight>

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">
//Festlegen wo das PluginInterface liegt
String PLUGININTERFACECLASS_STRING = "net.byte_welt.wiki.PluginInterface";
// 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 passende Plugin implementiert
boolean isplugin = false;
for(int y = 0; y < interfaces.length && !isplugin; y++)
  if(interfaces[y].getName().equals(PLUGININTERFACECLASS_STRING))
    isplugin = true;
if(isplugin){
  PluginInterface plugin = (PluginInterface) cl.newInstance();
  loadedplugins.add(plugin);
}

//Schließen von JarFile und ClassLoader um Fehler zu vermeiden
//jarFile.close();
classLoader.close();
</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.

=====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=====
* 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.
<syntaxhighlight lang="java">
public void openWindow(String msg){
  javax.swing.JOptionPane.showMessageDialog(null, msg);
}
</syntaxhighlight>

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


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