Java Plugin schreiben

[BlubBlub]

Hi,

ich versuche ein Programm "FunnyFunctions" zu schreiben, welches erlaubt weitere Funktionen zu integrieren.

Ich habe also, das Hauptprogramm "FunnyFunctions".
Zudem habe ich einen Ordner namens "External".
In den Ordner "External" soll ein Dritter eine ".class" Datei ablegen können,
deren Funktionalität beim starten des Hauptprogramms zur Verfügung steht.

Ich sage also, dass jede ".class" Datei ein bestimmtes Interface implementieren muss,
mit den Funktionen die dem Hauptprogramm später zur Verfügung stehen sollen.
Die neue Klasse wird dynamisch über einen URLClassLoader geladen.

Allerdings habe ich ein Problem. Sowohl das Hauptprogramm als auch die neue Klasse
müssen das Interface kennen. Somit muss man jedes mal von Hand den ClassPath setzen zu dem Pfad wo sich das Interface befindet. Dies ist jedoch recht mühselig.

Mein Ziel ist es, dass ein unerfahrener Benutzer sich von irgendwo her die neue Klasse in Form einer ".class" Datei holt oder runterlädt und diese lediglich in einen bestimmten Ordner, in diesem Fall in den Ordner "External" einfügt. Anschließend soll beim Ausführen des Hauptprogramm die neue Funktionalität zur Verfügung stehen.

Frage: Wie schaffe ich es ohne immer wieder den ClassPath selbst setzen zu müssen das Interface sowohl dem Hauptprogramm als auch der neuen Klasse bekannt zu machen?

Ich habe auch einen recht interessanten Artikel gefunden zum Erstellen von Java Plugins gefunden Java Blog Buch : D) Plugin-Entwicklung in Java. Jedoch wird da immer der ClassPath von Hand gesetzt, was ich ja vermeiden will.

Damit diese beiden Klassen als Schnittstelle zwischen Plugin und Programm agieren können, müssen sowohl die Plugins, als auch die Anwendung selbst, diese beiden Interfaces kennen. Es bietet sich also an, ein eigenes PluginInterface.jar zu erstellen, welches aus dem PluginManager und dem Pluggable Interface besteht. Dieses JAR muss dann während der Entwicklung der Applikation und der Plugins als Classpath-Eintrag zur Verfügung stehen. Das Programm selbst benötigt die Schnittstelle natürlich auch beim Ausführen.

 

[faetzminator]

Wieso ist das mühsam? Es ist normal, das beide die Schnittstelle kennen müssen, ansonsten könnten sie gar nicht miteinander kommunizieren!
Aber es gäb da noch den hässlichen Weg, dass du einfach die Methoden (des nicht vorhandenen Interfaces) per Reflection aufrufen kannst. Die Klasse muss natürlich trotzdem all diese Methoden implementieren, auch wenn sie nicht vom Interface erbt.

 

[bygones]

du benutzt doch schon den URLClassLoader - warum soll der fuer deine Idee nicht nutzbar sein ?!

um die "plugins" zu laden brauchst du gar nix von hand machen. ueber den URLClassLoader kannst du sie einfach alle reinladen

 

[BlubBlub]

Wieso ist das mühsam? Es ist normal, dass beide die Schnittstelle kennen müssen, ansonsten könnten sie gar nicht miteinander kommunizieren!

Dass beide die Schnittstellen kennen müssen versteh ich ja. Aber ich denke halt, dass die meisten Benutzer, die nur Grundkenntnise besitzen, Probleme haben werden den Classpath zu setzen.
Darum fänd ichs halt gut wenn der Benutzer so wenig wie möglich machen muss. Am besten wärs, wenn die ".class" Datei in einen bestimmten Ordner einfügt werden müsste. Die meisten Benutzer werden mit dem Begriff Classpath sicherlich Schwierigkeiten haben.

Den Classpath bei dem Hauptprogramm könnte ich ja noch selbst setzen, indem ich mein Hauptprogramm in einer Jar Datei packe und in der Manifest Datei den Classpath zur Interface ".class" Datei erstelle, glaube ich. Bin mir da aber nicht ganz sicher, das muss ich erstmal ausprobieren.

