Change a method at runtime via a hot swap mechanis

Question

Assume we have a trivial Java program that consists of just one class:

public class HelloWorld {

   private static void replacable(int i) {
      System.out.println("Today is a nice day with a number " + i);
   }        

   public static void main(String[] args) throws Exception {
      for(int i = 0; i < 100000; ++i) {
      replacable(i);
      Thread.sleep(500);
   }
}

After it's compiled and run, output will be this:

Today is a nice day with a number 0

Today is a nice day with a number 1

Today is a nice day with a number 2

Today is a nice day with a number 3

...

My question: does there exist (or is there on the horizon) some way to swap replacable method at runtime? Something like writing another version of HelloWorld with a new version of replacable, compiling it and then the old version in an already running JVM?

So, if I write the new version like this:

private static void replacable(int i) {
   System.out.println("Today is an even nicer day with a number " + i);
}  

is there something similar to Erlang's hot code swapping where I can do this:

1. run original program
2. write modified version
3. using a command line program, connect to running JVM and replace existing method

so that, during runtime, this will happen:

Today is a nice day with a number 15000

Today is a nice day with a number 15001

Today is an even nicer day with a number 15002

Today is an even nicer day with a number 15003

...

Assume that above program is standalone, runs in a standard Java SE environment, there is nothing else on classpath, so it's almost a Hello world style program.

Note: I know that technologies like bytecode manipulation (cglib), aspectJ, jRebel, JMX, hotswapping of methods in Java EE etc. exist, but they aren't what I'm thinking of. Think of Erlang.

Answer 1

You can either use the open-source HotSpot VM or the commercial JRebel IDE plugin to easily achieve your goal (view comparison table here).

Answer 2

You could use the Strategy design pattern, so you have a an object to manipulate rather than a method, and a protocol for communicating with the program to tell it to use a given class name as the class of the Strategy object.

Answer 3

A slightly old post, but hopefully someone will find this useful:

I've found the relatively newer Hotswap Agent is well documented and feature-rich (and best of all, open source).

Answer 4

What about OSGi? Hot swapping is sorta "built in" to the spec - I would think this would be one possible solution as well.

Answer 5

You can do it via class loaders. For example if you are familiar with Servlet containers such as tomcat that reload pages as you modify them in development. Here is a great explanation of creating dynamic code in java. It not only explains loading but also compiling source on the fly. You should be able to apply the concepts covered to any strategy of reloading code you want to utilize.

Answer 6

You can do this through the JPDA (Java Platform Debugger Architecture) interface: http://download.oracle.com/javase/1.4.2/docs/guide/jpda/enhancements.html#hotswap

It's not automatic as the Erlang case - the JVM doesn't monitor the class path for changes to class files then reload and relink them if changed, for fairly obvious reasons (Java was designed for web deployment you don't want to be polling a http URL for changes).