我有两个类( A 和 B )由不同的 ClassLoaders 加载.此外，我还有第三个类，它提供静态 getter 和 setter 方法。我希望下面的图片可以说明情况:

Data类如下所示:

public class Data {

    private static String data = "<fill in>";

    public static void setData(String d) {
        data = d;
    }

    public static String getData() {
        return data;
    }
}

在类里面A , 我想设置 Data 的静态值在B我想检索这个值。然而，在 B我总是得到原始值(即 "<fill in>" )。我对ClassLoader只有一个基本的了解s，所以我不太确定引擎盖下发生了什么。我认为两个类加载器( clA 和 clB )都会传播到它们的父级 ClassLoader我会得到相同的 Data两者都上课。任何人都可以给我一些关于该行为的反馈或指出我要查看的方向吗？

更新

当我打印 hashCode()两者的 Data类，我为他们得到不同的值(这意味着我显然不能访​​问同一个类)。有没有简单的方法来说明 ClassLoader层次结构？

最佳答案

如果您的问题是如何说明或可视化对象的类加载器层次结构，那么您可以在代码中遍历每个类的类加载器。您提到您正在使用 groovy，因此示例如下:

def showObjectClassLoaderHierarchy(Object obj) {
    def classLoader = showClassLoaderHierarchy(obj.getClass().getClassLoader());
    showClassLoaderHierarchy(classLoader);
}

def showClassLoaderHierarchy(ClassLoader loader) {

    if (loader != null) {
        println "Classloader: " + loader.hashCode();
        while (loader.getParent() != null) {
              loader = loader.getParent();
          println "    Child of: " + loader.hashCode();
        }
    }

}

我想你会发现，在你的代码中，这两个数据对象实际上并不是从同一个类加载器加载的，这就是为什么它们有不同的静态变量。

我整理了一个样本

• Main(从父类加载器加载)
• 带有静态字符串的 DataObj(也从父类加载器加载)
• LoadA，它实例化 DataObj 的副本(从子类加载器 A 加载)
• LoadB，它实例化 DataObj 的副本(从子类加载器 B 加载)

我看到虽然 LoadA 和 LoadB 有不同的类加载器，但 DataObj 和静态变量来自一个公共(public)类加载器。

完整代码位于:https://github.com/lucasmcgregor/groovy_classloader_test

groovy 中的 Main 对象:

import java.lang.ClassLoader;
import java.net.URLClassLoader;
import java.net.URL;

def showObjectClassLoaderHierarchy(Object obj) {
        def classLoader = showClassLoaderHierarchy(obj.getClass().getClassLoader());
        showClassLoaderHierarchy(classLoader);
}

def showClassLoaderHierarchy(ClassLoader loader) {

        if (loader != null) {
            println "Classloader: " + loader.hashCode();
            while (loader.getParent() != null) {
                  loader = loader.getParent();
                  println "    Child of: " + loader.hashCode();
            }
        }

}

println "Setting up child classLoaders A and B...";

def URL[] urlsA = [new URL("file:///tmp/cla/")];
def classLoaderA = new URLClassLoader(urlsA, this.getClass().getClassLoader());

def URL[] urlsB = [new URL("file:///tmp/clb/")];
def classLoaderB = new URLClassLoader(urlsB, this.getClass().getClassLoader());


println "Classloader A heirachry:";
showClassLoaderHierarchy(classLoaderA);

println "Classloader B: ";
showClassLoaderHierarchy(classLoaderB);

println "";
println "Now loading Load classes A and B from seperate classloaders:";
def loadA = classLoaderA.loadClass("LoadA").newInstance();
def loadB = classLoaderB.loadClass("LoadB").newInstance();

print "LoadA: heirachry";
showObjectClassLoaderHierarchy(loadA);
print "LoadB: heirachry";
showObjectClassLoaderHierarchy(loadB);

println "";
println "Now pulling the data objects from both and comparing classloders and static data: ";
def dobjA = loadA.getDataObj();
def dobjB = loadB.getDataObj();

println "dataA static field:" + dobjA.getData();
println "dataA static field hashcode: " + dobjA.getData().hashCode();
println "dataA hashcode: " + dobjA.hashCode();
println "dataA classloader: ";
showObjectClassLoaderHierarchy(dobjA);

println "dataB static field: " + dobjB.getData();
println "dataB static field hashcode: " + dobjB.getData().hashCode();
println "dataB hashcode: " + dobjB.hashCode();
println "dataB classLoader:";
showObjectClassLoaderHierarchy(dobjB);

结果是:

Setting up child classLoaders A and B...
Classloader A heirachry:
Classloader: 1926764753
    Child of: 1163157884
    Child of: 1022308509
Classloader B:
Classloader: 846238611
    Child of: 1163157884
    Child of: 1022308509

Now loading Load classes A and B from seperate classloaders:
LoadA: heirachryClassloader: 1926764753
    Child of: 1163157884
    Child of: 1022308509
LoadB: heirachryClassloader: 846238611
    Child of: 1163157884
    Child of: 1022308509

Now pulling the data objects from both and comparing classloders and static data:
dataA static field:Loaded By B
dataA static field hashcode: 1828548084
dataA hashcode: 2083117811
dataA classloader:
Classloader: 1163157884
    Child of: 1022308509
dataB static field: Loaded By B
dataB static field hashcode: 1828548084
dataB hashcode: 157683534
dataB classLoader:
Classloader: 1163157884
    Child of: 1022308509

您看到 LoadA 和 LoadB 都有不同的类加载器，但它们共享一个父类加载器。

父类加载器为 LoadA.dataObj 和 LoadB.dataObj 的两个实例加载 DataObj。

LoadA.dataObj 和 LoadB.dataObj 具有不同的哈希码。

但是，LoadA.dataObj.data 和 LoadB.dataObj.data 具有相同的哈希码，因为这是静态对象。它们也具有相同的值。 LoadB 最后实例化它的 dataObj 并将字符串设置为“Loaded By B”

关于java - 从不同类加载器加载的类访问静态方法，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/27218177/