Hi,

ich habe vor eine Art PlugIn-System zu schreiben.
Ich habe mich dabei an folgende Seite gehalten: http://www.javangelist.de/space/Plugin

In der META-INF/services stehen nun die Klassen drin, die geladen/unterstuetzt werden sollen.
Auf der Seite ist auch beschrieben, wie ich mittels Iterator zB durch alle Klassen gehen und Methoden aufrufen kann.
Komisch finde ich, dass in dem Beispiel eine nicht statische Funktion direkt über die Klasse (oder doch nicht?) aufgerufen wird.
Wie kann ich jetzt Objekte der geladenenen Klassen erstellen, oder ist das nicht moeglich?

Gruss
M_Kay

EDIT: Ich sehe gerade, dass es die schicke funktion Class.newInstance() gibt. Mal schauen

Hallo M_Kay,
ist je eine interssante Seite!, Früher habe ich mir so eine Art Klassenfinder aus alten Sourcen, die von "Weiß der Henker" kamen zusammen gebastelt.

Mal 'ne Blöde Frage: ist die Klasse Service in Java 6 eigetnlich immernoch im Paket sun.misc oder wurde da ein algemeineres Paket nun ersonnen? (habe da die Diskusion der Bug-Seite angesehen, da steht drauf fixed, aber nicht welches Paket)
Benötigt man eigetnlich, wenn man außerhalb des Klassenpfades Bibliotheken als Plugins anziehen will auch noch eine Datei in META-INF/service oder kann man sich die dann schenken?

mit neugierigen Grüßen

Takidoso

PS: hier ein Link der ähnliches diskutiert http://www.tutorials.de/forum/java/2...-programm.html

Hallo,

ich glaube du meinst hier den ServiceLoader...
schau mal hier:
http://www.tutorials.de/forum/java/3...m-problem.html

Gruß Tom

Argh, ich habe die Struktur meines (noch recht winzigen) Programms überarbeitet und schon will der keine Services mehr laden :X

Code :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

