On-the-fly, in-memory java code compilation for Java 5 and Java 6

Question

How can I compile java code from an arbitrary string (in memory) in Java 5 and Java 6, load it and run a specific method on it (predefined)?

Before you flame this, I looked over existing implementations:

• Most rely on Java 6 Compiler API.
• Those that don't, rely on tricks.
• Yes, I checked out commons-jci. Either I'm too dense to understand how it works, or it just doesn't.
• I could not find how to feed the compiler my current class path (which is quite huge).
• On the implementation that worked (in Java 6), I could not find how to correctly load inner classes (or inner anonymous classes).
• I'd quite like it if the entire thing was in-memory, as the thing runs on multiple environments.

I'm sure this has been solved before, but I can't find anything that looks even half-production quality on google (except jci, which, as I've said before, I haven't managed to use).

Edit:

• I looked over JavaAssist - I need inner classes, Java 5.0 language level support and compiling with the entire classpath. Also, I'd like to create new classes on the fly. I might be mistaken, but I couldn't find how to do this with JavaAssit.
• I'm willing to use a file-system based solution (calling javac) but I don't know how to divine the classpath, nor how to later load the files (which are not in my classpath) with a special classloader that can be recycled for multiple invocations. While I do know how to research it, I'd prefer a ready solution.

Edit2: For now, I'm content with BeanShell "evaluate". Apparently it does everything I need it to (get a string, evaluate it in the context of the 'current' classpath. It does miss some of Java 5 features, but it can use enums (not define) and compiled 'generic' (erased) classes, so it should be enough for what I want.

I don't want to mark the answer as accepted yet since I do hope for a better solution to come up.

Edit3: Accepted the beanshell suggestion - it really works wonderfully.

Answer 1

Javassist might interest you

Answer 2

JCI looks fine. This code snippet should be your base:

JavaCompiler compiler = new JavaCompilerFactory().createCompiler("eclipse");

MemoryResourceReader mrr = new MemoryResourceReader();
mrr.add("resource name string", yourJavaSourceString.getBytes());

MemoryResourceStore mrs = new MemoryResourceStore();

CompilationResult result = compiler.compile(sources, mrr, mrs);

// don't need the result, unless you care for errors/warnings
// the class should have been compiled to your destination dir

Any reason this should not work?

---

Edit: added a MemoryResourceStore to send the compiled class output to memory, like requested.

Also, setting javac settings, like classpath in your case, can be done via setCustomArguments(String[] pCustomArguments) in JavacJavaCompilerSettings class.

Answer 3

If you're not completely tied to compiling, solutions like Beanshell, groovy and the other scripting languages are easily embedded (in-fact, java has built-in support for plugging in a scripting language so your code doesn't even know what language the script is written in)

Beanshell should run any 100% java code IIRC, and I believe Groovy can run most java code--possibly all.

Answer 4

You might want to check out Janino as well.

From their website:

Janino is a compiler that reads a JavaTM expression, block, class body, source file or a set of source files, and generates JavaTM bytecode that is loaded and executed directly. Janino is not intended to be a development tool, but an embedded compiler for run-time compilation purposes, e.g. expression evaluators or "server pages" engines like JSP.

http://www.janino.net/

Im currently using it in a pretty large mission critical project and it works just fine

Answer 5

Run inside a web container like Tomcat and first generate a JSP page, and then invoke it.

This also allow you to get rid of the old class definitions by simply overwriting the JSP page instead of having your classloader slowly run full.

Is the "in-memory" requirement due to speed or due to not changing the code base?

Answer 6

You can do it on Java 6 using compiler API quite easily. In fact, OpenJdk has it implemented (though it is kinda private). Just look for CompileFromString class