我做了一个新的 ClassLoader并让它定义一个新的 Class ，这意味着新类应该在一个新的命名空间中，据我所知。奇怪的是，当我调用 Class.getPackage在新类上，它返回的对象与在我的主命名空间中的任何其他类上调用 getPackage 返回的对象完全相同。

根据JVM spec :

The runtime package of a class or interface is determined by the package name and defining class loader of the class or interface.

所以换句话说，如果你有两个类在同一个包中，但是被不同的类加载器加载，它们被认为是在不同的包中。 (这也可以通过下面我的测试用例中的反射来“确认”。)

那么当我这样做时，为什么我从两个类的 getPackage 得到了相同的结果？

这是我的测试:

package pkg;
import java.io.*;

// Yes, you can try commenting this class, you'll get the same result.
class LoadedClass {
    LoadedClass() {
        System.out.println("LoadedClass init");
    }
}

class MyClassLoader extends ClassLoader {
    Class<?> defineClass(String name, byte[] b) {
        return defineClass(name, b, 0, b.length);
    }
}

class Main {
    public static void main(String[] args) throws Exception {
        MyClassLoader mcl = new MyClassLoader();

        // load compiled class from file
        FileInputStream fileinputstream = new FileInputStream(
            "/home/me/test/pkg/LoadedClass.class" /* <- point to whever these classes
                                                   *    are being compiled to. */
        );
        int numberBytes = fileinputstream.available();
        byte classBytes[] = new byte[numberBytes];
        fileinputstream.read(classBytes);
        fileinputstream.close();

        Class<?> lc = mcl.defineClass("pkg.LoadedClass", classBytes);
        Package myPackage = Main.class.getPackage();
        Package lcPackage = lc.getPackage();
        System.out.println("lc package: " + lcPackage);
        System.out.println("my package: " + myPackage);
        System.out.println("lc ClassLoader: " + lc.getClassLoader());
        System.out.println("lc ClassLoader parent: " +
                           lc.getClassLoader().getParent());
        System.out.println("my ClassLoader: " + Main.class.getClassLoader());
        System.out.println("are they equal? " + (lcPackage == myPackage));
        if (lcPackage == myPackage) {
            System.out.println("okay... we should be able to instantiate " +
                               "the package if that's true, lets try");
            lc.newInstance(); // boom as expected
        }
    }
}

输出:

lc package: package pkg
my package: package pkg
lc ClassLoader: pkg.MyClassLoader@7987aeca
lc ClassLoader parent: sun.misc.Launcher$AppClassLoader@1f7182c1
my ClassLoader: sun.misc.Launcher$AppClassLoader@1f7182c1
are they equal? true
okay... we should be able to instantiate the package if that's true, lets try
Exception in thread "main" java.lang.IllegalAccessException: Class pkg.Main can not access a member of class pkg.LoadedClass with modifiers ""
    at sun.reflect.Reflection.ensureMemberAccess(Reflection.java:65)
    at java.lang.Class.newInstance0(Class.java:349)
    at java.lang.Class.newInstance(Class.java:308)
    at pkg.Main.main(Main.java:42)

正如预期的那样，您通常不能通过反射实例化这个加载的类，因为包私有(private)并且它位于不同的包中(相同的名称，不同的命名空间)，这是正确的 AFAIK，因为它是强制类型安全。

只是想知道，因为过去几天我一直在研究 JVM 和安全架构，并不断发现像这样的小细节，所以很难推理。

最佳答案

未指定 getPackage 方法。这是bug 4256589说:

ClassLoader.getPackage("foo") returns the package object defined for package foo in this particular class loader, or if this class loader didn't define package foo, the method returns what the parent class loader has defined for foo, if any.

对我来说，这表示 getPackage 返回的 Package 对象取决于类加载器是否“定义”了一个类包本身，或者它是否在它的类包中找到了该包父类加载器。而所看到的行为似乎与此一致。

这是相当不一致的。但是，是一个包对象还是多个包对象真的有什么区别吗？当然，类型安全或安全性应该没有任何区别……除非您在自定义类加载器或安全管理器中实现了一些特殊的基于包的安全方案。

关于java - 为什么 Class.getPackage 会为来自不同包的类返回相同的包？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/3455267/