RelProxy: A Hot Class Reloader and Scripting for Java and Groovy

Let's go first with Groovy.

You know Groovy is a dynamic language that supports built-in hot class reload. Maybe you don't know Groovy is a bytecode based language. In this case, Groovy engine compiles Groovy classes on demand.

Think we have several Groovy classes with object instances going to be registered into some Java library as listeners implementing some interface. The Groovy object implementing the Java interface is in memory a "normal" Java object (in spite it was created by Groovy), then this object is received by the Java library when registering. In spite of Groovy can reload classes, there is no way to reload the Groovy object registered.

Only the bridge object and related/dependent code is reloaded, maybe not everything, but it may avoid many re-deploys for instance in web applications.

The same is applied to Java code with the utility JProxy, in this case is RelProxy which timely checks source code changes, compiling changed classes on the fly and reloading all classes with a new ClassLoader.

The following is a Java example based on ItsNat:

FalseDB db = new FalseDB();
ItsNatServletRequestListener listener = 
   JProxy.create(new example.javaex.JProxyExampleLoadListener(db), 
      ItsNatServletRequestListener.class);
docTemplate.addItsNatServletRequestListener(listener);

The object JProxyExampleLoadListener is reloadable, the same its dependencies but FalseDB because is created "outside of the proxy environment".

Thanks to jproxysh utility you can create an archive, for instance with name example_java_shell, with this content:

#!/usr/bin/env jproxysh

String msg = args[0] + args[1];
System.out.println(msg);
System.out.println("example_java_shell 1 ");
example.javashellex.JProxyShellExample.exec();

and be executed with no previous compilation.

It can be a complete Java class:

#!/usr/bin/env jproxysh

import example.javashellex.JProxyShellExample;
public class example_java_shell_complete_class
{
    public static void main(String[] args)
    {
        String msg = args[0] + args[1];
        System.out.println(msg);
        System.out.println("example_java_shell_complete_class 1 ");
        JProxyShellExample.exec();
    }
}

JProxyShellExample can also be a Java class with just the source code.

Also it could be a normal Java class, again with no need of compilation (JavaSE projects with no compilation):

jproxysh example_normal_class.java "HELLO " "WORLD!"

We can execute a code snippet:

jproxysh -c 'System.out.print("This code snippet says: ");' \
                   'System.out.println("Hello World!!");'

Or a complete class:

jproxysh -c 'public class _jproxyMainClass_ { '  \
            ' public static void main(String[] args) { ' \
            '    System.out.print("This code snippet says: ");' \
            '    System.out.println("Hello World!!");' \
            '  }' \
            '}'

Finally invoking jproxysh with no param:

jproxysh

Starts a simple interactive shell, where we can write and execute Java code progressively.

Must be noted RelProxy does NOT create a new language similar to Java, such as BeanShell does, RelProxy just compiles on the fly in memory (optionally can save .class files).

Java is just another "script" language supported:

JProxyScriptEngineFactory factory = JProxyScriptEngineFactory.create(jpConfig);

ScriptEngineManager manager = new ScriptEngineManager();
manager.registerEngineName("Java", factory);
manager.getBindings().put("msg","HELLO GLOBAL WORLD!");

ScriptEngine engine = manager.getEngineByName("Java");
Bindings bindings = engine.createBindings();
bindings.put("msg","HELLO SCOPE WORLD!");

StringBuilder code = new StringBuilder();
code.append( " javax.script.Bindings bindings = context.getBindings(javax.script.ScriptContext.ENGINE_SCOPE); \n");
code.append( " String msg = (String)bindings.get(\"msg\"); \n");
code.append( " System.out.println(msg); \n");
code.append( " bindings = context.getBindings(javax.script.ScriptContext.GLOBAL_SCOPE); \n");
code.append( " msg = (String)bindings.get(\"msg\"); \n");
code.append( " System.out.println(msg); \n");
code.append( " example.javashellex.JProxyShellExample.exec(engine); \n");
code.append( " return \"SUCCESS\";");

String result = (String)engine.eval( code.toString() , bindings);
System.out.println("RETURNED: " + result);

ENJOY!!