Klassen Klassen "virtuell" erstellen

[SadoChrome]

Hallo Leute,
weiß einer bzw. hat jemand eine Idee, wie man Klassen während des Programmlaufes erzeugen kann, also das Programm soll eine Klasse selber erzeugen, einbinden, evtl. abspeichern und aus der Klasse Objekte erzeugen können.
Es könnte ungefähr so aussehen:

public static void main(String args[]){
     Klasse klasse = createClass();
     KlasseA test = klasse.createObject();
     test.setZahl(5);
}

public Klasse createClass(){
   Klasse klasse = new Klasse("KlasseA"); //Erzeugen einer Klasse
   klasse.setExtends(KlasseB.class); //Vererbung festlegen
   klasse.addInterface(Interface);
   klasse.addVariable("private", Integer, "zahl"); // Variablen setzen
   klasse.addContructor(new Constructor(){
       zahl = 0;
   });
   klasse.addMethod(new Method("public void setZahl (int zahl)"){
      this.zahl = zahl;
   });

return klasse;
}

Meine Idee wäre, man erzeugt eine Klasse als Quellcode, lässt es kompilieren und bindet es dann ein, aber vllt. gibt es eine einfachere Methode.
Mein Ziel ist es, dass sich mein Programm selber weiterentwickelt ohne selber großartig Code dafür zu schreiben.

LG Ich

 

[Tobse]

Ich weiss nicht ob das über Reflection geht. Falls nein bleibt dir nur, den Bytecode zu erzeugen und über einen ClassLoader zu laden. Da gibts Libraries für.

EDIT:
Eine Anmerkung noch: Sehr wahrscheinlich versuchst du hier ein anderes Problem zu lösen. Solange du nicht wirklich Logik zur Laufzeit erstellen musst tust du dir deutlich einfacher damit, ein paar sehr flexible Klassen zu schreiben deren Verhalten über Eingabewerte verändert werden kann.

 

[SadoChrome]

EDIT:
Eine Anmerkung noch: Sehr wahrscheinlich versuchst du hier ein anderes Problem zu lösen. Solange du nicht wirklich Logik zur Laufzeit erstellen musst tust du dir deutlich einfacher damit, ein paar sehr flexible Klassen zu schreiben deren Verhalten über Eingabewerte verändert werden kann.

In diesem Fall hättest du evtl. Recht, dass es so einfacher wäre, weil der größte Teil der selbsterzeugten Klassen von der selben Klasse erben würden.

 

[Tobse]

In diesem Fall hättest du evtl. Recht, dass es so einfacher wäre, weil der größte Teil der selbsterzeugten Klassen von der selben Klasse erben würden.

Richtig. Da tust du dir um ein vielfaches leichter, wenn du einfach die Konfigurationswerte der Objekte speicherst (ggf. per DB-Mapper).

 

[tommysenf]

Mal abgesehen davon ob es für deinen Anwendungsfall sinnvoll ist. Wenn du so etwas vor hast, kann ich dir Javassist empfehlen:

http://jboss-javassist.github.io/javassist/tutorial/tutorial.html

 

[AndyJ]

Das ist mal eine interessante Frage! Ich habe etwas aehnliches schon gemacht, allerdings habe ich halt einfach javac von meinem Programm aus aufgerufen. Das war aber noch mit Java 5, seit Java 6 gibt es jedoch das "Java programming language compiler framework", das ich immer schon mal ausprobieren wollte. Den compiler bekommt man damit so:

JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();

Ich habe es an einem kleinen Beispiel ausprobiert. Das ist die Klasse, die compiliert werden soll:

package some.test;

public class Test {
   
  private int value = 0;
   
  public int getValue() {
  return this.value;
  }
  public void setValue(int value) {
  this.value = value;
  }
   
  public String toString() {
  return "Test[value=" + this.value + "]";
  }
}

Diese Klasse gehoert dann in das Verzeichnis {user.dir}/some/test damit der foldende Code funktioniert:

import java.io.*;
import java.lang.reflect.*;
import java.net.*;
import java.util.*;
import javax.tools.*;

public class CompileTest {

  public static void main(String[] args) throws IOException {
  // file im user directory
  String sourceFile = "some" + File.separator + "test" + File.separator + "Test.java";
  // get compiler and compile source
  JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
  int result = compiler.run(System.in, System.out, System.err, sourceFile);
  System.out.println("Compilation result: " + result);

  // use the class if it worked
  if (result == 0) {
  // add the user directory to the class path of this application
  File classPath = new File(System.getProperty("user.dir"));
  System.out.println("classPath: " + classPath.getCanonicalPath());

  URL url = classPath.toURI().toURL();
  System.out.println("classPath url: " + url);

  try (URLClassLoader classLoader = new URLClassLoader(new URL[] { url }, CompileTest.class.getClassLoader());) {
  System.out.println("classpaths added to class loader: " + Arrays.toString(classLoader.getURLs()));
  // binary name of the compiled class
  String byteCodeFile = "some.test.Test";
  // load the class
  Class<?> clazz = classLoader.loadClass(byteCodeFile);
  System.out.println("The compiled class: " + clazz);

  // create an instance
  Object object = clazz.newInstance();

  // get the setter
  Method method = clazz.getMethod("setValue", Integer.TYPE);

  // set a value
  method.invoke(object, 42);

  // get the toString method
  method = clazz.getMethod("toString");

  // invoke it
  String printed = (String) method.invoke(object);

  System.out.println("The object printed: " + printed);
  } catch (ClassNotFoundException
  | MalformedURLException
  | SecurityException
  | IllegalArgumentException
  | InstantiationException
  | IllegalAccessException
  | NoSuchMethodException
  | InvocationTargetException e) {
  e.printStackTrace();
  }
  }
  }
}

Ich habe das mal fuer eine RuleEnine benutzt, die dem Nutzer erlaubt neue Regeln nach Belieben hinzuzufuegen.

Cheers,
Andy