implémentation Java dynamique de la méthode abstraite

Question

Je suis en train de faire ce qui suit en Java:

j'ai une collection de chaînes (ne importe où entre 1 et 10 000), chaque chaîne contient un corps de méthode différente (ils sont écrits en Java) pour la même méthode abstraite d'une classe. Par exemple:

string1= "int a=1;" 
string2="System.out.println(\"HelloWorld\");" 
... 

chacun de la chaîne pourrait être une mise en œuvre de la méthode abstraite suivante:

abstract class FOO{ 
    public abstract void doSomething(); 
} 

Pour chaque chaîne, je voudrais créer une instance de FOO à utiliser.

Je ne suis pas tout à fait sûr quelle est la meilleure façon d'aller: Je l'ai cherché sur le web et est venu avec ces suggestions:

• Utilisez l'API du compilateur Java 6 pour générer un fichier .class et charger les
• utiliser une bibliothèque de manipulation de bytecode comme cglib, de modifier le code de compilation

y at-il d'autres suggestions, car ceux-ci ont l'air un peu compliqué (au moins à moi-même) ...

Merci pour votre aide

Edit:

Je vais peut-être la mauvaise façon de mon problème. Voici ce que je suis en fin de compte essayer d'atteindre:

J'ai une interface représentant un noeud dans un arbre

public interface Node{ 
    public <T> void process(T input); 

/* ... d'autres méthodes ne sont pas liés à mon problème ... */ }

Lorsque vous fournissez une instance de T au noeud, il fait quelque chose (certains peuvent avoir besoin d'accéder à d'autres méthodes de noeud), et le transmet aux noeuds enfants.

Le problème est (la spécification pour le programme): le programme lit et construit les nœuds à partir de fichiers texte, y compris ce corps de la méthode (les corps sont en java). Il construit ensuite l'arbre et le renvoie.

J'ai l'impression que pour ce faire, je dois générer une implémentation de Node pour chacune des méthodes fournies dans le fichier texte. Je peux me tromper bien, et il pourrait y avoir une meilleure façon ...

Answer 1

Peut-être ce que vous voulez est BeanShell

BeanShell est un petit interprète libre, source de Java intégrable avec des fonctionnalités de langage de script objet, écrit en Java. BeanShell exécute de manière dynamique la syntaxe Java standard et l'étend avec des fonctions de script courantes telles que les types, les commandes et les fermetures de méthodes, comme ceux de Perl et de JavaScript. Vous pouvez utiliser BeanShell interactivement pour l'expérimentation et le débogage Java, ainsi que pour étendre vos applications de nouvelles façons.Scripting Java se prête à une grande variété d'applications, y compris le prototypage rapide, l'extension de script utilisateur, les moteurs de règles, la configuration, les tests, le déploiement dynamique, les systèmes embarqués et même l'éducation Java. BeanShell est petit et intégrable, vous pouvez donc appeler BeanShell à partir de vos applications Java pour exécuter du code Java dynamiquement au moment de l'exécution ou pour fournir de l'extensibilité dans vos applications. Vous pouvez également utiliser des scripts BeanShell autonomes pour manipuler des applications Java. travailler dynamiquement avec les objets Java et les API. Puisque BeanShell est écrit en Java et s'exécute dans la même machine virtuelle que votre application, vous pouvez librement transmettre des références à des objets «vivants» dans des scripts et les renvoyer sous forme de résultats. En bref, BeanShell est interprété de manière dynamique Java, plus un langage de script et un environnement flexible tous roulés dans un paquet propre.

Résumé des caractéristiques

• exécution dynamique de la syntaxe Java complète, fragments de code Java, ainsi que des commodités Java et scripts supplémentaires faiblement typé.
• Accès transparent à tous les objets et API Java.
• Fonctionne selon quatre modes: ligne de commande, console, applet, serveur de session à distance.
• Peut fonctionner dans des environnements à sécurité contrainte sans génération de classe ou de bytecode pour la plupart des fonctionnalités.
• L'interpréteur est un petit fichier jar ~ 150K.
• Pure Java.
• C'est gratuit !!

---

Une alternative est d'utiliser une bibliothèque que j'ai écrit qui enveloppe l'API du compilateur afin qu'il compile en mémoire et des charges dans le classloader (par défaut)

http://sourceforge.net/projects/essence/files/Essence%20Java%20Config.%20Files/Essence%20JCF%201.02/

http://vanillajava.blogspot.co.uk/2010/11/more-uses-for-dynamic-code-in-java.html

// this writes the file to disk only when debugging is enabled. 
CachedCompiler cc = CompilerUtils.DEBUGGING ? 
     new CachedCompiler(new File(parent, "src/test/java"), new File(parent, "target/compiled")) : 
     CompilerUtils.CACHED_COMPILER; 

String text = "generated test " + new Date(); 
Class fooBarTeeClass = cc.loadFromJava("eg.FooBarTee", "package eg;\n" + 
    '\n' + 
    "import eg.components.BarImpl;\n" + 
    "import eg.components.TeeImpl;\n" + 
    "import eg.components.Foo;\n" + 
    '\n' + 
    "public class FooBarTee{\n" + 
    " public final String name;\n" + 
    " public final TeeImpl tee;\n" + 
    " public final BarImpl bar;\n" + 
    " public final BarImpl copy;\n" + 
    " public final Foo foo;\n" + 
    '\n' + 
    " public FooBarTee(String name) {\n" + 
    "  // when viewing this file, ensure it is synchronised with the copy on disk.\n" + 
    "  System.out.println(\"" + text + "\");\n" + 
    "  this.name = name;\n" + 
    '\n' + 
    "  tee = new TeeImpl(\"test\");\n" + 
    '\n' + 
    "  bar = new BarImpl(tee, 55);\n" + 
    '\n' + 
    "  copy = new BarImpl(tee, 555);\n" + 
    '\n' + 
    "  // you should see the current date here after synchronisation.\n" + 
    "  foo = new Foo(bar, copy, \"" + text + "\", 5);\n" + 
    " }\n" + 
    '\n' + 
    " public void start() {\n" + 
    " }\n" + 
    '\n' + 
    " public void stop() {\n" + 
    " }\n" + 
    '\n' + 
    " public void close() {\n" + 
    "  stop();\n" + 
    '\n' + 
    " }\n" + 
    "}\n"); 

// add a debug break point here and step into this method. 
FooBarTee fooBarTee = new FooBarTee("test foo bar tee"); 
Foo foo = fooBarTee.foo; 
assertNotNull(foo); 
assertEquals(text, foo.s);