3 steps to dynamically compile, instantiate and run a Java class

July 20, 2011 by
Filed under: java 

The background:  sometimes we need to compile dynamic source code, and run the code.  Some common situation includes on a program contest evaluation system, on a dynamic business logic control,  on evaluation of dynamic math expression, or even on evaluation of dynamic expression on test case.

Here’s 3 steps to implement compilation, instantiation and running of dynamic java source code.  It is the hard way,  the most original and elastic way; cause you can add any logic in the generation of your dynamic source code.

1. Construct an in-memory java source file from your dynamic code.

You need to override SimpleJavaFileObject, and take a string content as and In memory java source file.

2.Compile your files by JavaCompiler

You need to compile by JavaCompiler which could be got by ToolProvider.getSystemJavaCompiler(). Then get a task of JavaCompiler.CompilationTask. And call the task to execute compilation.

3.Load your class by URLClassLoader

Load your class by URLClassLoader from classes output folder, then instantiate a instance from the class, and finally call method of the class from the instance by reflection.

Here’s a complete working code (tested on JDK 1.6):

import java.io.File;
import java.io.IOException;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.Arrays;
import java.util.Locale;

import javax.tools.Diagnostic;
import javax.tools.DiagnosticListener;
import javax.tools.JavaCompiler;
import javax.tools.JavaFileObject;
import javax.tools.SimpleJavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;

 * Dynamic java class compiler and executer  <br>
 * Demonstrate how to compile dynamic java source code, <br>
 * instantiate instance of the class, and finally call method of the class <br>
 * http://www.beyondlinux.com
 * @author david 2011/07
public class DynamicCompiler
    /** where shall the compiled class be saved to (should exist already) */
    private static String classOutputFolder = "/classes/demo";

    public static class MyDiagnosticListener implements DiagnosticListener<JavaFileObject>
        public void report(Diagnostic<? extends JavaFileObject> diagnostic)

            System.out.println("Line Number->" + diagnostic.getLineNumber());
            System.out.println("code->" + diagnostic.getCode());
                               + diagnostic.getMessage(Locale.ENGLISH));
            System.out.println("Source->" + diagnostic.getSource());
            System.out.println(" ");

    /** java File Object represents an in-memory java source file <br>
     * so there is no need to put the source file on hard disk  **/
    public static class InMemoryJavaFileObject extends SimpleJavaFileObject
        private String contents = null;

        public InMemoryJavaFileObject(String className, String contents) throws Exception
            super(URI.create("string:///" + className.replace('.', '/')
                             + Kind.SOURCE.extension), Kind.SOURCE);
            this.contents = contents;

        public CharSequence getCharContent(boolean ignoreEncodingErrors)
                throws IOException
            return contents;

    /** Get a simple Java File Object ,<br>
     * It is just for demo, content of the source code is dynamic in real use case */
    private static JavaFileObject getJavaFileObject()
        StringBuilder contents = new StringBuilder(
                                                   "package math;"+
                                                            "public class Calculator { "
                                                           + "  public void testAdd() { "
                                                           + "    System.out.println(200+300); "
                                                           + "  } "
                                                           + "  public static void main(String[] args) { "
                                                           + "    Calculator cal = new Calculator(); "
                                                           + "    cal.testAdd(); "
                                                           + "  } " + "} ");
        JavaFileObject so = null;
            so = new InMemoryJavaFileObject("math.Calculator", contents.toString());
        catch (Exception exception)
        return so;

    /** compile your files by JavaCompiler */
    public static void compile(Iterable<? extends JavaFileObject> files)
        //get system compiler:
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();

        // for compilation diagnostic message processing on compilation WARNING/ERROR
        MyDiagnosticListener c = new MyDiagnosticListener();
        StandardJavaFileManager fileManager = compiler.getStandardFileManager(c,
        //specify classes output folder
        Iterable options = Arrays.asList("-d", classOutputFolder);
        JavaCompiler.CompilationTask task = compiler.getTask(null, fileManager,
                                                             c, options, null,
        Boolean result = task.call();
        if (result == true)

    /** run class from the compiled byte code file by URLClassloader */
    public static void runIt()
        // Create a File object on the root of the directory
        // containing the class file
        File file = new File(classOutputFolder);

            // Convert File to a URL
            URL url = file.toURL(); // file:/classes/demo
            URL[] urls = new URL[] { url };

            // Create a new class loader with the directory
            ClassLoader loader = new URLClassLoader(urls);

            // Load in the class; Class.childclass should be located in
            // the directory file:/class/demo/
            Class thisClass = loader.loadClass("math.Calculator");

            Class params[] = {};
            Object paramsObj[] = {};
            Object instance = thisClass.newInstance();
            Method thisMethod = thisClass.getDeclaredMethod("testAdd", params);

            // run the testAdd() method on the instance:
            thisMethod.invoke(instance, paramsObj);
        catch (MalformedURLException e)
        catch (ClassNotFoundException e)
        catch (Exception ex)

    public static void main(String[] args) throws Exception
        //1.Construct an in-memory java source file from your dynamic code
        JavaFileObject file = getJavaFileObject();
        Iterable<? extends JavaFileObject> files = Arrays.asList(file);

        //2.Compile your files by JavaCompiler

        //3.Load your class by URLClassLoader, then instantiate the instance, and call method by reflection
Digg This
Reddit This
Stumble Now!
Vote on DZone
Share on Facebook
Bookmark this on Delicious
Share on LinkedIn
Bookmark this on Technorati
Post on Twitter
Google Buzz (aka. Google Reader)


2 Comments on 3 steps to dynamically compile, instantiate and run a Java class

    […] You can add the dynamic expressions to codes of a skeleton class  template; and then compile the class.  It is the most original and flexible way to evaluate expressions. For full instructions see my last post: 3 steps to dynamically compile, instantiate and run a Java class. […]

  1. javaexp on Mon, 7th Jan 2013 8:59 pm
  2. Some of JDK classes are automatically loaded into JVM memory which can be seen by using the verbose options