[beny_mcde]

hallo allerseits. bingerade dabei mir gedanken zu einer plugin engine zu machen.
das ganze soll generisch sein, d.h. in verschiedenen anwendungen einsetzbar zu sein.

die plugins sollen beim starten nicht im klassenpfad aufgenommen werden müssen, d.h. die klassen eines plugins werden später über einen URLClassLoader oder einem eigenbau geladen.

es soll abhängigkeiten zwischen den plugins geben können.
also plugin2 verwendet klassen aus plugin1

das ist ja alles kein problem aber um dann klassen aus einem plugin in einem anderm zu instanzieren muss man sie immer beim PluginClassLoader bestellen.

package bs.plugin2;

 public class KlasseVonPlugin2{
 public KlasseVonPlugin2(){
   PluginClassLoader loader = PluginClassLoader.getInstance();
   Class clazz = loader.loadClass("bs.plugin1.KlasseVonPlugin1");
   KlasseVonPlugin1 instance = clazz.newInstance();
 }
}

das finde ich irgendwie zu umständlich.
da zu kompilierzeit die benötigten plugins ja zur verfügung stehen währe es schön wenn man das ganze etwa wie folgt schreiben könnte.

package bs.plugin2;

import bs.plugin1.*;

 public class KlasseVonPlugin2{
 public KlasseVonPlugin2(){
   KlasseVonPlugin1 instance = new KlasseVonPlugin1();
 }
}

wie setzt man das jetzt um? es gibt ja seit einigen versionen für jeden thread einen eigenen context ClassLoader der für alle ladevorgänge im thread zuständig ist. wird aus diesem thread eine neuer thread erzeugt erhällt dieser den selben ClassLoader.

meine idee war also am anfang dem mainthread einen context ClassLoader zuzuweisen der im stande ist pluginklassen zu laden.
nur irgendwie funktioniert das nicht richtig, da die findClass methode des contextclassloaders nicht aufgerufen wird sondern gleich einen ClassNotFoundException fliegt.

was ist falsch an der sache? oder geht das überhaupt garnicht?
im schlimmsten fall müsste ich ja beim starten der VM einen selbstgeschriebenen SystemClassLoader mitgeben aber das wird sicher umständlich.

hoffe ihr versteht was mein problem ist und habt ein paar anregungen wie man es lösen könte.

[pago]

Machen wir's kurz: http://platonos.sourceforge.net

[karahead]

@beny_mcde
Ich bin mir (fast) sicher, dass für ein Plugins System nur variante 1 möglich ist.
Wenn du aber einen Weg findest, dann bin ich ganz Ohr

Warum kapselst du die Klassenladerei nicht in deiner PluginClassLoader?
z.B.

KlasseVonPlugin1 instance = PluginClassLoader.getInstance()
                           .newInstance("bs.plugin1.KlasseVonPlugin1");
 

Sowas in der Art. Man kann es noch verfeinern.

Zu Platonos:
Ich habe die pluginengine ausprobiert und sie ist echt eine der besten.
Leider wird sie seit der Version 1.0 nicht mehr weiterentwickelt.
Der Entwickler will die ganze Engine neu machen und sie dann als Version 2.0 rausbringen. Nur hat mir der Entwickler das im Herbst '05 erzählt und das ist schon ein halbes Jahr her. Wer weiß ob er noch was macht.

Echt schade um die Engine, wenn nichts draus wird.

Gruß KaraHead

[pago]

Tatsache? Wusste ich gar nicht - benutze diese Engine ja selbst in SimpleEdit. Na ja, aber so schlimm ist das auch nicht, weil 1.0 schon nen sehr großen Bereich an Sachen abdeckt. Deren CVS ham sie vor 8 Monaten das letzte mal benutzt.

Na gut... wenn ich mich nicht ganz irre, dann hat jeder ClassLoader einen Parent-ClassLoader, d.h. sowas hier müsste theoretisch funktionieren können:

public class PluginDemo {
    public static void main(String args[]) {
        MasterPluginClassLoader classLoader = new MasterPluginClassLoader(ClassLoader.getSystemLoader());
        
        File[] pluginFiles = new File("plugins").listFiles();
        for(File plugin : pluginFiles) {
            ClassLoader pluginLoader = new PluginClassLoader(
            // theoretisch könnte man auch alle Plugins in einen URLClassLoader stecken, könnte aber dann eher zu Überschneidungen führen
                        new URL[] { plugin.toURL() },
                        classLoader);
            classLoader.addChild(pluginLoader);
            // Plugin starten ("plugin.xml" lesen und parsen oder sonstwas)
        }
    }
    
    public static class PluginClassLoader extends URLClassLoader {
        private ClassLoader parent;
        public PluginClassLoader(URL url, ClassLoader parent) {
            super(new URL[] { url });
            this.parent = parent;
        }
    
