Change a method at runtime via a hot swap mechanism

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.

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

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.

I've used this hotswap ant task in many projects. The target java application can be launched via Ant, Eclipse, a command prompt, or any other means as long as it is launched in debug mode with the appropriate port open. The linked page provides instructions on how to do this via Ant.

Any number of classes can be hotswapped as long as the changes are not structural. Method body changes generally hotswap with ease. Code can be hotswapped by running an ant script via a shell or Eclipse.

At work, I utilize a script that hotswaps code changes automatically by comparing timestamps on the class files. This is similar to the sample on the project page that shows a simple example that only hotswaps changed classes.

Additional note: This utilizes the JPDA.

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).

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).

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

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.