Myujth

Say I have a class named NameGenerator. I can use this to generate names according to a given logic. Then I write a TestNameGeneration class with a method that asks for a letter from the user and generate a name in accordance. Now I want to change the logic in NameGeneration class and apply that particular change without stopping the application.

I did this to learn more about class loaders and can someone please explain the key concepts that I have to learn to do something like that or site any references ?

Here is a working test. Every 5 secs Test.main() reloads test.Test1.class from the file system and calls Test1.hello()

package test;

public class Test1 
 public void hello() 
 System.out.println("Hello !");
 


public class Test 

 static class TestClassLoader extends ClassLoader 
 @Override
 public Class<?> loadClass(String name) throws ClassNotFoundException 
 if (name.equals("test.Test1")) 
 try 
 InputStream is = Test.class.getClassLoader().getResourceAsStream("test/Test1.class");
 byte buf = new byte[10000];
 int len = is.read(buf);
 return defineClass(name, buf, 0, len);
 catch (IOException e) 
 throw new ClassNotFoundException("", e);
 
 
 return getParent().loadClass(name);
 
 

 public static void main(String args) throws Exception 
 for (;;) 
 Class cls = new TestClassLoader().loadClass("test.Test1");
 Object obj = cls.newInstance();
 cls.getMethod("hello").invoke(obj);
 Thread.sleep(5000);
 
 

Run it. Then change and recompile Test1

System.out.println("Hello !!!");

while Test is running. You will see Test1.hello output changed

...
Hello !
Hello !
Hello !!!
Hello !!!

This is how eg Tomcat reloads webapps. It has a separate ClassLoader for each webapp and loads a new version in a new ClassLoader. The old one is GCed just like any Java object as well as the old classes.

Note that we loaded Test1 with TestClassLoader and invoked its first method with reflection. But all Test1 dependencies will be implicitly loaded with Test1 class loader, that is all the Test1 application will be loaded by JVM into TestClassLoader.

There are 2 ways:

1. To overwrite the class loader you're using by first using the existing classloader to bootstrap your application and specifically for the class that you need to have dynamic update, you have to use the overwritten classloader.


2. To use OSGi framework. Depending on the scale of your application, OSGi framework may not be a good choice as it requires you to follow it's coding convention.

Hope it helps

It's really simple, you will use of advantage of a OOP and use interface, don't need to manage classloader
You can inject the implementation with a setter:

Create an interface called NameGeneration
Create n implementation NameGenerationImpl1, NameGenerationimpl2 for instance
In your client class define a variable:

NameGeneration nameGeneration ;

and the setter :

 public void setNameGeneration(NameGeneration nameGeneration) 
 this.nameGeneration = nameGeneration ;

nameGeneration will generate what you want.

When you change the algorithm you change the implementation by doing for instance :

setNameGeneration(new NameGenerationImpl1()) ;

or

setNameGeneration(new NameGenerationImpl2()) ;

What about a strategy pattern? It could be a better solution for your problem instead of using classloaders.

You can write your own custom classloader. When ever there is change in the class file or resource/jar containing the class file (check the timestamp), destroy the previous classloader instance and create a new classloader instance which in turn will load the new class file.