        public Class findClass(String name) throws ClassNotFoundException {
            // wir tun so, als ob wir keinen parent-ClassLoader hätten
            try {
                return super.findClass(name);
            } catch(ClassNotFoundException e) {
                return parent.findClass(name);
            }
        }
    }
    
    public static class MasterPluginClassLoader extends ClassLoader {
        private List<ClassLoader> children;
    
        public MasterPluginClassLoader(ClassLoader parent) {
            super(parent);
            children = new ArrayList<ClassLoader>();
        }
        
        public void addChild(ClassLoader loader) {
            children.add(loader);
        }
        
        public Class findClass(String name) throws ClassNotFoundException {
            for(ClassLoader child : children) {
                try {
                    return child.findClass(name);
                } catch(ClassNotFoundException e) {
                    // ignore
                }
            }
            return parent.findClass(name);
        }
    }
}
 

Das ist ein _Beispiel_. Ich weiß nicht, ob es kompiliert oder gar funktioniert, aber wahrscheinlich tut es beides nicht.

[beny_mcde]

hab mir die platoon engine mal angeschaut und sie scheint alle wichtigen funktionen schon zu implementieren. also scheint sie eine günstige gelegenheit zu sein um mir einiges an tipparbeit zu sparen....

oder habt ihr schon irgendwelche mängel entdeckt?


@pago: mit dem parent classloader hast du recht. aber ich verstehe dein beispiel nicht ganz. normalerweisewürde man einen ClassLoader etwa so instanieren

 MasterClassLoader master = new MasterClassLoader();
 
 PluginClassLoader plugin1 = new PluginClassLoader(master);
 PluginClassLoader plugin2 = new PluginClassLoader(master);
 ...

wenn nun über den PluginClassLoader eine klasse geladen wird, wird erst der parent classloader gefragt, wenn dieser die klasse nicht kennt wird immer weiter nach oben bis zum SystemClassLoader gefragt. wenn dieser die klasse auch nicht findet wird der unterste ClassLoader, also hier der PluginClassLoader gefragt. hierzu wird die methode findClass aufgerufen.

deswegen verstehe ich dein beispiel irgendwie nicht.
da du ja im PluginClassLoader wenn er die klasse nicht findet nochmal den vater fragst...
das ist ja praktisch das umgekehrte vorgehen wie es normlerweise funktioniert.
im schlimmsten falle, wenn eine klasse überhauptnicht verfügbar ist wird das in einer endloßschleife enden, da der PluginClassLoader die klasse nicht findet, den parent loader fragt, der kennt aber die klasse auch nicht und ruft nun wieder die findClassMethode im PluginClassLoader auf u.s.w.


hab zum thema class loading 2 gute artikel gefunden.
nr1
den anderen hab ich nur auf meiner linux platte auf die ich unter windoof kein zugriff habe und find ihn bei google nicht mehr....

[karahead]

Man könnt ja mal den Entwickler fragen, ob er noch was an der engine macht.
Leider bin ich zu unfähig die email von ihm zu finden.

JPF ist auch noch eine Plugin Engine, die mir persönlich aber überhaupt nicht gefällt.
Nur zum Vergleich. Geschmäcker sind verschieden.

[pago]

Deswegen ist es nur ein Beispiel.
Man müsste natürlich noch dafür sorgen, dass es nicht in ner Endlosschleife endet, d.h. der aufrufende ClassLoader müsste übersprungen werden. Ist aber auch kein Thema.

[karahead]

Also so wie ich das verstehe geht

Klasse kl = new Klasse()
 

nicht solange die Klasse.class nicht in der JVM geladen ist und das laden muss halt zur Ausführzeit (AppClassLoader) oder manuell per loadClass("Klasse"); erfolgen.

Die Suchreihenfolge übernehmen dann die ClassLoader.

@beny_mcde
Wenn du unbedingt auf die 2. Variante bestehen willst, dann musst du die vorhandenen Plugins in deinem Plugin Ordner einfach zum Classpath hinzufügen und das Programm starten. Dann sollte es gehen.

Oder rede ich an euch vorbei?

[beny_mcde]

das geht halt warscheinlich nur mit einem eigenen SystemClassLoader, den man ja soweit ich weiß beim start der vm als argument mitgeben muss.

aber ich denke die platoon engine reicht völlig aus, wenn nicht jemand noch riesige mängel hier postet.

wie sagt man doch so schön bei der heirat...
"wer einwände hat möge sie jetzt hervorbringen oder für immer schweigen"
oder so

ausserdem gibts den quellcode ja auch, ich hab die lizenz zwar nicht gelesen aber man darf ihn bestimmt verändern und erweitern.