Dynamic class loading problem using unknown JAR archive and directory names

Question

I read the following article, which enlightened me a lot:
Ted Neward: Understanding Class.forName().
However, it took me some while to understand that my problem is the other way around:
I know the name of the class, I know the name of the method,
but my program/JVM does not know where to load the classes from.
Shortly, my problem is that the server engine that I am writing
uses two different versions of the same library.
So I am trying out the following solution:
My program is named TestClassPathMain.java
Assume the two libraries are named JAR1.jar and JAR2.jar
and the class/instance method that should
be exposed to TestClassPathMain.java by them is named
TestClass1.testMethod().
As long as I was depending on just one library,
I put JAR1.jar in the classpath before starting java,
and I was happy for a while.
At the moment I got the need to use another version of
TestClass1.testMethod() packaged in JAR2.jar,
a call would always access JAR1.jar's
TestClass1.testMethod().
I then decided to remove JAR1.jar from the classpath,
and programmatically define two separate ClassLoaders, one for use
with JAR1.jar and the other for use with JAR2.jar.
However, the problem is only partly solved.
Please refer to the enclosed code for details.
(The code in the JAR1.jar/JAR2.jar is extremely simple,
it just tells (by hardcoding) the name of the jar it is packaged in
and instantiates another class packaged in the same jar using
the "new" operator and calls a method on it. I don't enclose it.)
The TestClassPathMain.java/UC1.java/UC2.java code suite was
successfully compiled with an arbitrary of JAR1 or JAR2 in the classpath,
however removed from the classpath at runtime.
(I know that this could have been done (more elegantly...?) by producing an Interface,
but I think the main problem principle is still untouched by this potential lack of elegancy(?))
1) This problem should not be unknown to you experts out there,
how is it generally and/or most elegantly solved?
The "*** UC2: Variant 2" is the solution I would like best, had it only worked.
2) And why arent "*** UC2: Variant 2" and
"*** static UC2: Variant 2" working,
while "*** Main: Variant 2" is?
3) And a mal-apropos:
Why can't I catch the NoClassDefFoundError?
The output:
*** Main: Variant 1 JAR 1 ***:
Entering TestClass1.testMethod() packaged in JAR1.jar
About to instantiate TestClass2 with the new operator
About to call TestClass2.testMethod()
Entering TestClass2.testMethod() packaged in JAR1.jar
*** Main: Variant 1 JAR 2 ***:
Entering TestClass1.testMethod() packaged in JAR2.jar
About to instantiate TestClass2 with the new operator
About to call TestClass2.testMethod()
Entering TestClass2.testMethod() packaged in JAR2.jar
*** Main: Variant 2 JAR 1 ***:
Entering TestClass1.testMethod() packaged in JAR1.jar
About to instantiate TestClass2 with the new operator
About to call TestClass2.testMethod()
Entering TestClass2.testMethod() packaged in JAR1.jar
*** Main: Variant 2 JAR 2 ***:
Entering TestClass1.testMethod() packaged in JAR2.jar
About to instantiate TestClass2 with the new operator
About to call TestClass2.testMethod()
Entering TestClass2.testMethod() packaged in JAR2.jar
*** UC1: Variant 1 JAR 1 ***:
Entering TestClass1.testMethod() packaged in JAR1.jar
About to instantiate TestClass2 with the new operator
About to call TestClass2.testMethod()
Entering TestClass2.testMethod() packaged in JAR1.jar
*** UC1: Variant 1 JAR 2 ***:
Entering TestClass1.testMethod() packaged in JAR2.jar
About to instantiate TestClass2 with the new operator
About to call TestClass2.testMethod()
Entering TestClass2.testMethod() packaged in JAR2.jar
*** static UC2: Variant 2 JAR 1 ***:
Exception in thread "main" java.lang.NoClassDefFoundError: TestClass1
        at UC2.runFromJarVariant2_static(UC2.java:56)
        at TestClassPathMain.main(TestClassPathMain.java:52)
