Is there a way to create class(not instance) dynamically?

Question

I have an issue about how to create class(not instance) dynamically. In my project, I need to write several similar class according to the configuration file. For exmaple, there is a JSON like this:

{                                                                                                                                                                              
    {                                                                                                                                                                          
        "lang": "python",                                                                                                                                                      
        "file": "class1.py",
        "args": ["arg1"]                                                                                                                                  
    },                                                                                                                                                                         
    {                                                                                                                                                                          
        "lang": "python",                                                                                                                                                      
        "file": "class2.py"  
        "args": ["arg2"]                                                                                                                                               
    }                                                                                                                                                                          
}

Subsequently, I need to write two java class below:

class1:

public class Class1 extends ShellBolt implements IRichBolt {
    public Class1() {
        super("python", "class1.py");
    }

    @Override
    public void declareOutputFields(OutputFieldsDeclarer declarer) {
        declarer.declare(new Fields(arg1));
    }

    @Override
    public Map<String, Object> getComponentConfiguration() {
        return null;
    }
}

class2:

public class Class2 extends ShellBolt implements IRichBolt {

    public Class2() {
        super("python", "class2.py");
    }

    @Override
    public void declareOutputFields(OutputFieldsDeclarer declarer) {
        declarer.declare(new Fields(arg2));
    }

    @Override
    public Map<String, Object> getComponentConfiguration() {
        return null;
    }
}

But if the JSON file is added a new object:

{                                                                                                                                                                          
    "lang": "python",                                                                                                                                                      
    "file": "class3.py"   
    "args": ["arg3"]
}

I need to write a new Class with the similar structure. So, is there a way to create class dynamically? I know maybe cglib might works, but I hava no idea how to use it in my case. Thanks.

Why do you need to create these classes? Why wouldn't it be sufficient to have just one class which encapsulates the JSON-Object from the configuration file and has methods which behave according to the content of that object? — Philipp, Jan 17 '14 at 09:18
there are libraries like [BCEL](http://commons.apache.org/proper/commons-bcel/) that allow you to create classes at run time — Paolo Falabella, Jan 17 '14 at 09:20
This is an article discussing a similar problem: http://www.javaranch.com/journal/200711/Journal200711.jsp#a4 — jayeff, Jan 17 '14 at 09:22
@Philipp hi philipp, I know somebody might have this question. But unfortunately, the frame work I used here just needs to be like this. The Instances of the similar classes will be used later. — Charlie Lin, Jan 17 '14 at 09:25

score 2 · Answer 1 · edited May 23 '17 at 12:11

You can use the JavaCompiler to compile any java code to a class file. You can then load the resulting class with a URLClassLoader.

An example is given in the javadocs or for a complete example you can check this question.

Applied to your Class1 it would look like the example below. Note that you need to include all the relevant imports in the code or it won't compile.

public static void main(String[] args) throws Exception {
    String packageName = "some.packagename";
    String className = packageName + ".Class1";
    String body = "package " + packageName + ";   " +
                "public class Class1 extends ShellBolt implements IRichBolt {\n" +
                "    public Class1() {\n" +
                "        super(\"python\", \"class1.py\");\n" +
                "    }\n" +
                "\n" +
                "    @Override\n" +
                "    public void declareOutputFields(OutputFieldsDeclarer declarer) {\n" +
                "        declarer.declare(new Fields(arg1));\n" +
                "    }\n" +
                "\n" +
                "    @Override\n" +
                "    public Map<String, Object> getComponentConfiguration() {\n" +
                "        return null;\n" +
                "    }\n" +
                "}";

    Path classFile = Paths.get(System.getProperty("user.home"));
    compile(className, body, classFile);
    Class<?> class1 = loadClass(className, classFile);

    Method getComponentConfiguration = class1.getDeclaredMethod("getComponentConfiguration");
    Map<String, Object> result = (Map<String, Object>) getComponentConfiguration.invoke(class1.newInstance());
}

private static Class<?> loadClass(String className, Path path) throws Exception {
    URLClassLoader loader = new URLClassLoader(new URL[]{path.toUri().toURL()}, Test1.class.getClassLoader());
    return loader.loadClass(className);
}

private static void compile(String className, String body, Path path) throws Exception {
    List<JavaSourceFromString> sourceCode = Arrays.asList(new JavaSourceFromString(className, body));

    JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
    StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
    fileManager.setLocation(StandardLocation.CLASS_OUTPUT, Arrays.asList(path.toFile()));
    boolean ok = compiler.getTask(null, fileManager, null, null, null, sourceCode).call();

    System.out.println("compilation ok = " + ok);
}

public static class JavaSourceFromString extends SimpleJavaFileObject {
    final String code;

    JavaSourceFromString(String name, String code) {
        super(URI.create("string:///" + name.replace('.', '/') + JavaFileObject.Kind.SOURCE.extension),
                JavaFileObject.Kind.SOURCE);
        this.code = code;
    }

    @Override
    public CharSequence getCharContent(boolean ignoreEncodingErrors) {
        return code;
    }
}

score 1 · Answer 2 · answered Jan 17 '14 at 09:32

If you really need to create classes in JVM dynamically, consider using dynamic languages such as Groovy.

Another way: if you need to interpret some Python code on JVM - consider using Jython. http://www.jython.org/

There's a danger on creating classes in HotSpot JVM dynamically. If you will create too many dynamic classes, you may run out of PermGen space, and your JVM will crash with OutOfMemory error. However, there's some workarounds about it, such as enabling garbage collection for PermGen via -XX:+UseConcMarkSweepGC -XX:+CMSClassUnloadingEnabled -XX:+CMSPermGenSweepingEnabled jvm parameters. It is announced than PermGen will be removed in JVM 8.

score 0 · Answer 3 · answered Jan 17 '14 at 10:42

Yes, there is a way. You should create your own ClassLoader implementation, override its loadClass method and there call defineClass, providing it with the bytecode. There is no built-in classes to generate bytecode, but you can always use ASM. Then you instantiate you ClassLoader and get your class from it that way:

ClassLoader myClassLoader = new MyClassLoader(ClassLoader.getSystemClassLoader());
Class<?> generatedClass = Class.forName("pkg.GeneratedClass", true, myClassLoader);
Object instance = generatedClass.newInstance();

There is an example of how your loadClass might be implemented:

@Override public void loadClass(String name) {
    if (name.equals("pkg.GeneratedClass")) {
        ClassWriter cw = new ClassWriter(0);
        cw.visit(V1_6, ACC_PUBLIC, "pkg/GeneratedClass", null, "java/lang/Object", null);
        // and so on, use ASM API to complete class generation,
        // see asm documentation
        byte[] bytecode = cw.toByteArray();
        return defineClass(name, bytecode, 0, bytecode.length);
    } else {
        return super.loadClass(name);
    }
}

Is there a way to create class(not instance) dynamically?

3 Answers3