5

我正在研究类路径的动态修改。我找到了一种效果很好的解决方案，但它使用显式调用 addURL() 来实现。（大概在启动时）

但是，如果默认类加载器似乎无法找到类，我想在运行时拦截类加载过程以定位类。我尝试将ClassLoader子类化，因此它只是委托findClass()和默认值，并打印出一条调试行，告诉我这些方法已被调用，但是当我的类通过隐式loadClass()类加载使用依赖类时，它们似乎从未被调用，例如

// regular object instantiation with 'new'
BrowserLauncher launcher;
launcher = new BrowserLauncher();

// static methods
Foobar.doSomethingOrOther();

// Class.forName()
Class cl = Class.forName("foo.bar.baz");

// reflection on a Class object obtained statically
Class<Foobar> cl = Foobar.class;
// do something with cl, like call static methods or newInstance()

在这些情况下类加载如何工作？（与显式调用 Classloader.loadClass() 的更简单情况相比）

下面是我对自定义类加载器的尝试。如果我使用带有参数列表的 DynClassLoader0.main(){"some.package.SomeClass", "foo", "bar", "baz"}和 some.package.SomeClass 引用在外部 .jar 文件中找到的其他类，使用上面列出的方法之一，为什么我的 DynClassLoader0 的 findClass() 和 loadClass( ) 被调用？唯一一次调用 loadClass 是在下面的 main() 函数中显式调用 loadClass。

package com.example.test.classloader;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class DynClassLoader0 extends ClassLoader {
    public DynClassLoader0()
    {
        super();
    }
    public DynClassLoader0(ClassLoader parent)
    {
        super(parent);
    }
    public void runMain(String classname, String[] args) throws ClassNotFoundException, SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException
    {
    // [***] here we explicitly use our classloader.
        Class<?> cl = loadClass(classname);
        Method main = cl.getMethod("main", String[].class);
        main.invoke(null, new Object[] {args});
    }

    @Override protected Class<?> findClass(String name) throws ClassNotFoundException
    {
        System.out.println("findClass("+name+")");
        return super.findClass(name);
    }

    @Override public Class<?> loadClass(String name) throws ClassNotFoundException
    {
        System.out.println("loadClass("+name+")");
        return super.loadClass(name);
    }

    static public void main(String[] args)
    {
        // classname, then args
        if (args.length >= 1)
        {
            String[] classArgs = new String[args.length-1];
            System.arraycopy(args, 1, classArgs, 0, args.length-1);

            ClassLoader currentThreadClassLoader
             = Thread.currentThread().getContextClassLoader();
            DynClassLoader0 classLoader = new DynClassLoader0(currentThreadClassLoader);
            // Replace the thread classloader - assumes
            // you have permissions to do so
            Thread.currentThread().setContextClassLoader(classLoader);

            try {
                classLoader.runMain(args[0], classArgs);
            }
            catch (Exception e) {
                e.printStackTrace();
            }
        }
        else
        {
            System.out.println("usage: DynClassLoader {classname} [arg0] [arg1] ...");
        }
    }
}

编辑：我已经查看了这些问题：

编辑：我认为 kdgregory 在下面所说的是正确的，一旦我明确使用我的类加载器（参见代码中的行[***]作为注释），从该类执行的所有代码都将导致来自同一个类加载器的隐式类加载。然而，我的 DynClassLoader0.loadClass() 永远不会被调用，除非在最外层的显式调用期间。

4

2 回答 2

4

引用ClassLoader JavaDoc：

类加载器创建的对象的方法和构造函数可以引用其他类。为了确定引用的类，Java 虚拟机调用最初创建该类的类加载器的 loadClass 方法。

换句话说，一旦加载了一个类，该类就会尝试通过加载它的类加载器加载其他类。在普通的 Java 应用程序中，即系统类加载器，它表示传递给 JVM 的类路径，或引导类加载器，用于加载 JVM 运行时。

根据您的需要，有一个Class.forName()的变体，它将类加载器作为参数。如果您使用它来加载特定类，则该类中的引用应使用指定的类加载器。

编辑：我开始跟踪您的示例，但决定提供我自己的示例会更容易。如果你要编写自己的类加载器，我建议从现有的URLClassLoader开始，因为它处理了很多幕后的东西。