public static ArrayList<ProtocolDownload> loadDownloadProtocols() {         ArrayList<ProtocolDownload> pd = new ArrayList<ProtocolDownload>();                 Iterator iterator;         iterator = Service.providers(ProtocolDownload.class);                 while(iterator.hasNext()) {             ProtocolDownload dl = (ProtocolDownload) iterator.next();             pd.add(dl);                         //TODO entf             System.out.print(dl.getClass().getName());         }                 return pd;     }

Beim ersten Befehl in der While-Schleife bricht er mit folgendem Befehl ab:

Code :

1 2 3 4 5 6 7 8 9 10 11 12

Exception in thread "main" sun.misc.ServiceConfigurationError: mload.model.download.ProtocolDownload: Provider mload.model.download.protocols.HttpDownload could not be instantiated: java.lang.InstantiationException: mload.model.download.protocols.HttpDownload     at sun.misc.Service.fail(Service.java:120)     at sun.misc.Service.access$200(Service.java:111)     at sun.misc.Service$LazyIterator.next(Service.java:276)     at mload.model.Init.loadDownloadProtocols(Init.java:28)     at mload.controller.MLController.load(MLController.java:45)     at mload.MLoad.main(MLoad.java:24) Caused by: java.lang.InstantiationException: mload.model.download.protocols.HttpDownload     at java.lang.Class.newInstance0(Class.java:340)     at java.lang.Class.newInstance(Class.java:308)     at sun.misc.Service$LazyIterator.next(Service.java:271)     ... 3 more

Er findet scheinbar die gewünschte Klasse, doch kann ich mit der Fehlermeldung nichts anfangen (vorher hats doch funktioniert )

Kann mir jemand helfen?

Ok, es lag scheinbar daran, dass die Klasse, die geladen werden sollte, keinen Konstruktor ohne Parameter hatte (komisch, vorher hatte es funktioniert).

Gibt es eine Möglichkeit eben das zu erreichen? Also dass es mit Konstruktor funktionert, die Parameter enthalten?

Direkt geht das offenbar nicht mit sun.misc.Service ist aber ja recht leicht selber zu schreiben...

Lies halt die Datei die die Pluginnamen definieren selber per ClassLoader aus, lade die Klassen und erstelle entsprechende Instanzen mit den gewünschten Parametern.

Hi,

könntest du das evtl mit einem kleinen Beispiel erläutern?

Bisher habe ich halt die Klassen über die Service Methode geladen und später dann mit Klasse.getConstructor und Klasse.newInstance(param) die Instance mit Parametern erstellt.
Aber ich musste wie gesagt einen Konstruktor ohne Parameter erstellen, auch wenn dieser leer ist, da er sonst in der o.g. Schleife einen Fehler ausgibt.

Gruss
M_Kay

Soo... nun:

Das Interface:

Code java:

1 2 3 4 5 6 7

package de.tutorials;   public interface IPlugin {         public void print();   }

Eine Implementierung:

Code java:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

package de.tutorials.plugin;   import de.tutorials.IPlugin;   public class Plugin implements IPlugin {         private int i;     private String strg;       public Plugin(int i, String strg){         this.i = i;         this.strg = strg;     }       @Override     public void print() {         System.out.println(i + " " + strg);     }   }

Und nun das Laden:

Code java:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52

package de.tutorials;   import java.io.BufferedReader; import java.io.File; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; import java.net.URL; import java.net.URLClassLoader; import java.util.Enumeration;   public class PluginLoader {       public static void main(String[] args) throws Exception {         URLClassLoader loader = new URLClassLoader(new URL[] { new File(                 "Plugin.jar").toURI().toURL() });         final Enumeration<URL> findResources = loader                 .findResources("META-INF/services/plugins");         while (findResources.hasMoreElements()) {             final URL url = findResources.nextElement();             loadSpecifiedClasses(loader, url);         }                 reader.close();     }       private static void loadSpecifiedClasses(URLClassLoader loader,             final URL url) throws IOException, ClassNotFoundException,             NoSuchMethodException, InstantiationException,             IllegalAccessException, InvocationTargetException {         final InputStream stream = url.openStream();         BufferedReader reader = new BufferedReader(                 new InputStreamReader(stream));         String line = null;         while ((line = reader.readLine()) != null) {             loadClass(loader, line);         }     }       private static void loadClass(URLClassLoader loader, String className)             throws ClassNotFoundException, NoSuchMethodException,             InstantiationException, IllegalAccessException,             InvocationTargetException {         final Class<?> clss = loader.loadClass(className);         final Constructor<?> construct = clss.getConstructor(int.class,                 String.class);         final IPlugin newInstance = (IPlugin) construct.newInstance(1, "Hello");         newInstance.print();     }   }

Argh, ich bekomms nicht hin.
Die Klassen liegen ja in meinem Fall im Projekt selbst, nicht in einem externen jar.

Code :

1 2 3 4

URL thisurl = new File("./").toURI().toURL();             URLClassLoader loader = new URLClassLoader(new URL[] {thisurl});                         final URL findResources = loader.findResource("/META-INF/service/mload.model.download.ProtocolDownload");

Das möchte irgendwie nicht funktionieren
findResources ist bei mir aber immer null.

Kann mir jemand helfen?

Dann mach nen eigenes Jar von. Das macht ja keinen Sinn das Plugins in dem Hauptprojekt mit drinliegen...

Danach mußt du dich vergewissern dass in deinem Jar unter META-INF/services auch tatsächlich die gesucht Datei liegt. Diese heißt immer gleich. IN der Datei stehen dann die Namen der zu ladenden Plugins.

Hehe, doch, die "PlugIns" liegen im Hauptprogramm-Jar
Die Plugins sind also fest implementiert. Damit möchte ich erreichen, dass ich ohne größeren Aufwand die gleiche Funktionalität für eine andere Art von Objekten erstellen und das Programm gleich damit umgehen kann, ohne, dass ich im Source noch wild rumfummeln muss

Folgendermaßen funktioniert es:

Code :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

public static ArrayList<Class<?>> loadDownloadProtocols() {         ArrayList<Class<?>> pd = new ArrayList<Class<?>>();                 try {             URL url = ClassLoader.getSystemClassLoader().getResource("META-INF/services/mload.model.download.ProtocolDownload");             URLClassLoader loader = new URLClassLoader(new URL[] {url});                 final InputStream stream = url.openStream();             BufferedReader reader = new BufferedReader(new InputStreamReader(stream));             String line = null;                 while ((line = reader.readLine()) != null) {                     Class<?> cl = loader.loadClass(line);                 pd.add(cl);                 }         } catch (Exception exc) {}                   return pd;     }

Die Funktion liefert mir die entsprechenden verfügbaren Klassen, die in der o.g. Datei aufgelistet sind.
Das ließe sich zwar alles mit Service.providers einfacher lösen, aber der scheint automatisch eine Instanz über einen parameterlosen Konstruktor zu erzeugen.

Ich bin jetzt am überlegen, ob ich die Service.providers in Kombination mit einem Konstruktor-Ersatz nehme, da es dort doch recht einfach geht.
Die Methode mit dem Laden über einen extra ClassLoader bringt leider ein paar Probleme mit sich. Bspw muss ich die Klassen als Class-Objekt zwischenspeichern und kann nicht direkt angeben, dass es sich dabei um eine von Klasse xxx abgeleitete Klasse handelt. Oder doch?

Nun denk mal drüber nach was die Service Klasse wohl intern macht? Die lädt auch die Klassen, erstellt Instanzen und castet diese dann. Du würdest dann über den parameterlosen Konstruktor Klassen erstellen lassen welche du nie verwendest... das ist doch viel weniger schön.

Schreib dir doch eine eigene Klasse, kapsel das ganze genauso wie in der Service Klasse und dann ist gut.

Mir ist allerdings nicht ganz klar warum du dann diesen Aufwand treibst... Den URLClassloader kannst du auf jeden Fall weglassen und den SystemClassLoader weiter verwenden.

Aber genausogut könntest du dann doch auch im Code deine Klassen in einer Liste sammeln und sie dann so instanziieren. Dann fällt das mit dem ClassLoader schonmal ganz weg (Class.forName() würde reichen).

Durch eine andere Sache war ich nun gezwungen doch einen parameterlosen Konstruktor einzubauen. Deshalb bin ich jetzt bei der ServiceLoader-Methode geblieben

Gruss
M_Kay

Ich denke der Sinn der parameterlosen Konstruktoren (Default Constructors) ist, dass ein allgemeingültiger Lader nicht wirklich riechen kann welche Parameter ein Konstructor benötigt. Wenn doch, dann vermutlich mit imensen Aufwand. Es ist IMHO der gleiche Gedanke wie mit den Beans.

Was ich schade an dieser mittlerweile Standardlösung finde ist, dass man da noch eine extra file benötigt um die Klassen anzugeben. Schöner fände ich die Lösung, dass man ein nacktes JAR einfach in ein definiertes Verzeichnis wirft, welches dann nach allen den Klassen durchsucht wird welche die "Basisklasse" oder Interface implementieren.
Ok es kostet vielleicht ein wenig mehr Performance, aber praktischer wäre es doch, oder?

Kostest mehr Performance, erlaubt weniger Kontrolle aber ist irgendwie einfacher ja. Und eigentlich in ner halben Stunde selber zu schreiben....

Genauso kann man sich nen eigenen ServiceLoader schreiben dem man eine Factory Klasse übergibt die die Instanziierung von Klassen übernimmt die Parameter benötigen.