TestClassPathMain.java
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
public class TestClassPathMain {
    public static void main(final String args[]) throws MalformedURLException, ClassNotFoundException, InstantiationException, SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException {
            // Commented out because I cannot catch the NoClassDefFoundError.
            // Why?
            try {
                final TestClass1 testClass1 = new TestClass1();
                System.out.println(
                    "\nThe class TestClass1 is of some unexplicable reason available." +
                    "\nFor the purpose of the test, it shouldn't have been!" +
                    "\nExiting");
                System.exit(1);
            } catch (NoClassDefFoundError e) {
                System.out.println("\nPositively confirmed that the class TestClass1 is not available:\n" + e);
                System.out.println("\n\nREADY FOR THE TEST: ...");
            // Works fine
            System.out.println("\n*** Main: Variant 1 JAR 1 ***:");
            runFromJarVariant1("file:/W:/java/eclipse/workspaces/simped_test/CP1/JAR1.jar");
            System.out.println("\n*** Main: Variant 1 JAR 2 ***:");
            runFromJarVariant1("file:/W:/java/eclipse/workspaces/simped_test/CP2/JAR2.jar");
            // Works fine
            System.out.println("\n*** Main: Variant 2 JAR 1 ***:");
            runFromJarVariant1("file:/W:/java/eclipse/workspaces/simped_test/CP1/JAR1.jar");
            System.out.println("\n*** Main: Variant 2 JAR 2 ***:");
            runFromJarVariant1("file:/W:/java/eclipse/workspaces/simped_test/CP2/JAR2.jar");
            // Works fine
            final UC1 uc1 = new UC1();
            System.out.println("\n*** UC1: Variant 1 JAR 1 ***:");
            uc1.runFromJarVariant1("file:/W:/java/eclipse/workspaces/simped_test/CP1/JAR1.jar");
            System.out.println("\n*** UC1: Variant 1 JAR 2 ***:");
            uc1.runFromJarVariant1("file:/W:/java/eclipse/workspaces/simped_test/CP2/JAR2.jar");
            // Crashes
            System.out.println("\n*** static UC2: Variant 2 JAR 1 ***:");
            UC2.runFromJarVariant2_static("file:/W:/java/eclipse/workspaces/simped_test/CP1/JAR1.jar");
            System.out.println("\n*** static UC2: Variant 2 JAR 2 ***:");
            UC2.runFromJarVariant2_static("file:/W:/java/eclipse/workspaces/simped_test/CP2/JAR2.jar");
            // Crashes
            final UC2 uc2 = new UC2();
            System.out.println("\n*** UC2: Variant 2 JAR 1 ***:");
            uc2.runFromJarVariant2("file:/W:/java/eclipse/workspaces/simped_test/CP1/JAR1.jar");
            System.out.println("\n*** UC2: Variant 2 JAR 2 ***:");
            uc2.runFromJarVariant2("file:/W:/java/eclipse/workspaces/simped_test/CP2/JAR2.jar");
    private static void runFromJarVariant1(final String jarFileURL)
        throws MalformedURLException,
               ClassNotFoundException,
               InstantiationException,
               IllegalArgumentException,
               IllegalAccessException,
               InvocationTargetException,
               SecurityException,
               NoSuchMethodException {
        final URL url = new URL(jarFileURL);
        final URLClassLoader cl =
            new URLClassLoader(new URL[]{url},
                               Thread.currentThread().getContextClassLoader());
        final Class clazz = cl.loadClass("TestClass1");
        final Object testClass1 = clazz.newInstance();
        final Method testMethod1 = clazz.getMethod("testMethod", null);
        testMethod1.invoke(testClass1, null);
    private static void runFromJarVariant2(final String jarFileURL)
        throws MalformedURLException,
               ClassNotFoundException,
               InstantiationException,
               IllegalArgumentException,
               IllegalAccessException,
               InvocationTargetException,
               SecurityException,
               NoSuchMethodException {
        final URL url = new URL(jarFileURL);
        final URLClassLoader cl =
            new URLClassLoader(new URL[]{url},
                               Thread.currentThread().getContextClassLoader());
        final Class clazz = cl.loadClass("TestClass1");
        final TestClass1 testClass1 = new TestClass1();
        testClass1.testMethod();
UC1.java
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
public class UC1 {
    public void runFromJarVariant1(final String jarFileURL)
        throws MalformedURLException,
               ClassNotFoundException,
               InstantiationException,
               IllegalArgumentException,
               IllegalAccessException,
               InvocationTargetException,
               SecurityException,
               NoSuchMethodException {
        final URL url = new URL(jarFileURL);
        final URLClassLoader cl =
            new URLClassLoader(new URL[]{url},
                               Thread.currentThread().getContextClassLoader());
        final Class clazz = cl.loadClass("TestClass1");
        final Object testClass1 = clazz.newInstance();
        final Method testMethod1 = clazz.getMethod("testMethod", null);
        testMethod1.invoke(testClass1, null);
UC2.java
import java.lang.reflect.InvocationTargetException;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
public class UC2 {
    public void runFromJarVariant2(final String jarFileURL)
    throws MalformedURLException,
           ClassNotFoundException,
           InstantiationException,
           IllegalArgumentException,
           IllegalAccessException,
           InvocationTargetException,
           SecurityException,
           NoSuchMethodException {
        final URL url = new URL(jarFileURL);
        final URLClassLoader cl =
            new URLClassLoader(new URL[]{url},
                               Thread.currentThread().getContextClassLoader());
        final Class clazz = cl.loadClass("TestClass1");
        final TestClass1 testClass1 = new TestClass1();
        testClass1.testMethod();
     * Identic to the "runFromJarVariant2" method,
     * except that it is static
    public static void runFromJarVariant2_static(final String jarFileURL)
    throws MalformedURLException,
           ClassNotFoundException,
           InstantiationException,
           IllegalArgumentException,
           IllegalAccessException,
           InvocationTargetException,
           SecurityException,
           NoSuchMethodException {
        final URL url = new URL(jarFileURL);
        final URLClassLoader cl =
            new URLClassLoader(new URL[]{url},
                               Thread.currentThread().getContextClassLoader());
        final Class clazz = cl.loadClass("TestClass1");
        final TestClass1 testClass1 = new TestClass1();
        testClass1.testMethod();
}

Answer 1

2. i need to load the class to the same JVM (i.e. to
the same environment) of the current running
aplication, so that when the loaded class is run, it
would be able to invoke methods on it!!!
ClassLoader(s) do this. Try the URLClassLoader.
(I was talking about relatively esoteric "security"
issues when I mentioned the stuff about Class objects
"scope".) You might use the URLClassLoader kind of
like this.
Pseudo-code follows:
// setup the class loader
URL[] urls = new URL[1];
urls[0] = new URL("/path/to/dynamic/classes");
URLClassLoader ucl = new URLClassLoader(urls);
// load a class & use make an object with the default constructor
Object tmp = ucl.loadClass("dynamic.class.name").newInstance();
// Cast the object to a know interface so that you can use it.
// This may be used to further determine which interface to cast
// the class to. Or it may simply be the interface to which all
// dynamic classes have to conform in your program.
InterfaceImplementedByDynamicClass loadedObj =
    (InterfaceImplementedByDynamicClass)tmp;It's really not as hard as it sounds, just write a little test of
this and you will see how it works.