du benutzt doch schon den URLClassLoader - warum soll der fuer deine Idee nicht nutzbar sein ?!

Ich verwende den URLClassLoader um ein Objekt zu laden, dessen Klasse ein bestimmtes Interface implementiert.
Das Problem welches Auftritt, wenn ich den ClassPath zur "Interface.class" Datei nicht setze, ist dass
das Objekt welches über den URLClassLoader geladen wird einen NoClassDefFoundError auslösen wird. Dies liegt daran, dass die externe Klasse fogelndes stehen hat "public MyClass implements AnInterface". Sie muss also wissen, wo sich das Interface befindet. Eine Import Anweisung ist ja nicht möglich, da sowohl das Hauptprogramm, als auch die Neue Klasse auf dieselbe ".class" Datei also auf dieselbe Interface Definition zugreifen müssen. Das Interface wird sich aber in der jar. Datei zusammen mit dem Hauptprogramm befindent. Die externe Klasse befindet sich aber in einem Ordner außerhalb der jar Datei. Ich denke das ist jetzt etwas schwer verständlich beschrieben, dass genau Problem habe ich beschrieben beim letzten Eintrag von mir: dynamische-erzeugung-objektes

 

[faetzminator]

Na dann musst du dem Classloader das Interface präsentieren. Aber das sollte ihm so oder so schon bekannt sein, da du das Interface in deinem Hauptprogramm lädst. Das könntest du mit einem ClassLoader (Java Platform SE 6) testen.

 

[bygones]

ich glaub ich versteh das nicht so recht.

Du hast ein Projekt in welchem du eine API fuer andere Entwickler bereitstellst. Damit diese entwickeln koennen bietest du zb ein jar an, welches sie in ihr projekt einsetzen muessen (oder du haust ihnen alles ihn, was nicht sehr gut waere)

Sie haben dann ihr Projekt/Klasse entwickelt und legen das nun in Ordner x ab.

Dein Programm was ja im jar liegt hat seinen Classpath definiert damit es an sich startet. Zusaetzlich laedt es sich per URLClassloader den entsprechenden Ordner.

Was ist das Problem?

 

[BlubBlub]

Kurz worums geht: Es wird ein java.lang.NoClassDefFoundError geschmissen.
Der Fehler liegt meiner Meinung daran, dass ich die Klasse aus einem anderen
Ordner versuche zu laden die ein Interface implementiert. Dieses Interface liegt
aber nicht in dem Ordner wo die zu ladende Klasse liegt.

Was mir am meisten helfen würde, ist wenn ihr euch diesen Beispielcode anschaut und mir anhand dessen sagt was ich da genau zu ändern habe damit es funktioniert.

Fehlermeldung:
java.lang.NoClassDefFoundError: ExternalFunction


Kurze Beschreibung:
Auf dem Desktop habe ich zwei Ordner:
Ordner: "One"
Ordner: "Two"

Diese haben folgenden Aufbau:

One
  |--------- interfaces
  |                 |------------- ExternalFunction.java
  |                 |------------- ExternalFunction.class
  |
  |--------- starter
                    |------------- Starter.java
                    |------------- Starter.class
 
Two
  |---------- MyExternalClass.java
  |---------- MyExternalClass.class

package starter;
 
import interfaces.ExternalFunction;
 
import java.io.File;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
 
public class Starter 
{
    public static void main(String[] args)
    {
        try 
        {             
            URL urls = new URL("file:\\\\\\C:\\Users\\Ich\\Desktop\\Two\\");
            URL[] classpath = {urls};
            URLClassLoader urlClassLoader = new URLClassLoader(classpath);
            Class<?> clazz = urlClassLoader.loadClass("MyExternalClass");  //Hier wird der Fehler geschmissen
            Object object = clazz.newInstance();
            ExternalFunction externalFunction = (ExternalFunction)object;
            externalFunction.doSomething();
        }
        catch (MalformedURLException e)
        {
            e.printStackTrace();
        } 
        catch (ClassNotFoundException e)
        {
            e.printStackTrace();
        }
        catch (InstantiationException e)
        {
            e.printStackTrace();
        } 
        catch (IllegalAccessException e)
        {
            e.printStackTrace();
        }
    }
}