因此，MyClassLoader只需要一个 JARfile/directory 并为该目录加载类。我重写了加载类的三个调用方法，并简单地记录它们的调用（使用 System.err，因为它不缓冲输出，与 System.out 不同）。

我的示例使用了我目前正在使用的库；这很方便，但是您可以选择任何您想要的库，只要它不在您的 classpath中。

main() 方法通过 MyLoader 加载一个类。然后我在那个类上调用一个方法，我知道它会抛出一个异常，该异常也是库的一部分。请注意，我通过反射调用该方法：由于该库不在我的 Eclipse 类路径中，因此我无法使用显式引用对其进行编译。

当我运行这个程序时（在 Linux 的 Sun JDK 1.5 下），我看到很多对 loadClass() 的调用，包括库中的类和类路径中的类。这是意料之中的：ParseUtil 类引用了许多其他类，并将使用 MyLoader（即它的类加载器）来加载它们。对于 MyLoader 无法在本地找到的那些类，它会委托加载器树。

抛出异常，当我打印出它的类加载器时，我看到它与我创建的 MyLoader 实例相同。我还打印了 Exception.class 的加载器，它是空的——Class.getClassLoader()的 JavaDoc说它表示引导类加载器。

import java.io.File;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;


public class ClassLoaderExample
{
    private static class MyClassLoader
    extends URLClassLoader
    {
        public MyClassLoader(String path)
        throws Exception
        {
            super(new URL[] { new File(path).toURL() });
        }

        @Override
        protected Class<?> findClass(String name) throws ClassNotFoundException
        {
            System.err.println("findClass(" + name + ")");
            return super.findClass(name);
        }

        @Override
        protected synchronized Class<?> loadClass(String name, boolean resolve)
            throws ClassNotFoundException
        {
            System.err.println("loadClass(" + name + "," + resolve + ")");
            return super.loadClass(name, resolve);
        }

        @Override
        public Class<?> loadClass(String name) throws ClassNotFoundException
        {
            System.err.println("loadClass(" + name + ")");
            return super.loadClass(name);
        }
    }


    public static void main(String[] argv)
    throws Exception
    {
        ClassLoader myLoader = new MyClassLoader("/home/kgregory/Workspace/PracticalXml-1.1/target/classes/");
        System.out.println("myLoader = " + myLoader);

        Class<?> parseUtilKlass = myLoader.loadClass("net.sf.practicalxml.ParseUtil");
        Method parseMethod = parseUtilKlass.getDeclaredMethod("parse", String.class);

        try
        {
            parseMethod.invoke(null, "not at all valid XML");
        }
        catch (InvocationTargetException e)
        {
            Throwable ee = e.getCause();
            System.out.println("exception:" + ee);
            System.out.println("exception loader = " + ee.getClass().getClassLoader());

            System.out.println("Exception.class loader = " + Exception.class.getClassLoader());
        }
    }
}

编辑#2，根据今天的评论。

类加载器应在尝试自己完成请求之前将请求委托给其父级（这在 ClassLoader JavaDoc 中）。这种做法有几个好处，首先是您不会无意中加载同一类的不兼容实例。

J2EE 类加载器修改了这个模型：用于加载 WAR 的类加载器将尝试在包含 EAR 的加载器之前解析类，而后者又尝试在容器的类加载器之前解析类。这里的目标是隔离：如果 WAR 和它的 EAR 都包含相同的库，这可能是因为两者需要不同的版本（或者他们有一个草率的构建过程）。即使在 J2EE 案例中，我也相信容器类加载器以标准方式进行委托。

于 2009-08-19T17:52:13.447 回答
1

在您的代码中，调用将super.loadClass()类的加载委托给父类加载器（只需查看 的实现java.lang.ClassLoader#loadClass）。因此DynClassLoader0，加载类的不是您的实例，而是currentThreadClassLoader您Thread.currentThread().getContextClassLoader()作为构造函数参数传递给DynClassLoader0. 当加载的类引用其他类时，它们也会由该类加载器加载，而不是你的DynClassLoader0.

于 2009-08-19T18:04:16.573 回答