ändern Classloader

Question

Ich versuche, die Class Loader zur Laufzeit wechseln:

public class Test { 
    public static void main(String[] args) throws Exception { 
     final InjectingClassLoader classLoader = new InjectingClassLoader(); 
     Thread.currentThread().setContextClassLoader(classLoader); 
     Thread thread = new Thread("test") { 
      public void run() { 
       System.out.println("running..."); 
       // approach 1 
       ClassLoader cl = TestProxy.class.getClassLoader(); 
       try { 
        Class c = classLoader.loadClass("classloader.TestProxy"); 
        Object o = c.newInstance(); 
        c.getMethod("test", new Class[] {}).invoke(o); 
       } catch (Exception e) { 
        e.printStackTrace(); 
       } 
       // approach 2 
       new TestProxy().test(); 
      }; 
     }; 
     thread.setContextClassLoader(classLoader); 
     thread.start(); 
    } 
} 

und:

public class TestProxy { 
    public void test() { 
     ClassLoader tcl = Thread.currentThread().getContextClassLoader(); 
     ClassLoader ccl = ClassToLoad.class.getClassLoader(); 
     ClassToLoad classToLoad = new ClassToLoad(); 
    } 
} 

(InjectingClassLoader ist eine Klasse Verlängerung der org.apache.bcel.util .ClassLoader, die die geänderten Versionen der Klassen laden sollten, bevor sie ihre Eltern für sie fragen)

würde ich lik e, um das Ergebnis von "Ansatz 1" und "Ansatz 2" genau gleich zu machen, aber es sieht aus wie thread.setContextClassLoader (classLoader) tut nichts und die "Approach 2" verwendet immer den System-Classloader (kann durch Vergleich tcl ermittelt werden und ccl Variablen während des Debuggens).

Ist es möglich, alle Klassen durch neue Thread-Verwendung gegeben Klassenlader gemacht zu machen?

Answer 1

Die anonyme Klasse, die Sie über new Thread("test") { ... } erstellen, hat eine implizite Referenz auf die umschließende Instanz. Klassenliterale innerhalb dieser anonymen Klasse werden mit dem ClassLoader der umschließenden Klasse geladen.

Damit dieser Test funktioniert, sollten Sie eine geeignete Runnable-Implementierung auswählen und sie mit dem gewünschten ClassLoader reflektiv laden. Übergeben Sie das dann explizit an den Thread. Etwas wie:

public final class MyRunnable implements Runnable { 
     public void run() { 
      System.out.println("running..."); 
      // etc... 
     } 
    } 

    final Class runnableClass = classLoader.loadClass("classloader.MyRunnable"); 
    final Thread thread = new Thread((Runnable) runableClass.newInstance()); 

    thread.setContextClassLoader(classLoader); // this is unnecessary unless you you are using libraries that themselves call .getContextClassLoader() 

    thread.start(); 

Answer 2

Ich denke, InjectingClassLoader kann hier wichtig sein. Denken Sie daran, wie die Klassenladedelegierung funktioniert - wenn mehr als ein Klassenlader in Ihrer Hierarchie die Klasse finden kann, wird der oberste Klassenlader geladen. (Siehe Abbildung 21.2 here)

Da InjectingClassLoader kein Parent im Konstruktor angibt, wird standardmäßig der Konstruktor im abstrakten ClassLoader verwendet, der den aktuellen Context-Klassenlader als InjectingClassLoader-Eltern definiert. Da das übergeordnete Element (alter Kontextklassenlader) TestProxy finden kann, wird die Klasse daher immer geladen, bevor InjectingClassLoader eine Chance erhält.