package interfaces;
 
public interface ExternalFunction 
{
    public String doSomething();
    public String getDescription();
}

public class MyExternalClass implements ExternalFunction
{
    public MyExternalClass(){}
     
    @Override
    public String doSomething()
    {
        System.out.println("MyExternalClass doSomething");
        return null;
    }
 
    @Override
    public String getDescription() 
    {
        String description = "MyExternalClass Description";
        return description;
    }
}

Ziel: Wie oben beschrieben. Der Benutzer soll eine Klasse welche das "ExternalFunction" Interface implementiert in den Ordner "Two" legen. Das Hauptprogramm also die "Starter" Klasse starten und dann soll die Methode der externen Klasse aufgerufen werden.

 

[BlubBlub]

Um keine Missverständisse hervorzurufen. Das Programm über mir funktioniert.
Aber nur unter der Bedigung, dass ich beim Compilieren der Externenen Klasse den Classpath dahin setze
wo sich das Interface befindet.

Wenn ich also eine neue Klasse schreiben, wie diese hier:

public class MyExternalClass implements ExternalFunction
{
    public MyExternalClass(){}
     
    @Override
    public String doSomething()
    {
        System.out.println("MyExternalClass doSomething");
        return null;
    }
 
    @Override
    public String getDescription() 
    {
        String description = "MyExternalClass Description";
        return description;
    }
}

Dann muss ich sie so compilieren in der windows Konsole:
C:\Users\Ich\Desktop\Two> javac -classpath C:\Users\Ich\Desktop\One MyExternalClass

So funktioniert dann alles prima. Den Classpath muss ich also setzen da sich das Interface "ExternalFunction" an einer ganz anderen Stelle befindet, nämlich im Ordner One (siehe meinen darüberliegenden Eintrag).

Mein Ziel ist es, aber dass man
-classpath C:\Users\Ich\Desktop\One
NICHT extra eingeben muss.
Denn wenn ein Dritter ein neues Plugin (also eine Neue Klasse die das Interface ExternalFunction implementiert) schreibt und er nicht im Besitz des Hauptprogramms ist, dann kann er seine Klasse nicht kompilieren. Denn beim kompilieren würde der Compiler sagen, dass er das Interface "ExternalFunction" nicht kennt.
Ich möchter aber, dass der Dritte ohne den Code des Hauptprogramm eine Klasse schreibe kann, die das Interface implementiert und anschließend die compilierte Version an jemanden per Email oder USBStick gibt, der das Hauptprogramm besitzt. Der jemand der die ".class" Datei dann erhalten hat, legt diese dann nur noch in den entsprechenden Ordner und schon ist das Hauptprogramm um ein Plugin reicher.

 

[Gast2]

Beim Kompilieren der Klasse MUSS das Interface dem Compiler bekannt sein. In der Regel verpackt man sowas in nen

meineApp-api.jar

file, dass man dann den Entwicklern mit ausliefert damit die ihre Plugins kompilieren können.
In dem

meineApp-api.jar

File würde dann unter anderem dein Interface liegen.

 

[BlubBlub]

*spam entfertn*

Beim Kompilieren der Klasse MUSS das Interface dem Compiler bekannt sein. In der Regel verpackt man sowas in nen meineApp-api.jar file, dass man dann den Entwicklern mit ausliefert damit die ihre Plugins kompilieren können.
In dem meineApp-api.jar File würde dann unter anderem dein Interface liegen.

Die schaffe ich zu realisieren. Also ist das der gängige Weg wie man Plugins erstellt?

 

[Gast2]

Der gängiste weg ist etwas fertiges zu nutzen, wie zum Beispiel OSGi. Das kann zwar etwas mehr als das was du willst, aber plugins sind da kein Problem.

 

[BlubBlub]

okay danke für die tipps