Comments on: Dynamic in-memory compilation

By: George

George — Mon, 21 Nov 2011 23:15:50 +0000

When I try this with dynamic Class A that extends non-dynamic class B and I properly set the class path during compile time, it compiles but I can’t load it.

If I load it with the custom file manager, I get an issue finding class B. If I try it with Class.forName(), I get an issue finding class C.

Thoughts?

By: RSS Digest: Week Ending 18-Nov-2011 | Zahid Qureshi

RSS Digest: Week Ending 18-Nov-2011 | Zahid Qureshi — Fri, 18 Nov 2011 12:29:49 +0000

[...] Dynamic in-memory compilation http://www.javablogging.com/dynamic-in-memory-compilation/ [...]

By: Hannes de Jager

Hannes de Jager — Sun, 13 Nov 2011 18:38:43 +0000

Great article. You should have a twitter feed to announce blog posts. Would like to follow you like that…

By: Sandeep

Sandeep — Sun, 13 Nov 2011 17:12:45 +0000

Hi, What if I want to specify the version of compiler to use. I mean I want to use some compiler which is not the same as the one which through which I am running the demo program written by you above. Naming Java Files

By: bhomass

bhomass — Sat, 12 Nov 2011 06:40:05 +0000

This is a great article, I am using it for my application. However, one issue is not clear. If the class I am compiling depends on other in memory classes, how is that fed to the compiler? Normally, the filemanager would have a StandardLocation.CLASS_OUTPUT where the dependent classes can be found. of course, not true in this approach. w/o these dependent classes, the compilation would fail.

By: Sergio

Sergio — Thu, 03 Nov 2011 09:59:41 +0000

Really cool. But could you do the same without knowing in advance the class name ?. I mean, generating in memory byte codes only having the source code of the class?

By: jhoni

jhoni — Thu, 13 Oct 2011 09:22:55 +0000

“Intriguing post – thank you. I thought your post was really intriguing. Thanks over again – I will come back.
Software Development

By: Karsten

Karsten — Mon, 03 Oct 2011 07:35:27 +0000

Nice work! Did anybody know an Eclipse-plugin that uses this way to compile the java sources. At work I’m really annoyed by an enthusastic virus scanner that I can’t disable and every compiling-task takes a lot of time (even on a SSD)

By: Britt

Britt — Mon, 20 Jun 2011 19:53:56 +0000

Great example! After doing something similar, I thought it would be useful to mention that the public code in com.sum.script.java.MemoryJavaFileManager does a lot of this, allowing for a simplification of your example:

public class DynaCompTest { public static void main(String[] args) throws Exception { // Full name of the class that will be compiled. // If class should be in some package, // fullName should contain it too // (ex. "testpackage.DynaClass") String fullName = "DynaClass";


        // Here we specify the source code of the class to be compiled

        StringBuilder src = new StringBuilder();

        src.append("public class DynaClass {\n");

        src.append("    public String toString() {\n");

        src.append("        return \"Hello, I am \" + ");

        src.append("this.getClass().getSimpleName();\n");

        src.append("    }\n");

        src.append("}\n");
        System.out.println(src);
        // We get an instance of JavaCompiler. Then

        // we create a file manager

        // (our custom implementation of it)

        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();

        JavaFileManager fileManager = new MemoryJavaFileManager(compiler.getStandardFileManager(null, null, null));
        // Dynamic compiling requires specifying

        // a list of "files" to compile. In our case

        // this is a list containing one "file" which is in our case

        // our own implementation (see details below)

        List jfiles = new ArrayList();

        jfiles.add(MemoryJavaFileManager.makeStringSource(fullName + ".java", src.toString()));
        // We specify a task to the compiler. Compiler should use our file

        // manager and our list of "files".

        // Then we run the compilation with call()

        compiler.getTask(null, fileManager, null, null,

            null, jfiles).call();

// Creating an instance of our compiled class and // running its toString() method Object instance = fileManager.getClassLoader(null) .loadClass(fullName).newInstance(); System.out.println(instance); } }

The only thing needed is to add a getClassLoader() method to MemoryJavaFileManager, such as this one:

@Override public ClassLoader getClassLoader(Location location) { return new java.security.SecureClassLoader() { @Override protected Class findClass(String name) throws ClassNotFoundException { byte[] b = classBytes.get(name); if (b != null) return defineClass(name, b, 0, b.length); return super.findClass(name); } }; }

Source for MemoryJavaFileManager is just a google search away.

Thanks again for the great blog post!

By: Teresa

Teresa — Tue, 12 Apr 2011 08:38:20 +0000

Hey interesting post! Thanks for sharing!!