ClassLoader 源码分析。

81 阅读 0 评论 54 点赞

我是靠谱客的博主美丽雪碧，这篇文章主要介绍ClassLoader 源码分析。，现在分享给大家，希望可以做个参考。

复制代码

/**
* 类加载器是负责加载类的对象。ClassLoader 类是一个抽象类。
* 如果给定类的二进制名称，那么类加载器会试图查找或生成构成类定义的数据。
* 一般策略是将名称转换为某个文件名，然后从文件系统读取该名称的“类文件”。
* 每个 Class 对象都包含一个对定义它的 ClassLoader 的引用。
* 数组类的 Class 对象不是由类加载器创建的，而是由 Java 运行时根据需要自动创建。
* 数组类的类加载器由 Class.getClassLoader() 返回，该加载器与其元素类型的类加载器是相同的；
* 如果该元素类型是基本类型，则该数组类没有类加载器。
* 应用程序需要实现 ClassLoader 的子类，以扩展 Java 虚拟机动态加载类的方式。
* 类加载器通常由安全管理器使用，用于指示安全域。
* ClassLoader 类使用委托模型来搜索类和资源。每个 ClassLoader 实例都有一个相关的父类加载器。
* 需要查找类或资源时，ClassLoader 实例会在试图亲自查找类或资源之前，将搜索类或资源的任务委托给其父类加载器。
* 虚拟机的内置类加载器（称为 "bootstrap class loader"）本身没有父类加载器，
* 但是可以将它用作 ClassLoader 实例的父类加载器。
* 通常情况下，Java 虚拟机以与平台有关的方式，从本地文件系统中加载类。
* 例如，在 UNIX 系统中，虚拟机从 CLASSPATH 环境变量定义的目录中加载类。
* 然而，有些类可能并非源自一个文件；它们可能源自其他来源（如网络），也可能是由应用程序构造的。
* defineClass 方法将一个 byte 数组转换为 Class 类的实例。
* 这种新定义的类的实例可以使用 Class.newInstance 来创建。
* 类加载器所创建对象的方法和构造方法可以引用其他类。
* 为了确定引用的类，Java 虚拟机将调用最初创建该类的类加载器的 loadClass 方法。
*/
public abstract class ClassLoader {
// 要为类注册本地函数，RegisterNatives从本地的库中的本机代码调用JNI函数。
private static native void registerNatives();
static {
registerNatives();
}
/*
* 委托的父类装入器
* 注意:虚拟机硬编码这个字段的偏移量,
* 因此，所有新字段必须在*after*添加。
*/
private final ClassLoader parent;
/**
* 封装可并行加载器类型集
*/
private static class ParallelLoaders {
private ParallelLoaders() {}
// 一组具有并行能力的加载器类型
private static final Set<Class<? extends ClassLoader>> loaderTypes =
Collections.newSetFromMap(
new WeakHashMap<Class<? extends ClassLoader>, Boolean>());
static {
synchronized (loaderTypes) { loaderTypes.add(ClassLoader.class); }
}
/**
* 将给定的类加载器类型注册为并行capabale。
* 成功注册返回true;
* 如果加载器的超类未注册，则为false。
*/
static boolean register(Class<? extends ClassLoader> c) {
synchronized (loaderTypes) {
if (loaderTypes.contains(c.getSuperclass())) {
/*
* 注册类加载器为并行的，当且仅当它的所有超类都是并行的。
* 注:给定当前类加载顺序，如果直接超类是并行的，
* 上面的所有超类也必须是。
*/
loaderTypes.add(c);
return true;
} else {
return false;
}
}
}
/**
* 如果指定的类加载器类型注册为并行的，则返回{true}。
*/
static boolean isRegistered(Class<? extends ClassLoader> c) {
synchronized (loaderTypes) {
return loaderTypes.contains(c);
}
}
}
/*
* 当当前类加载器具有并行能力时，将类名映射到相应的锁对象。
* 注意:VM还使用这个字段来决定当前类加载器是否具有并行能力，以及加载类的适当锁定对象。
*/
private final ConcurrentHashMap<String, Object> parallelLockMap;
// 将包映射到certs的哈希表
private final Map <String, Certificate[]> package2certs;
// 在所有无签名类的包之间共享
private static final Certificate[] nocerts = new Certificate[0];
/*
* 由这类加载器加载的类。
* 此表的唯一目的是在加载器GC之前防止类被GC。
*/
private final Vector<Class<?>> classes = new Vector<>();
/*
* “默认”domain。
* 设置为新创建的类的默认ProtectionDomain。
*/
private final ProtectionDomain defaultDomain =
new ProtectionDomain(new CodeSource(null, (Certificate[]) null),
null, this, null);
// 此加载程序加载的所有类的初始化保护domain
private final Set<ProtectionDomain> domains;
/**
* VM调用它来记录使用此加载器加载的每个类。
* @param c
*/
void addClass(Class<?> c) {
classes.addElement(c);
}
/*
* 类加载器中定义的包。
* 每个包名映射到对应的包对象。
*/
private final HashMap<String, Package> packages = new HashMap<>();
/**
* 检查创建新类加载器的权限
* @return
*/
private static Void checkCreateClassLoader() {
// 获取系统安全接口
SecurityManager security = System.getSecurityManager();
if (security != null) {
// 判断是否有调用线程创建新类加载器的权限，不允许，则抛SecurityException
security.checkCreateClassLoader();
}
return null;
}
/**
* 私有构造器
* @param unused
* @param parent
*/
private ClassLoader(Void unused, ClassLoader parent) {
this.parent = parent;
// 如果指定的类加载器类型注册为并行的，则返回true。
if (ParallelLoaders.isRegistered(this.getClass())) {
parallelLockMap = new ConcurrentHashMap<>();
package2certs = new ConcurrentHashMap<>();
domains =
Collections.synchronizedSet(new HashSet<ProtectionDomain>());
assertionLock = new Object();
} else {
// 没有更细粒度的锁;锁定类加载器实例
parallelLockMap = null;
package2certs = new Hashtable<>();
domains = new HashSet<>();
assertionLock = this;
}
}
/**
* 使用指定的、用于委托操作的父类加载器创建新的类加载器。
* 如果存在安全管理器，则调用其 checkCreateClassLoader 方法。这可能导致安全性异常。
* @param parent	父类加载器
*/
protected ClassLoader(ClassLoader parent) {
this(checkCreateClassLoader(), parent);
}
/**
* 使用方法 getSystemClassLoader() 返回的 ClassLoader 创建一个新的类加载器，将该加载器作为父类加载器。
* 如果存在安全管理器，则调用其 checkCreateClassLoader 方法。这可能导致安全性异常。
*/
protected ClassLoader() {
this(checkCreateClassLoader(), getSystemClassLoader());
}
// -- Class --
/**
* 使用指定的二进制名称来加载类。此方法使用与 loadClass(String, boolean) 方法相同的方式搜索类。
* Java 虚拟机调用它来分析类引用。调用此方法等效于调用 loadClass(name, false)。
* @param name	类的二进制名称
* @return
* @throws ClassNotFoundException
*/
public Class<?> loadClass(String name) throws ClassNotFoundException {
return loadClass(name, false);
}
/**
* 使用指定的二进制名称来加载类。此方法的默认实现将按以下顺序搜索类：
* 调用 findLoadedClass(String) 来检查是否已经加载类。
* 在父类加载器上调用 loadClass 方法。如果父类加载器为 null，则使用虚拟机的内置类加载器。
* 调用 findClass(String) 方法查找类。
* 如果使用上述步骤找到类，并且 resolve 标志为真，则此方法将在得到的 Class 对象上调用 resolveClass(Class) 方法。
* 鼓励用 ClassLoader 的子类重写 findClass(String)，而不是使用此方法。
* @param name	类的二进制名称
* @param resolve	如果该参数为 true，则分析这个类
* @return
* @throws ClassNotFoundException
*/
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
synchronized (getClassLoadingLock(name)) {
// 首先，判断该类型是否已经被加载
Class<?> c = findLoadedClass(name);
if (c == null) { // 如果没有被加载，就委托给父类加载或者委派给启动类加载其加载
// 获取最准确的可用系统计时器的当前值，以毫微秒为单位
long t0 = System.nanoTime();
try {
if (parent != null) {
// 如果存在父类加载器，就委派给父类加载器加载
// 使用父类的加载器来加载类。
c = parent.loadClass(name, false);
} else {
// 如果不存在父类加载器，就检查是否是由启动类加载器加载的类，通过调用本地方法findBootstrapClass
c = findBootstrapClassOrNull(name);
}
} catch (ClassNotFoundException e) {
// 如果父类加载器和启动类加载器都不能完成加载任务，才调用自身的加载功能
}
if (c == null) {
// 如果仍然没有找到，然后调用findClass来查找该类。
long t1 = System.nanoTime();
c = findClass(name);
// 这是定义类加载器;记录数据
sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
sun.misc.PerfCounter.getFindClasses().increment();
}
}
if (resolve) { // 链接指定的类。
resolveClass(c);
}
return c;
}
}
/**
* 返回类加载操作的锁对象。
* 为了向后兼容，此方法的默认实现的行为如下。
* 如果这个类加载器对象被注册为并行的，该方法返回与指定类名关联的专用对象。否则,该方法返回这个类加载器对象。
* @param className	要加载的类的名称
* @return	类加载操作的锁
*/
protected Object getClassLoadingLock(String className) {
Object lock = this;
if (parallelLockMap != null) {
Object newLock = new Object();
// 如果指定键已经不再与某个值相关联，则将它与给定值关联。
lock = parallelLockMap.putIfAbsent(className, newLock);
if (lock == null) {
lock = newLock;
}
}
return lock;
}
/**
* 虚拟机调用此方法来加载类。
* @param name	类的二进制名称
* @return
* @throws ClassNotFoundException
*/
private Class<?> loadClassInternal(String name)
throws ClassNotFoundException
{
// 为了向后兼容，当当前类加载器不支持并行时，显式锁定“this”。
if (parallelLockMap == null) {
synchronized (this) {
return loadClass(name);
}
} else {
return loadClass(name);
}
}
/**
* 在使用此加载器加载类之后由VM调用。
* @param cls
* @param pd
*/
private void checkPackageAccess(Class<?> cls, ProtectionDomain pd) {
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
// 是否有保护域拥有权限
if (ReflectUtil.isNonPublicProxyClass(cls)) {
for (Class<?> intf: cls.getInterfaces()) {
checkPackageAccess(intf, pd);
}
return;
}
final String name = cls.getName();
final int i = name.lastIndexOf('.');
if (i != -1) {
/*
* 通过指定的 AccessControlContext 启用和限制特权，执行指定的 PrivilegedAction。
* 该操作在调用方保护域所拥有权限与指定的 AccessControlContext 表示的域所拥有权限的交集下执行。
*/
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
// 如果不允许调用线程访问由参数指定的包，则抛出 SecurityException。
sm.checkPackageAccess(name.substring(0, i));
return null;
}
// 创建带有给定 ProtectionDomain 集合的 AccessControlContext。上下文不能为 null。重复的域将从上下文中被移除。
}, new AccessControlContext(new ProtectionDomain[] {pd}));
}
}
domains.add(pd);
}
/**
* 使用指定的二进制名称查找类。此方法应该被类加载器的实现重写，该实现按照委托模型来加载类。
* 在通过父类加载器检查所请求的类后，此方法将被 loadClass 方法调用。
* @param name	类的二进制名称
* @return
* @throws ClassNotFoundException
*/
protected Class<?> findClass(String name) throws ClassNotFoundException {
throw new ClassNotFoundException(name);
}
/**
* 将一个 byte 数组转换为 Class 类的实例。必须分析 Class，然后才能使用它。
* 此方法将默认的 ProtectionDomain 分配给新定义的类。
* 调用 Policy.getPolicy().getPermissions(new CodeSource(null, null)) 时，
* ProtectionDomain 被有效授予所返回的相同权限集。
* 默认域在第一次调用 defineClass 时创建，并在后续调用时被重用。
* 要将特定的 ProtectionDomain 分配给类，需要使用 defineClass 方法，
* 该方法将 ProtectionDomain 用作其参数之一。
* @param name	所需要的类的二进制名称，如果不知道此名称，则该参数为 null
* @param b	组成类数据的字节。
* @param off	类数据的 b 中的起始偏移量
* @param len	类数据的长度
* @return
* @throws ClassFormatError
*/
protected final Class<?> defineClass(String name, byte[] b, int off, int len)
throws ClassFormatError
{
return defineClass(name, b, off, len, null);
}
/**
* 确定ProtectionDomain，并检查。
* @param name
* @param pd
* @return
*/
private ProtectionDomain preDefineClass(String name,
ProtectionDomain pd)
{
//如果名称为null或可能为有效二进制名称，则为true
if (!checkName(name))
throw new NoClassDefFoundError("IllegalName: " + name);
// 指定的 name 不能以 "java." 开头，因为 "java.*" 包中的所有类都只能由引导类加载器定义。
if ((name != null) && name.startsWith("java.")) {
throw new SecurityException
("Prohibited package name: " +
name.substring(0, name.lastIndexOf('.')));
}
if (pd == null) {
pd = defaultDomain;
}
// 如果 name 不是 null，则它必定等于由 byte 数组 "b" 指定的类的二进制名称
if (name != null) checkCerts(name, pd.getCodeSource());
return pd;
}
/**
* 获取与此 域的CodeSource 关联的位置
* @param pd
* @return
*/
private String defineClassSourceLocation(ProtectionDomain pd)
{
// 获取此域的 CodeSource。
CodeSource cs = pd.getCodeSource();
String source = null;
if (cs != null && cs.getLocation() != null) {
// 获取与此 CodeSource 关联的位置
source = cs.getLocation().toString();
}
return source;
}
/**
* 从该类的 ProtectionDomain 中的 CodeSource 可以获得类的证书集合。
* 添加到该包中的任何类都必须包含相同的证书集合
* @param c
* @param pd
*/
private void postDefineClass(Class<?> c, ProtectionDomain pd)
{
if (pd.getCodeSource() != null) {
// 获取与此 CodeSource 关联的证书。
Certificate certs[] = pd.getCodeSource().getCertificates();
if (certs != null)
// 设置类的签署者
setSigners(c, certs);
}
}
/**
* 使用可选的 ProtectionDomain 将一个 byte 数组转换为 Class 类的实例。
* 如果该域为 null，则将默认域分配给 defineClass(String, byte[], int, int) 的文档中指定的类。
* 这个类必须分析后才能使用。
* 包中定义的第一个类确定在该包中定义的所有后续类必须包含的证书的确切集合。
* 从该类的 ProtectionDomain 中的 CodeSource 可以获得类的证书集合。
* 添加到该包中的任何类都必须包含相同的证书集合，否则抛出 SecurityException 异常。
* 注意，如果 name 为 null，则不执行该检查。应该始终传入要定义的类的二进制名称以及字节。
* 这可确保定义该类的正确性。
* 指定的 name 不能以 "java." 开头，因为 "java.*" 包中的所有类都只能由引导类加载器定义。
* 如果 name 不是 null，则它必定等于由 byte 数组 "b" 指定的类的二进制名称，
* 否则将抛出 NoClassDefFoundError。
* @param name	所需类的二进制名称，如果不知道此名称，则该参数为 null
* @param b	组成类数据的字节。
* @param off	类数据的 b 中的起始偏移量
* @param len	类数据的长度
* @param protectionDomain	类的 ProtectionDomain
* @return
* @throws ClassFormatError
*/
protected final Class<?> defineClass(String name, byte[] b, int off, int len,
ProtectionDomain protectionDomain)
throws ClassFormatError
{
// 确定ProtectionDomain，分析
protectionDomain = preDefineClass(name, protectionDomain);
// 获取与此 域的CodeSource 关联的位置
String source = defineClassSourceLocation(protectionDomain);
// 获取class对象，通过b为byte[]
Class<?> c = defineClass1(name, b, off, len, protectionDomain, source);
// 从该类的 ProtectionDomain 中的 CodeSource 可以获得类的证书集合。
// 添加到该包中的任何类都必须包含相同的证书集合
postDefineClass(c, protectionDomain);
return c;
}
/**
* 使用可选的 ProtectionDomain 将 ByteBuffer 转换为 Class 类的实例。
* 如果该域为 null，则将默认域分配给 defineClass(String, byte[], int, int) 的文档中指定的类。
* 这个类必须分析后才能使用。
* 有关包中定义的第一个类（它确定了包的证书集合）的规则，以及对类名称的限制，
* 都与 defineClass(String, byte[], int, int, ProtectionDomain) 的文档中指定的相同。
* @param name	所需要的类的二进制名称，如果不知道此名称，则该参数为 null
* @param b	组成类数据的字节。
* @param protectionDomain	类的 ProtectionDomain，或为 null。
* @return
* @throws ClassFormatError
*/
protected final Class<?> defineClass(String name, java.nio.ByteBuffer b,
ProtectionDomain protectionDomain)
throws ClassFormatError
{
// 获取此缓冲区中的剩余元素数
int len = b.remaining();
// 如果不是直接ByteBufer，请使用byte[]:
// 判断此缓冲区是否为直接缓冲区。
if (!b.isDirect()) {
// 判断当且仅当此缓冲区有非只读的底层实现数组时返回 true。
if (b.hasArray()) {
return defineClass(name, b.array(),
b.position() + b.arrayOffset(), len,
protectionDomain);
} else {
// 不是数组, 或者 只读数组
byte[] tb = new byte[len];
b.get(tb);
//从字节缓冲区获取字节。
return defineClass(name, tb, 0, len, protectionDomain);
}
}
// 确定ProtectionDomain，并检查。
protectionDomain = preDefineClass(name, protectionDomain);
// 获取与此 域的CodeSource 关联的位置
String source = defineClassSourceLocation(protectionDomain);
// 获取class对象，通过b为nio.ByteBuffer字节缓冲
Class<?> c = defineClass2(name, b, b.position(), len, protectionDomain, source);
// 从该类的 ProtectionDomain 中的 CodeSource 可以获得类的证书集合。
// 添加到该包中的任何类都必须包含相同的证书集合
postDefineClass(c, protectionDomain);
return c;
}
private native Class<?> defineClass0(String name, byte[] b, int off, int len,
ProtectionDomain pd);
private native Class<?> defineClass1(String name, byte[] b, int off, int len,
ProtectionDomain pd, String source);
private native Class<?> defineClass2(String name, java.nio.ByteBuffer b,
int off, int len, ProtectionDomain pd,
String source);
/**
* 如果名称为null或可能为有效二进制名称，则为true
* @param name
* @return
*/
private boolean checkName(String name) {
if ((name == null) || (name.length() == 0))
return true;
if ((name.indexOf('/') != -1)
|| (!VM.allowArraySyntax() && (name.charAt(0) == '[')))
return false;
return true;
}
/**
* 检查name是否等于由 byte 数组 "b" 指定的类的二进制名称
* @param name
* @param cs
*/
private void checkCerts(String name, CodeSource cs) {
int i = name.lastIndexOf('.');
String pname = (i == -1) ? "" : name.substring(0, i);
Certificate[] certs = null;
if (cs != null) {
// // 获取与此 CodeSource 关联的证书。
certs = cs.getCertificates();
}
Certificate[] pcerts = null;
if (parallelLockMap == null) {
// 放入与当前类加载器关联的package2certs中
synchronized (this) {
pcerts = package2certs.get(pname);
if (pcerts == null) {
package2certs.put(pname, (certs == null? nocerts:certs));
}
}
} else {
// 如果指定键已经不再与某个值相关联，则将它与给定值关联。
pcerts = ((ConcurrentHashMap<String, Certificate[]>)package2certs).
putIfAbsent(pname, (certs == null? nocerts:certs));
}
// 检查以确保新类(certs)的证书与包中插入的第一个类(pcerts)的证书相同
if (pcerts != null && !compareCerts(pcerts, certs)) {
throw new SecurityException("class ""+ name +
""'s signer information does not match signer information of other classes in the same package");
}
}
/**
* 检查以确保新类(certs)的证书与包中插入的第一个类(pcerts)的证书相同
* @param pcerts
* @param certs
* @return
*/
private boolean compareCerts(Certificate[] pcerts,
Certificate[] certs)
{
// certs 可以为null, 表示没有certs
if ((certs == null) || (certs.length == 0)) {
return pcerts.length == 0;
}
// 这一点的长度必须相同
if (certs.length != pcerts.length)
return false;
// 检查并确保一个数组中的所有certs都在另一个数组中，反之亦然。
boolean match;
for (int i = 0; i < certs.length; i++) {
match = false;
for (int j = 0; j < pcerts.length; j++) {
if (certs[i].equals(pcerts[j])) {
match = true;
break;
}
}
if (!match) return false;
}
// 现在对pcert做同样的事情
for (int i = 0; i < pcerts.length; i++) {
match = false;
for (int j = 0; j < certs.length; j++) {
if (pcerts[i].equals(certs[j])) {
match = true;
break;
}
}
if (!match) return false;
}
return true;
}
/**
* 链接指定的类。类加载器可以使用此方法（其名称容易使人误解）来链接类。
* 如果已经链接类 c，则仅返回此方法。
* @param c	要链接的类
*/
protected final void resolveClass(Class<?> c) {
resolveClass0(c);
}
private native void resolveClass0(Class<?> c);
/**
* 查找具有指定的二进制名称的类，必要时加载它。
* 此方法通过系统类加载器（参见 getSystemClassLoader()）来加载该类。
* 返回的 Class 对象具有多个与之相关联的 ClassLoader。ClassLoader 的子类通常不必调用此方法，
* 因为大多数类加载器只需重写 findClass(String) 即可。
* @param name	类的二进制名称
* @return	指定 name 的 Class 对象
* @throws ClassNotFoundException
*/
protected final Class<?> findSystemClass(String name)
throws ClassNotFoundException
{
// 获取委托的系统类加载器。
ClassLoader system = getSystemClassLoader();
if (system == null) {
// 如果名称为null或可能为有效二进制名称，则为true
if (!checkName(name))
throw new ClassNotFoundException(name);
Class<?> cls = findBootstrapClass(name);
if (cls == null) {
throw new ClassNotFoundException(name);
}
return cls;
}
// 使用指定的二进制名称来加载类。
return system.loadClass(name);
}
/**
* 使用虚拟机的内置类加载器加载类
* @param name
* @return
*/
private Class<?> findBootstrapClassOrNull(String name)
{
// 如果名称为null或可能为有效二进制名称，则为true
if (!checkName(name)) return null;
return findBootstrapClass(name);
}
// 如果没有找到，返回null
private native Class<?> findBootstrapClass(String name);
/**
* 如果 Java 虚拟机已将此加载器记录为具有给定二进制名称的某个类的启动加载器，
* 则返回该二进制名称的类。否则，返回 null。
* @param name	类的二进制名称
* @return	Class 对象，如果类没有被加载，则返回 null
*/
protected final Class<?> findLoadedClass(String name) {
// 如果名称为null或可能为有效二进制名称，则为true
if (!checkName(name))
return null;
return findLoadedClass0(name);
}
private native final Class<?> findLoadedClass0(String name);
/**
* 设置类的签署者。应该在定义类后调用此方法。
* @param c	Class 对象
* @param signers	类的签署者
*/
protected final void setSigners(Class<?> c, Object[] signers) {
c.setSigners(signers);
}
// -- Resource --
/**
* 查找具有给定名称的资源。资源是可以通过类代码以与代码基无关的方式访问的一些数据（图像、声音、文本等）。
*
资源名称是以 '/' 分隔的标识资源的路径名称。 此方法首先搜索资源的父类加载器；
*
如果父类加载器为 null，则搜索的路径就是虚拟机的内置类加载器的路径。
*
如果搜索失败，则此方法将调用 findResource(String) 来查找资源。
* @param name	资源名称
* @return	读取资源的 URL 对象；如果找不到该资源，或者调用者没有足够的权限获取该资源，则返回 null。
*/
public URL getResource(String name) {
URL url;
// 搜索资源的父类加载器；
if (parent != null) {
url = parent.getResource(name);
} else {
// 如果父类加载器为 null，则搜索的路径就是虚拟机的内置类加载器的路径。
url = getBootstrapResource(name);
}
if (url == null) {
// 查找资源
url = findResource(name);
}
return url;
}
/**
* 查找所有给定名称的资源。资源是可以通过类代码以与代码基无关的方式访问的某些数据（图像、声音、文本等）。
* 资源名称是以 '/' 分隔的标识资源的路径名称。
* @param name	资源名称
* @return	资源的 URL 对象的枚举。如果找不到资源，则该枚举将为空。类加载器无权访问的资源不在此枚举中。
* @throws IOException
*/
public Enumeration<URL> getResources(String name) throws IOException {
@SuppressWarnings("unchecked")
Enumeration<URL>[] tmp = (Enumeration<URL>[]) new Enumeration<?>[2];
// 搜索资源的父类加载器；
if (parent != null) {
tmp[0] = parent.getResources(name);
} else {
// 如果父类加载器为 null，则搜索的路径就是虚拟机的内置类加载器的路径。
tmp[0] = getBootstrapResources(name);
}
// 查找资源
tmp[1] = findResources(name);
return new CompoundEnumeration<>(tmp);
}
/**
* 查找具有给定名称的资源。类加载器实现应该重写此方法，以指定从何处查找资源。
* @param name	资源名称
* @return	用于读取资源的 URL 对象；如果无法找到资源，则返回 null
*/
protected URL findResource(String name) {
return null;
}
/**
* 返回表示所有具有给定名称的资源的 URL 对象的枚举。类加载器实现应该重写此方法，以指定从何处加载资源。
* @param name	资源名称
* @return	资源的 URL 对象的枚举
* @throws IOException
*/
protected Enumeration<URL> findResources(String name) throws IOException {
return java.util.Collections.emptyEnumeration();
}
/**
* 将调用者注册为并行的。
* 注册成功当且仅当满足以下所有条件:
* 1. 没有创建调用者的实例
* 2. 调用者的所有超类(类对象除外)都被注册为并行的
* 请注意，一旦类装入器被注册为具有并行能力，就无法将其更改回来。
* @return 如果调用方成功注册为具有并行能力，则为true;如果调用方注册为具有并行能力，则为false。
*/
@CallerSensitive
protected static boolean registerAsParallelCapable() {
Class<? extends ClassLoader> callerClass =
Reflection.getCallerClass().asSubclass(ClassLoader.class);
// 将给定的类装入器类型注册为并行capabale。
return ParallelLoaders.register(callerClass);
}
/**
* 从用来加载类的搜索路径中查找具有指定名称的资源。
* 此方法通过系统类加载器（参见 getSystemClassLoader()）来查找资源。
* @param name	资源名称
* @return	用于读取资源的 URL 对象，如果找不到资源，则返回 null
*/
public static URL getSystemResource(String name) {
// 获取委托的系统类加载器。
ClassLoader system = getSystemClassLoader();
if (system == null) {
// 获取虚拟机的内置类加载器。
return getBootstrapResource(name);
}
// 查找具有给定名称的资源。
return system.getResource(name);
}
/**
* 从用来加载类的搜索路径中查找所有具有指定名称的资源。
* 找到的资源作为 URL 对象的 Enumeration 返回。
* @param name	资源名称
* @return	资源 URL 对象的枚举
* @throws IOException
*/
public static Enumeration<URL> getSystemResources(String name)
throws IOException
{
// 获取委托的系统类加载器。
ClassLoader system = getSystemClassLoader();
if (system == null) {
// 获取虚拟机的内置类加载器。
return getBootstrapResources(name);
}
// 查找具有给定名称的资源。
return system.getResources(name);
}
/**
* 从VM的内置类加载器中查找资源。
* @param name	资源名称
* @return 用于读取资源的 URL 对象，如果找不到资源，则返回 null
*/
private static URL getBootstrapResource(String name) {
// 返回用于查找系统资源的URLClassPath。
URLClassPath ucp = getBootstrapClassPath();
Resource res = ucp.getResource(name);
return res != null ? res.getURL() : null;
}
/**
* 从VM的内置类加载器中查找资源。
* @param name	资源名称
* @return	资源 URL 对象的枚举
* @throws IOException
*/
private static Enumeration<URL> getBootstrapResources(String name)
throws IOException
{
final Enumeration<Resource> e =
getBootstrapClassPath().getResources(name);
return new Enumeration<URL> () {
public URL nextElement() {
return e.nextElement().getURL();
}
public boolean hasMoreElements() {
return e.hasMoreElements();
}
};
}
/**
* 返回用于查找系统资源的URLClassPath。
* @return
*/
static URLClassPath getBootstrapClassPath() {
return sun.misc.Launcher.getBootstrapClassPath();
}
/**
* 返回读取指定资源的输入流。
* @param name	资源名称
* @return	用于读取资源的输入流，如果无法找到资源，则返回 null
*/
public InputStream getResourceAsStream(String name) {
// 查找具有给定名称的资源。
URL url = getResource(name);
try {
return url != null ? url.openStream() : null;
} catch (IOException e) {
return null;
}
}
/**
* 从用来加载类的搜索路径打开具有指定名称的资源，以读取该资源。
* @param name	资源名称
* @return	用于读取资源的输入流，如果无法找到资源，则返回 null
*/
public static InputStream getSystemResourceAsStream(String name) {
// 从用来加载类的搜索路径中查找具有指定名称的资源。
URL url = getSystemResource(name);
try {
return url != null ? url.openStream() : null;
} catch (IOException e) {
return null;
}
}
// -- Hierarchy --
/**
* 返回委托的父类加载器。一些实现可能使用 null 来表示引导类加载器。
* 如果类加载器的父类加载器就是引导类加载器，则此方法将在这样的实现中返回 null。
* 如果存在安全管理器，且调用者的类加载器既不是 null，也不是此类加载器的祖先，
* 那么此方法将使用 RuntimePermission("getClassLoader") 权限调用安全管理器的 checkPermission 方法，
* 以检验是否允许访问该类的父类加载器。如果无此权限，则抛出 SecurityException 异常。
* @return
*/
@CallerSensitive
public final ClassLoader getParent() {
if (parent == null)
return null;
// 获取系统安全接口
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
/*
* 检查对父类加载器的访问，
* 如果调用方的类加载器与此类加载器相同，执行权限检查。
*/
checkClassLoaderPermission(parent, Reflection.getCallerClass());
}
return parent;
}
/**
* 返回委托的系统类加载器。该加载器是新的 ClassLoader 实例的默认委托父类加载器，
* 通常是用来启动应用程序的类加载器。
* 在运行时启动序列的早期首先调用此方法，这时会创建系统类加载器并将其设置为调用 Thread 的上下文类加载器。
* 默认的系统类加载器是此类的一个与实现有关的实例。
* 如果在第一次调用此方法时定义系统属性 "java.system.class.loader"，
* 那么该属性的值就是将作为系统类加载器返回的那个类的名称。
* 该类是使用默认系统类加载器进行加载的，它必须定义一个公共的构造方法，
* 此构造方法带有用作委托父类加载器的 ClassLoader 类型的单个参数。
* 然后可以使用将默认系统类加载器用作参数的此构造方法创建一个实例。得到的类加载器被定义为系统类加载器。
* 如果存在安全管理器，且调用者的类加载器既不是 null，也不同于或不是系统类加载器的祖先，
* 那么该方法将使用 RuntimePermission("getClassLoader") 权限调用安全管理器的 checkPermission 方法，
* 以检验系统类加载器的访问权。如果无此权限，则抛出 SecurityException 异常。
* @return	委托的系统 ClassLoader，如果没有这样的类加载器，则返回 null
*/
@CallerSensitive
public static ClassLoader getSystemClassLoader() {
// 创建系统类加载器
initSystemClassLoader();
if (scl == null) {
return null;
}
// 获取系统安全接口
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
/*
* 检查对父类加载器的访问，
* 如果调用方的类加载器与此类加载器相同，执行权限检查。
*/
checkClassLoaderPermission(scl, Reflection.getCallerClass());
}
return scl;
}
/**
*
创建系统类加载器
*/
private static synchronized void initSystemClassLoader() {
if (!sclSet) {
if (scl != null)
throw new IllegalStateException("recursive invocation");
sun.misc.Launcher l = sun.misc.Launcher.getLauncher();
if (l != null) {
Throwable oops = null;
// 返回类加载器
scl = l.getClassLoader();
try {
// 启用特权，执行指定的 PrivilegedAction。
scl = AccessController.doPrivileged(
new SystemClassLoaderAction(scl));
} catch (PrivilegedActionException pae) {
// 返回此异常的原因
oops = pae.getCause();
if (oops instanceof InvocationTargetException) {
oops = oops.getCause();
}
}
if (oops != null) {
if (oops instanceof Error) {
throw (Error) oops;
} else {
// 包装异常
throw new Error(oops);
}
}
}
sclSet = true;
}
}
/**
* 如果指定的类加载器可以在该类加载器的委托链中找到，则返回true。
* @param cl
* @return
*/
boolean isAncestor(ClassLoader cl) {
ClassLoader acl = this;
do {
acl = acl.parent;
if (cl == acl) {
return true;
}
} while (acl != null);
return false;
}
/**
* 测试类加载器访问是否需要“getClassLoader”权限检查。
* 类加载器'from'可以访问类加载器'to'，如果类加载器'from'与类加载器'to'或'to'的祖先相同的话。
* system domain中的类加载器可以访问任何类加载器。
* @param from
* @param to
* @return
*/
private static boolean needsClassLoaderPermissionCheck(ClassLoader from,
ClassLoader to)
{
if (from == to)
return false;
if (from == null)
return false;
// 如果指定的类加载器可以在该类加载器的委托链中找到，则返回true。
return !to.isAncestor(from);
}
/**
* 返回类加载器
* @param caller
* @return
*/
static ClassLoader getClassLoader(Class<?> caller) {
// 如果VM请求它，它可以是null
if (caller == null) {
return null;
}
// 绕过安全检查，因为这是包私有的
return caller.getClassLoader0();
}
/**
* 如果调用者的类加载器不为空，且调用者的类加载器与给定cl参数不相同或不是其祖先，
* 则检查运行时权限(“getClassLoader”)权限。
* @param cl
* @param caller
*/
static void checkClassLoaderPermission(ClassLoader cl, Class<?> caller) {
// 获取系统安全接口
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
//如果VM正在请求调用者，则调用者可以为空
ClassLoader ccl = getClassLoader(caller);
if (needsClassLoaderPermissionCheck(ccl, cl)) {
sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);
}
}
}
/*
* 系统的类加载器
*
@GuardedBy (“ClassLoader.class”)
*/
private static ClassLoader scl;
/*
* 一旦系统类加载器被设置为true
* @GuardedBy (“ClassLoader.class”)
*/
private static boolean sclSet;
// -- Package --
/**
* 根据 name 在此 ClassLoader 中定义包。这允许类加载器定义用于它们的类的包。
* 包必须在定义类之前创建，包名在类加载器中必须惟一，并且一旦创建就不能重新定义或更改。
* @param name	包名
* @param specTitle	规范标题
* @param specVersion	规范版本
* @param specVendor	规范供应商
* @param implTitle	实现标题
* @param implVersion	实现版本
* @param implVendor	实现供应商
* @param sealBase	如果不为 null，那么将此包对于给定代码源 URL 对象是密封的。否则，不密封此包。
* @return	新定义的 Package 对象
* @throws IllegalArgumentException
*/
protected Package definePackage(String name, String specTitle,
String specVersion, String specVendor,
String implTitle, String implVersion,
String implVendor, URL sealBase)
throws IllegalArgumentException
{
synchronized (packages) {
// 获取由此类加载器或其任何祖先所定义的 Package
Package pkg = getPackage(name);
if (pkg != null) {
throw new IllegalArgumentException(name);
}
pkg = new Package(name, specTitle, specVersion, specVendor,
implTitle, implVersion, implVendor,
sealBase, this);
packages.put(name, pkg);
return pkg;
}
}
/**
* 返回由此类加载器或其任何祖先所定义的 Package。
* @param name	包名
* @return	与给定名称相对应的 Package；如果没有这样的包，则返回 null
*/
protected Package getPackage(String name) {
Package pkg;
synchronized (packages) {
pkg = packages.get(name);
}
if (pkg == null) {
if (parent != null) {
// 获取祖先所定义的 Package
pkg = parent.getPackage(name);
} else {
// 返回指定名称的已加载系统包。
pkg = Package.getSystemPackage(name);
}
if (pkg != null) {
synchronized (packages) {
Package pkg2 = packages.get(name);
if (pkg2 == null) {
packages.put(name, pkg);
} else {
pkg = pkg2;
}
}
}
}
return pkg;
}
/**
* 返回此类加载器及其祖先所定义的所有 Package
* @return
*/
protected Package[] getPackages() {
Map<String, Package> map;
synchronized (packages) {
map = new HashMap<>(packages);
}
Package[] pkgs;
if (parent != null) {
// 返回祖先所定义的所有 Package
pkgs = parent.getPackages();
} else {
// 返回已加载系统包的数组。
pkgs = Package.getSystemPackages();
}
if (pkgs != null) {
for (int i = 0; i < pkgs.length; i++) {
String pkgName = pkgs[i].getName();
if (map.get(pkgName) == null) {
map.put(pkgName, pkgs[i]);
}
}
}
return map.values().toArray(new Package[map.size()]);
}
// -- Native library access --
/**
* 返回本机库的绝对路径名。虚拟机 (VM) 调用此方法来查找那些属于利用此类加载器加载的类的本机库。
* 如果此方法返回 null，则虚拟机沿指定为 "java.library.path" 属性的路径搜索该库。
* @param libname	库名称
* @return	本机库的绝对路径
*/
protected String findLibrary(String libname) {
return null;
}
/**
* 内部类NativeLibrary表示加载的本机库实例。
* 每个类加载器在私有字段nativeLibraries中包含一个已加载本机库的向量。
* 加载到系统中的本机库被输入到systemNativeLibraries vector。
*
* 每个本机库都需要特定版本的JNI。
* 这由私有的JNI Version字段表示。
* 这个字段是VM在加载库时设置的，
* 并由VM用于将正确版本的JNI传递给本机方法。
*/
static class NativeLibrary {
// 本机库的不透明句柄，在本机代码中使用。
long handle;
// 本机库需要的JNI环境版本。
private int jniVersion;
// 加载库的类还指示此本机库所属的加载器。
private final Class<?> fromClass;
//本机库的规范化名称。或静态库名
String name;
// 指示本机库是否链接到VM
boolean isBuiltin;
// 指示是否加载本机库
boolean loaded;
native void load(String name, boolean isBuiltin);
native long find(String name);
native void unload(String name, boolean isBuiltin);
public NativeLibrary(Class<?> fromClass, String name, boolean isBuiltin) {
this.name = name;
this.fromClass = fromClass;
this.isBuiltin = isBuiltin;
}
protected void finalize() {
synchronized (loadedLibraryNames) {
if (fromClass.getClassLoader() != null && loaded) {
/* 删除本机库名称 */
int size = loadedLibraryNames.size();
for (int i = 0; i < size; i++) {
if (name.equals(loadedLibraryNames.elementAt(i))) {
loadedLibraryNames.removeElementAt(i);
break;
}
}
/* 卸载库。 */
ClassLoader.nativeLibraryContext.push(this);
try {
unload(name, isBuiltin);
} finally {
ClassLoader.nativeLibraryContext.pop();
}
}
}
}
// 在VM中调用，以确定JNI_Load/JNI_Unload中的上下文类
static Class<?> getFromClass() {
return ClassLoader.nativeLibraryContext.peek().fromClass;
}
}
// 我们加载的所有本机库名称。
private static Vector<String> loadedLibraryNames = new Vector<>();
// 属于系统类的本机库。
private static Vector<NativeLibrary> systemNativeLibraries
= new Vector<>();
// 与类装载器关联的本机库。
private Vector<NativeLibrary> nativeLibraries = new Vector<>();
// 正在加载/卸载本机库。
private static Stack<NativeLibrary> nativeLibraryContext = new Stack<>();
// 路径搜索库
private static String usr_paths[];
private static String sys_paths[];
/**
* 初始化库路径
* @param propname
* @return
*/
private static String[] initializePath(String propname) {
// 获取指定键指示的系统属性
String ldpath = System.getProperty(propname, "");
String ps = File.pathSeparator;
int ldlen = ldpath.length();
int i, j, n;
// 计算路径中的分隔符
i = ldpath.indexOf(ps);
n = 0;
while (i >= 0) {
n++;
i = ldpath.indexOf(ps, i + 1);
}
// 分配路径数组- n:'s = n + 1路径元素
String[] paths = new String[n + 1];
// 用ldpath中的路径填充数组
n = i = 0;
j = ldpath.indexOf(ps);
while (j >= 0) {
if (j - i > 0) {
paths[n++] = ldpath.substring(i, j);
} else if (j - i == 0) {
paths[n++] = ".";
}
i = j + 1;
j = ldpath.indexOf(ps, i);
}
paths[n] = ldpath.substring(i, ldlen);
return paths;
}
/**
* 在java.lang中调用。运行时类来实现load和loadLibrary。
* @param fromClass
* @param name
* @param isAbsolute
*/
static void loadLibrary(Class<?> fromClass, String name,
boolean isAbsolute) {
ClassLoader loader =
(fromClass == null) ? null : fromClass.getClassLoader();
if (sys_paths == null) {
usr_paths = initializePath("java.library.path");
sys_paths = initializePath("sun.boot.library.path");
}
if (isAbsolute) {
if (loadLibrary0(fromClass, new File(name))) {
return;
}
throw new UnsatisfiedLinkError("Can't load library: " + name);
}
if (loader != null) {
// 返回本机库的绝对路径名。
String libfilename = loader.findLibrary(name);
if (libfilename != null) {
File libfile = new File(libfilename);
// 测试此抽象路径名是否为绝对路径名。
if (!libfile.isAbsolute()) {
throw new UnsatisfiedLinkError(
"ClassLoader.findLibrary failed to return an absolute path: " + libfilename);
}
if (loadLibrary0(fromClass, libfile)) {
return;
}
throw new UnsatisfiedLinkError("Can't load " + libfilename);
}
}
for (int i = 0 ; i < sys_paths.length ; i++) {
// 加载由 libname 参数指定的系统库。
File libfile = new File(sys_paths[i], System.mapLibraryName(name));
if (loadLibrary0(fromClass, libfile)) {
return;
}
libfile = ClassLoaderHelper.mapAlternativeName(libfile);
if (libfile != null && loadLibrary0(fromClass, libfile)) {
return;
}
}
if (loader != null) {
for (int i = 0 ; i < usr_paths.length ; i++) {
// 加载由 libname 参数指定的用户库。
File libfile = new File(usr_paths[i],
System.mapLibraryName(name));
if (loadLibrary0(fromClass, libfile)) {
return;
}
// 返回给定文件的备用路径名
libfile = ClassLoaderHelper.mapAlternativeName(libfile);
if (libfile != null && loadLibrary0(fromClass, libfile)) {
return;
}
}
}
// 失败
throw new UnsatisfiedLinkError("no " + name + " in java.library.path");
}
private static native String findBuiltinLib(String name);
private static boolean loadLibrary0(Class<?> fromClass, final File file) {
// 检查是否试图访问静态库
String name = findBuiltinLib(file.getName());
boolean isBuiltin = (name != null);
if (!isBuiltin) {
boolean exists = AccessController.doPrivileged(
new PrivilegedAction<Object>() {
public Object run() {
return file.exists() ? Boolean.TRUE : null;
}})
!= null;
if (!exists) {
return false;
}
try {
// 返回此抽象路径名的规范形式
name = file.getCanonicalPath();
} catch (IOException e) {
return false;
}
}
ClassLoader loader =
(fromClass == null) ? null : fromClass.getClassLoader();
Vector<NativeLibrary> libs =
loader != null ? loader.nativeLibraries : systemNativeLibraries;
synchronized (libs) {
int size = libs.size();
for (int i = 0; i < size; i++) {
NativeLibrary lib = libs.elementAt(i);
if (name.equals(lib.name)) {
return true;
}
}
synchronized (loadedLibraryNames) {
if (loadedLibraryNames.contains(name)) {
throw new UnsatisfiedLinkError
("Native Library " +
name +
" already loaded in another classloader");
}
/* 如果正在加载库(必须是同样的线程,因为运行时。加载和运行时。loadLibrary同步)。
* 原因是JNI_OnLoad函数可能导致另一个loadLibrary调用。
*
* 因此，我们可以使用静态堆栈来保存正在加载的库列表。
*
* 如果库有一个挂起的加载操作，
* 我们立即回报成功;否则，我们会产生UnsatisfiedLinkError。
*/
int n = nativeLibraryContext.size();
for (int i = 0; i < n; i++) {
NativeLibrary lib = nativeLibraryContext.elementAt(i);
if (name.equals(lib.name)) {
if (loader == lib.fromClass.getClassLoader()) {
return true;
} else {
throw new UnsatisfiedLinkError
("Native Library " +
name +
" is being loaded in another classloader");
}
}
}
NativeLibrary lib = new NativeLibrary(fromClass, name, isBuiltin);
nativeLibraryContext.push(lib);
try {
lib.load(name, isBuiltin);
} finally {
nativeLibraryContext.pop();
}
if (lib.loaded) {
loadedLibraryNames.addElement(name);
libs.addElement(lib);
return true;
}
return false;
}
}
}
/**
* 在VM类链接代码中调用。
* @param loader
* @param name
* @return
*/
static long findNative(ClassLoader loader, String name) {
Vector<NativeLibrary> libs =
loader != null ? loader.nativeLibraries : systemNativeLibraries;
synchronized (libs) {
int size = libs.size();
for (int i = 0; i < size; i++) {
NativeLibrary lib = libs.elementAt(i);
long entry = lib.find(name);
if (entry != 0)
return entry;
}
}
return 0;
}
// -- Assertion management --
// ssertion管理
final Object assertionLock;
/*
* 断言检查的默认切换。
* @GuardedBy (“assertionLock”)
*/
private boolean defaultAssertionStatus = false;
/*
* 将字符串packageName映射到布尔包的默认断言状态。
* 如果该字段为null，则我们将断言状态查询委托给VM，即没有调用这个类加载器的断言状态修改方法。
* @GuardedBy (“assertionLock”)
*/
private Map<String, Boolean> packageAssertionStatus = null;
/*
* 如果该字段为空，则我们将断言状态查询委托给VM，即没有调用这个类加载器的断言状态修改方法。
* @GuardedBy (“assertionLock”)
*/
Map<String, Boolean> classAssertionStatus = null;
/**
* 设置此类加载器的默认断言状态。
* 此设置确定由此类加载器加载并在将来初始化的类在默认情况下是启用还是禁用断言。
* 通过调用 setPackageAssertionStatus(String, boolean) 或 setClassAssertionStatus(String, boolean)，
* 在每个包或每个类上重写此设置。
* @param enabled	如果由此类加载器加载的类将默认为启用断言，则该参数为 true；如果默认为禁用断言，则该参数为 false。
*/
public void setDefaultAssertionStatus(boolean enabled) {
synchronized (assertionLock) {
if (classAssertionStatus == null)
// 使用VM提供的信息设置断言。
initializeJavaAssertionMaps();
defaultAssertionStatus = enabled;
}
}
/**
* 为指定包设置默认断言状态。包的默认断言状态确定了以后初始化属于指定包或其子包的类的断言状态。
* 名为 p 的包的子包是所有名称以 "p." 开头的包。
* 例如，javax.swing.text 是 javax.swing 的子包，java.util 和 java.lang.reflect 是 java 的子包。
* 如果默认情况下多个包可应用于一个给定类，则默认与最特殊的包相关的包拥有高于其他包的优先级。
* 例如，如果 javax.lang 和 javax.lang.reflect 都具有与之相关的默认包，
* 则将后者应用于 javax.lang.reflect 中的类。
* 包的优先级默认情况下高于类加载器的默认断言状态，
* 并且可以通过调用 setClassAssertionStatus(String, boolean) 在每个类的基础上进行重写。
* @param packageName	要设置其默认包断言状态的包名。
* @param enabled	如果由此类加载器加载并属于指定包或其子包的类在默认情况下启用断言，
*
则该参数为 true；如果在默认情况下禁用断言，则该参数为 false。
*/
public void setPackageAssertionStatus(String packageName,
boolean enabled) {
synchronized (assertionLock) {
if (packageAssertionStatus == null)
// 使用VM提供的信息设置断言。
initializeJavaAssertionMaps();
packageAssertionStatus.put(packageName, enabled);
}
}
/**
* 设置在此类加载器及其包含的嵌套类中指定的最高层类所需的断言状态。
* 该设置的优先级高于类加载器的默认断言状态以及可用的任何包的默认值。
* 如果已经初始化指定类，则此方法无效。（初始化类后，其断言状态无法再改变。）
* 如果指定类不是最高层的类，则此调用对任何类的实际断言都无效。
* @param className	将要设置其断言状态的最高层类的完全限定类名。
* @param enabled	如果指定类在初始化时启用断言，则该参数为true；如果该类禁用断言，则该参数为false。
*/
public void setClassAssertionStatus(String className, boolean enabled) {
synchronized (assertionLock) {
if (classAssertionStatus == null)
initializeJavaAssertionMaps();
classAssertionStatus.put(className, enabled);
}
}
/**
* 将此类加载器的默认断言状态设置为 false，并放弃与此类加载器关联的所有默认包或类断言状态设置。
* 提供此方法可以让类加载器忽略任何命令行或持久断言状态设置，并且“无不良记录”。
*/
public void clearAssertionStatus() {
/*
* 无论“Java断言映射”是否初始化，
* 将它们设置为空映射，有效地忽略任何当前设置。
*/
synchronized (assertionLock) {
classAssertionStatus = new HashMap<>();
packageAssertionStatus = new HashMap<>();
defaultAssertionStatus = false;
}
}
/**
* 返回将分配给指定类的断言状态(如果在调用此方法时初始化该类)。
* 如果指定的类已经设置了断言状态，则返回最近的设置;
* 否则，如果任何包的默认断言状态属于这个类，
* 返回最特定的相关包默认断言状态的最新设置;
* 否则，将返回这个类装入器的默认断言状态。
* @param className	正在查询所需断言状态的类的完全限定类名
* @return	指定类的所需断言状态
*/
boolean desiredAssertionStatus(String className) {
synchronized (assertionLock) {
// assert classAssertionStatus
!= null;
// assert packageAssertionStatus != null;
// 检查类entry
Boolean result = classAssertionStatus.get(className);
if (result != null)
return result.booleanValue();
// 检查大多数特定的包entry
int dotIndex = className.lastIndexOf(".");
if (dotIndex < 0) { // 默认 package
result = packageAssertionStatus.get(null);
if (result != null)
return result.booleanValue();
}
while(dotIndex > 0) {
className = className.substring(0, dotIndex);
result = packageAssertionStatus.get(className);
if (result != null)
return result.booleanValue();
dotIndex = className.lastIndexOf(".", dotIndex-1);
}
// 返回类加载器默认值
return defaultAssertionStatus;
}
}
/**
* 使用VM提供的信息设置断言。
* 注意:应该只在同步块中调用
*/
private void initializeJavaAssertionMaps() {
// assert Thread.holdsLock(assertionLock);
classAssertionStatus = new HashMap<>();
packageAssertionStatus = new HashMap<>();
// 从VM检索断言指令。
AssertionStatusDirectives directives = retrieveDirectives();
// 类断言状态处理
for(int i = 0; i < directives.classes.length; i++)
classAssertionStatus.put(directives.classes[i],
directives.classEnabled[i]);
// 包断言状态处理
for(int i = 0; i < directives.packages.length; i++)
packageAssertionStatus.put(directives.packages[i],
directives.packageEnabled[i]);
// 默认断言状态处理
defaultAssertionStatus = directives.deflt;
}
// 从VM检索断言指令。
private static native AssertionStatusDirectives retrieveDirectives();
}
class SystemClassLoaderAction
implements PrivilegedExceptionAction<ClassLoader> {
private ClassLoader parent;
SystemClassLoaderAction(ClassLoader parent) {
this.parent = parent;
}
public ClassLoader run() throws Exception {
String cls = System.getProperty("java.system.class.loader");
if (cls == null) {
return parent;
}
Constructor<?> ctor = Class.forName(cls, true, parent)
.getDeclaredConstructor(new Class<?>[] { ClassLoader.class });
ClassLoader sys = (ClassLoader) ctor.newInstance(
new Object[] { parent });
Thread.currentThread().setContextClassLoader(sys);
return sys;
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
/**
* 类加载器是负责加载类的对象。ClassLoader 类是一个抽象类。
* 如果给定类的二进制名称，那么类加载器会试图查找或生成构成类定义的数据。
* 一般策略是将名称转换为某个文件名，然后从文件系统读取该名称的“类文件”。
* 每个 Class 对象都包含一个对定义它的 ClassLoader 的引用。
* 数组类的 Class 对象不是由类加载器创建的，而是由 Java 运行时根据需要自动创建。
* 数组类的类加载器由 Class.getClassLoader() 返回，该加载器与其元素类型的类加载器是相同的；
* 如果该元素类型是基本类型，则该数组类没有类加载器。
* 应用程序需要实现 ClassLoader 的子类，以扩展 Java 虚拟机动态加载类的方式。
* 类加载器通常由安全管理器使用，用于指示安全域。
* ClassLoader 类使用委托模型来搜索类和资源。每个 ClassLoader 实例都有一个相关的父类加载器。
* 需要查找类或资源时，ClassLoader 实例会在试图亲自查找类或资源之前，将搜索类或资源的任务委托给其父类加载器。
* 虚拟机的内置类加载器（称为 "bootstrap class loader"）本身没有父类加载器，
* 但是可以将它用作 ClassLoader 实例的父类加载器。
* 通常情况下，Java 虚拟机以与平台有关的方式，从本地文件系统中加载类。
* 例如，在 UNIX 系统中，虚拟机从 CLASSPATH 环境变量定义的目录中加载类。
* 然而，有些类可能并非源自一个文件；它们可能源自其他来源（如网络），也可能是由应用程序构造的。
* defineClass 方法将一个 byte 数组转换为 Class 类的实例。
* 这种新定义的类的实例可以使用 Class.newInstance 来创建。
* 类加载器所创建对象的方法和构造方法可以引用其他类。
* 为了确定引用的类，Java 虚拟机将调用最初创建该类的类加载器的 loadClass 方法。
*/
public abstract class ClassLoader {
// 要为类注册本地函数，RegisterNatives从本地的库中的本机代码调用JNI函数。
private static native void registerNatives();
static {
registerNatives();
}
/*
* 委托的父类装入器
* 注意:虚拟机硬编码这个字段的偏移量,
* 因此，所有新字段必须在*after*添加。
*/
private final ClassLoader parent;
/**
* 封装可并行加载器类型集
*/
private static class ParallelLoaders {
private ParallelLoaders() {}
// 一组具有并行能力的加载器类型
private static final Set<Class<? extends ClassLoader>> loaderTypes =
Collections.newSetFromMap(
new WeakHashMap<Class<? extends ClassLoader>, Boolean>());
static {
synchronized (loaderTypes) { loaderTypes.add(ClassLoader.class); }
}
/**
* 将给定的类加载器类型注册为并行capabale。
* 成功注册返回true;
* 如果加载器的超类未注册，则为false。
*/
static boolean register(Class<? extends ClassLoader> c) {
synchronized (loaderTypes) {
if (loaderTypes.contains(c.getSuperclass())) {
/*
* 注册类加载器为并行的，当且仅当它的所有超类都是并行的。
* 注:给定当前类加载顺序，如果直接超类是并行的，
* 上面的所有超类也必须是。
*/
loaderTypes.add(c);
return true;
} else {
return false;
}
}
}
/**
* 如果指定的类加载器类型注册为并行的，则返回{true}。
*/
static boolean isRegistered(Class<? extends ClassLoader> c) {
synchronized (loaderTypes) {
return loaderTypes.contains(c);
}
}
}
/*
* 当当前类加载器具有并行能力时，将类名映射到相应的锁对象。
* 注意:VM还使用这个字段来决定当前类加载器是否具有并行能力，以及加载类的适当锁定对象。
*/
private final ConcurrentHashMap<String, Object> parallelLockMap;
// 将包映射到certs的哈希表
private final Map <String, Certificate[]> package2certs;
// 在所有无签名类的包之间共享
private static final Certificate[] nocerts = new Certificate[0];
/*
* 由这类加载器加载的类。
* 此表的唯一目的是在加载器GC之前防止类被GC。
*/
private final Vector<Class<?>> classes = new Vector<>();
/*
* “默认”domain。
* 设置为新创建的类的默认ProtectionDomain。
*/
private final ProtectionDomain defaultDomain =
new ProtectionDomain(new CodeSource(null, (Certificate[]) null),
null, this, null);
// 此加载程序加载的所有类的初始化保护domain
private final Set<ProtectionDomain> domains;
/**
* VM调用它来记录使用此加载器加载的每个类。
* @param c
*/
void addClass(Class<?> c) {
classes.addElement(c);
}
/*
* 类加载器中定义的包。
* 每个包名映射到对应的包对象。
*/
private final HashMap<String, Package> packages = new HashMap<>();
/**
* 检查创建新类加载器的权限
* @return
*/
private static Void checkCreateClassLoader() {
// 获取系统安全接口
SecurityManager security = System.getSecurityManager();
if (security != null) {
// 判断是否有调用线程创建新类加载器的权限，不允许，则抛SecurityException
security.checkCreateClassLoader();
}
return null;
}
/**
* 私有构造器
* @param unused
* @param parent
*/
private ClassLoader(Void unused, ClassLoader parent) {
this.parent = parent;
// 如果指定的类加载器类型注册为并行的，则返回true。
if (ParallelLoaders.isRegistered(this.getClass())) {
parallelLockMap = new ConcurrentHashMap<>();
package2certs = new ConcurrentHashMap<>();
domains =
Collections.synchronizedSet(new HashSet<ProtectionDomain>());
assertionLock = new Object();
} else {
// 没有更细粒度的锁;锁定类加载器实例
parallelLockMap = null;
package2certs = new Hashtable<>();
domains = new HashSet<>();
assertionLock = this;
}
}
/**
* 使用指定的、用于委托操作的父类加载器创建新的类加载器。
* 如果存在安全管理器，则调用其 checkCreateClassLoader 方法。这可能导致安全性异常。
* @param parent	父类加载器
*/
protected ClassLoader(ClassLoader parent) {
this(checkCreateClassLoader(), parent);
}
/**
* 使用方法 getSystemClassLoader() 返回的 ClassLoader 创建一个新的类加载器，将该加载器作为父类加载器。
* 如果存在安全管理器，则调用其 checkCreateClassLoader 方法。这可能导致安全性异常。
*/
protected ClassLoader() {
this(checkCreateClassLoader(), getSystemClassLoader());
}
// -- Class --
/**
* 使用指定的二进制名称来加载类。此方法使用与 loadClass(String, boolean) 方法相同的方式搜索类。
* Java 虚拟机调用它来分析类引用。调用此方法等效于调用 loadClass(name, false)。
* @param name	类的二进制名称
* @return
* @throws ClassNotFoundException
*/
public Class<?> loadClass(String name) throws ClassNotFoundException {
return loadClass(name, false);
}
/**
* 使用指定的二进制名称来加载类。此方法的默认实现将按以下顺序搜索类：
* 调用 findLoadedClass(String) 来检查是否已经加载类。
* 在父类加载器上调用 loadClass 方法。如果父类加载器为 null，则使用虚拟机的内置类加载器。
* 调用 findClass(String) 方法查找类。
* 如果使用上述步骤找到类，并且 resolve 标志为真，则此方法将在得到的 Class 对象上调用 resolveClass(Class) 方法。
* 鼓励用 ClassLoader 的子类重写 findClass(String)，而不是使用此方法。
* @param name	类的二进制名称
* @param resolve	如果该参数为 true，则分析这个类
* @return
* @throws ClassNotFoundException
*/
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
synchronized (getClassLoadingLock(name)) {
// 首先，判断该类型是否已经被加载
Class<?> c = findLoadedClass(name);
if (c == null) { // 如果没有被加载，就委托给父类加载或者委派给启动类加载其加载
// 获取最准确的可用系统计时器的当前值，以毫微秒为单位
long t0 = System.nanoTime();
try {
if (parent != null) {
// 如果存在父类加载器，就委派给父类加载器加载
// 使用父类的加载器来加载类。
c = parent.loadClass(name, false);
} else {
// 如果不存在父类加载器，就检查是否是由启动类加载器加载的类，通过调用本地方法findBootstrapClass
c = findBootstrapClassOrNull(name);
}
} catch (ClassNotFoundException e) {
// 如果父类加载器和启动类加载器都不能完成加载任务，才调用自身的加载功能
}
if (c == null) {
// 如果仍然没有找到，然后调用findClass来查找该类。
long t1 = System.nanoTime();
c = findClass(name);
// 这是定义类加载器;记录数据
sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
sun.misc.PerfCounter.getFindClasses().increment();
}
}
if (resolve) { // 链接指定的类。
resolveClass(c);
}
return c;
}
}
/**
* 返回类加载操作的锁对象。
* 为了向后兼容，此方法的默认实现的行为如下。
* 如果这个类加载器对象被注册为并行的，该方法返回与指定类名关联的专用对象。否则,该方法返回这个类加载器对象。
* @param className	要加载的类的名称
* @return	类加载操作的锁
*/
protected Object getClassLoadingLock(String className) {
Object lock = this;
if (parallelLockMap != null) {
Object newLock = new Object();
// 如果指定键已经不再与某个值相关联，则将它与给定值关联。
lock = parallelLockMap.putIfAbsent(className, newLock);
if (lock == null) {
lock = newLock;
}
}
return lock;
}
/**
* 虚拟机调用此方法来加载类。
* @param name	类的二进制名称
* @return
* @throws ClassNotFoundException
*/
private Class<?> loadClassInternal(String name)
throws ClassNotFoundException
{
// 为了向后兼容，当当前类加载器不支持并行时，显式锁定“this”。
if (parallelLockMap == null) {
synchronized (this) {
return loadClass(name);
}
} else {
return loadClass(name);
}
}
/**
* 在使用此加载器加载类之后由VM调用。
* @param cls
* @param pd
*/
private void checkPackageAccess(Class<?> cls, ProtectionDomain pd) {
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
// 是否有保护域拥有权限
if (ReflectUtil.isNonPublicProxyClass(cls)) {
for (Class<?> intf: cls.getInterfaces()) {
checkPackageAccess(intf, pd);
}
return;
}
final String name = cls.getName();
final int i = name.lastIndexOf('.');
if (i != -1) {
/*
* 通过指定的 AccessControlContext 启用和限制特权，执行指定的 PrivilegedAction。
* 该操作在调用方保护域所拥有权限与指定的 AccessControlContext 表示的域所拥有权限的交集下执行。
*/
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
// 如果不允许调用线程访问由参数指定的包，则抛出 SecurityException。
sm.checkPackageAccess(name.substring(0, i));
return null;
}
// 创建带有给定 ProtectionDomain 集合的 AccessControlContext。上下文不能为 null。重复的域将从上下文中被移除。
}, new AccessControlContext(new ProtectionDomain[] {pd}));
}
}
domains.add(pd);
}
/**
* 使用指定的二进制名称查找类。此方法应该被类加载器的实现重写，该实现按照委托模型来加载类。
* 在通过父类加载器检查所请求的类后，此方法将被 loadClass 方法调用。
* @param name	类的二进制名称
* @return
* @throws ClassNotFoundException
*/
protected Class<?> findClass(String name) throws ClassNotFoundException {
throw new ClassNotFoundException(name);
}
/**
* 将一个 byte 数组转换为 Class 类的实例。必须分析 Class，然后才能使用它。
* 此方法将默认的 ProtectionDomain 分配给新定义的类。
* 调用 Policy.getPolicy().getPermissions(new CodeSource(null, null)) 时，
* ProtectionDomain 被有效授予所返回的相同权限集。
* 默认域在第一次调用 defineClass 时创建，并在后续调用时被重用。
* 要将特定的 ProtectionDomain 分配给类，需要使用 defineClass 方法，
* 该方法将 ProtectionDomain 用作其参数之一。
* @param name	所需要的类的二进制名称，如果不知道此名称，则该参数为 null
* @param b	组成类数据的字节。
* @param off	类数据的 b 中的起始偏移量
* @param len	类数据的长度
* @return
* @throws ClassFormatError
*/
protected final Class<?> defineClass(String name, byte[] b, int off, int len)
throws ClassFormatError
{
return defineClass(name, b, off, len, null);
}
/**
* 确定ProtectionDomain，并检查。
* @param name
* @param pd
* @return
*/
private ProtectionDomain preDefineClass(String name,
ProtectionDomain pd)
{
//如果名称为null或可能为有效二进制名称，则为true
if (!checkName(name))
throw new NoClassDefFoundError("IllegalName: " + name);
// 指定的 name 不能以 "java." 开头，因为 "java.*" 包中的所有类都只能由引导类加载器定义。
if ((name != null) && name.startsWith("java.")) {
throw new SecurityException
("Prohibited package name: " +
name.substring(0, name.lastIndexOf('.')));
}
if (pd == null) {
pd = defaultDomain;
}
// 如果 name 不是 null，则它必定等于由 byte 数组 "b" 指定的类的二进制名称
if (name != null) checkCerts(name, pd.getCodeSource());
return pd;
}
/**
* 获取与此 域的CodeSource 关联的位置
* @param pd
* @return
*/
private String defineClassSourceLocation(ProtectionDomain pd)
{
// 获取此域的 CodeSource。
CodeSource cs = pd.getCodeSource();
String source = null;
if (cs != null && cs.getLocation() != null) {
// 获取与此 CodeSource 关联的位置
source = cs.getLocation().toString();
}
return source;
}
/**
* 从该类的 ProtectionDomain 中的 CodeSource 可以获得类的证书集合。
* 添加到该包中的任何类都必须包含相同的证书集合
* @param c
* @param pd
*/
private void postDefineClass(Class<?> c, ProtectionDomain pd)
{
if (pd.getCodeSource() != null) {
// 获取与此 CodeSource 关联的证书。
Certificate certs[] = pd.getCodeSource().getCertificates();
if (certs != null)
// 设置类的签署者
setSigners(c, certs);
}
}
/**
* 使用可选的 ProtectionDomain 将一个 byte 数组转换为 Class 类的实例。
* 如果该域为 null，则将默认域分配给 defineClass(String, byte[], int, int) 的文档中指定的类。
* 这个类必须分析后才能使用。
* 包中定义的第一个类确定在该包中定义的所有后续类必须包含的证书的确切集合。
* 从该类的 ProtectionDomain 中的 CodeSource 可以获得类的证书集合。
* 添加到该包中的任何类都必须包含相同的证书集合，否则抛出 SecurityException 异常。
* 注意，如果 name 为 null，则不执行该检查。应该始终传入要定义的类的二进制名称以及字节。
* 这可确保定义该类的正确性。
* 指定的 name 不能以 "java." 开头，因为 "java.*" 包中的所有类都只能由引导类加载器定义。
* 如果 name 不是 null，则它必定等于由 byte 数组 "b" 指定的类的二进制名称，
* 否则将抛出 NoClassDefFoundError。
* @param name	所需类的二进制名称，如果不知道此名称，则该参数为 null
* @param b	组成类数据的字节。
* @param off	类数据的 b 中的起始偏移量
* @param len	类数据的长度
* @param protectionDomain	类的 ProtectionDomain
* @return
* @throws ClassFormatError
*/
protected final Class<?> defineClass(String name, byte[] b, int off, int len,
ProtectionDomain protectionDomain)
throws ClassFormatError
{
// 确定ProtectionDomain，分析
protectionDomain = preDefineClass(name, protectionDomain);
// 获取与此 域的CodeSource 关联的位置
String source = defineClassSourceLocation(protectionDomain);
// 获取class对象，通过b为byte[]
Class<?> c = defineClass1(name, b, off, len, protectionDomain, source);
// 从该类的 ProtectionDomain 中的 CodeSource 可以获得类的证书集合。
// 添加到该包中的任何类都必须包含相同的证书集合
postDefineClass(c, protectionDomain);
return c;
}
/**
* 使用可选的 ProtectionDomain 将 ByteBuffer 转换为 Class 类的实例。
* 如果该域为 null，则将默认域分配给 defineClass(String, byte[], int, int) 的文档中指定的类。
* 这个类必须分析后才能使用。
* 有关包中定义的第一个类（它确定了包的证书集合）的规则，以及对类名称的限制，
* 都与 defineClass(String, byte[], int, int, ProtectionDomain) 的文档中指定的相同。
* @param name	所需要的类的二进制名称，如果不知道此名称，则该参数为 null
* @param b	组成类数据的字节。
* @param protectionDomain	类的 ProtectionDomain，或为 null。
* @return
* @throws ClassFormatError
*/
protected final Class<?> defineClass(String name, java.nio.ByteBuffer b,
ProtectionDomain protectionDomain)
throws ClassFormatError
{
// 获取此缓冲区中的剩余元素数
int len = b.remaining();
// 如果不是直接ByteBufer，请使用byte[]:
// 判断此缓冲区是否为直接缓冲区。
if (!b.isDirect()) {
// 判断当且仅当此缓冲区有非只读的底层实现数组时返回 true。
if (b.hasArray()) {
return defineClass(name, b.array(),
b.position() + b.arrayOffset(), len,
protectionDomain);
} else {
// 不是数组, 或者 只读数组
byte[] tb = new byte[len];
b.get(tb);
//从字节缓冲区获取字节。
return defineClass(name, tb, 0, len, protectionDomain);
}
}
// 确定ProtectionDomain，并检查。
protectionDomain = preDefineClass(name, protectionDomain);
// 获取与此 域的CodeSource 关联的位置
String source = defineClassSourceLocation(protectionDomain);
// 获取class对象，通过b为nio.ByteBuffer字节缓冲
Class<?> c = defineClass2(name, b, b.position(), len, protectionDomain, source);
// 从该类的 ProtectionDomain 中的 CodeSource 可以获得类的证书集合。
// 添加到该包中的任何类都必须包含相同的证书集合
postDefineClass(c, protectionDomain);
return c;
}
private native Class<?> defineClass0(String name, byte[] b, int off, int len,
ProtectionDomain pd);
private native Class<?> defineClass1(String name, byte[] b, int off, int len,
ProtectionDomain pd, String source);
private native Class<?> defineClass2(String name, java.nio.ByteBuffer b,
int off, int len, ProtectionDomain pd,
String source);
/**
* 如果名称为null或可能为有效二进制名称，则为true
* @param name
* @return
*/
private boolean checkName(String name) {
if ((name == null) || (name.length() == 0))
return true;
if ((name.indexOf('/') != -1)
|| (!VM.allowArraySyntax() && (name.charAt(0) == '[')))
return false;
return true;
}
/**
* 检查name是否等于由 byte 数组 "b" 指定的类的二进制名称
* @param name
* @param cs
*/
private void checkCerts(String name, CodeSource cs) {
int i = name.lastIndexOf('.');
String pname = (i == -1) ? "" : name.substring(0, i);
Certificate[] certs = null;
if (cs != null) {
// // 获取与此 CodeSource 关联的证书。
certs = cs.getCertificates();
}
Certificate[] pcerts = null;
if (parallelLockMap == null) {
// 放入与当前类加载器关联的package2certs中
synchronized (this) {
pcerts = package2certs.get(pname);
if (pcerts == null) {
package2certs.put(pname, (certs == null? nocerts:certs));
}
}
} else {
// 如果指定键已经不再与某个值相关联，则将它与给定值关联。
pcerts = ((ConcurrentHashMap<String, Certificate[]>)package2certs).
putIfAbsent(pname, (certs == null? nocerts:certs));
}
// 检查以确保新类(certs)的证书与包中插入的第一个类(pcerts)的证书相同
if (pcerts != null && !compareCerts(pcerts, certs)) {
throw new SecurityException("class ""+ name +
""'s signer information does not match signer information of other classes in the same package");
}
}
/**
* 检查以确保新类(certs)的证书与包中插入的第一个类(pcerts)的证书相同
* @param pcerts
* @param certs
* @return
*/
private boolean compareCerts(Certificate[] pcerts,
Certificate[] certs)
{
// certs 可以为null, 表示没有certs
if ((certs == null) || (certs.length == 0)) {
return pcerts.length == 0;
}
// 这一点的长度必须相同
if (certs.length != pcerts.length)
return false;
// 检查并确保一个数组中的所有certs都在另一个数组中，反之亦然。
boolean match;
for (int i = 0; i < certs.length; i++) {
match = false;
for (int j = 0; j < pcerts.length; j++) {
if (certs[i].equals(pcerts[j])) {
match = true;
break;
}
}
if (!match) return false;
}
// 现在对pcert做同样的事情
for (int i = 0; i < pcerts.length; i++) {
match = false;
for (int j = 0; j < certs.length; j++) {
if (pcerts[i].equals(certs[j])) {
match = true;
break;
}
}
if (!match) return false;
}
return true;
}
/**
* 链接指定的类。类加载器可以使用此方法（其名称容易使人误解）来链接类。
* 如果已经链接类 c，则仅返回此方法。
* @param c	要链接的类
*/
protected final void resolveClass(Class<?> c) {
resolveClass0(c);
}
private native void resolveClass0(Class<?> c);
/**
* 查找具有指定的二进制名称的类，必要时加载它。
* 此方法通过系统类加载器（参见 getSystemClassLoader()）来加载该类。
* 返回的 Class 对象具有多个与之相关联的 ClassLoader。ClassLoader 的子类通常不必调用此方法，
* 因为大多数类加载器只需重写 findClass(String) 即可。
* @param name	类的二进制名称
* @return	指定 name 的 Class 对象
* @throws ClassNotFoundException
*/
protected final Class<?> findSystemClass(String name)
throws ClassNotFoundException
{
// 获取委托的系统类加载器。
ClassLoader system = getSystemClassLoader();
if (system == null) {
// 如果名称为null或可能为有效二进制名称，则为true
if (!checkName(name))
throw new ClassNotFoundException(name);
Class<?> cls = findBootstrapClass(name);
if (cls == null) {
throw new ClassNotFoundException(name);
}
return cls;
}
// 使用指定的二进制名称来加载类。
return system.loadClass(name);
}
/**
* 使用虚拟机的内置类加载器加载类
* @param name
* @return
*/
private Class<?> findBootstrapClassOrNull(String name)
{
// 如果名称为null或可能为有效二进制名称，则为true
if (!checkName(name)) return null;
return findBootstrapClass(name);
}
// 如果没有找到，返回null
private native Class<?> findBootstrapClass(String name);
/**
* 如果 Java 虚拟机已将此加载器记录为具有给定二进制名称的某个类的启动加载器，
* 则返回该二进制名称的类。否则，返回 null。
* @param name	类的二进制名称
* @return	Class 对象，如果类没有被加载，则返回 null
*/
protected final Class<?> findLoadedClass(String name) {
// 如果名称为null或可能为有效二进制名称，则为true
if (!checkName(name))
return null;
return findLoadedClass0(name);
}
private native final Class<?> findLoadedClass0(String name);
/**
* 设置类的签署者。应该在定义类后调用此方法。
* @param c	Class 对象
* @param signers	类的签署者
*/
protected final void setSigners(Class<?> c, Object[] signers) {
c.setSigners(signers);
}
// -- Resource --
/**
* 查找具有给定名称的资源。资源是可以通过类代码以与代码基无关的方式访问的一些数据（图像、声音、文本等）。
*
资源名称是以 '/' 分隔的标识资源的路径名称。 此方法首先搜索资源的父类加载器；
*
如果父类加载器为 null，则搜索的路径就是虚拟机的内置类加载器的路径。
*
如果搜索失败，则此方法将调用 findResource(String) 来查找资源。
* @param name	资源名称
* @return	读取资源的 URL 对象；如果找不到该资源，或者调用者没有足够的权限获取该资源，则返回 null。
*/
public URL getResource(String name) {
URL url;
// 搜索资源的父类加载器；
if (parent != null) {
url = parent.getResource(name);
} else {
// 如果父类加载器为 null，则搜索的路径就是虚拟机的内置类加载器的路径。
url = getBootstrapResource(name);
}
if (url == null) {
// 查找资源
url = findResource(name);
}
return url;
}
/**
* 查找所有给定名称的资源。资源是可以通过类代码以与代码基无关的方式访问的某些数据（图像、声音、文本等）。
* 资源名称是以 '/' 分隔的标识资源的路径名称。
* @param name	资源名称
* @return	资源的 URL 对象的枚举。如果找不到资源，则该枚举将为空。类加载器无权访问的资源不在此枚举中。
* @throws IOException
*/
public Enumeration<URL> getResources(String name) throws IOException {
@SuppressWarnings("unchecked")
Enumeration<URL>[] tmp = (Enumeration<URL>[]) new Enumeration<?>[2];
// 搜索资源的父类加载器；
if (parent != null) {
tmp[0] = parent.getResources(name);
} else {
// 如果父类加载器为 null，则搜索的路径就是虚拟机的内置类加载器的路径。
tmp[0] = getBootstrapResources(name);
}
// 查找资源
tmp[1] = findResources(name);
return new CompoundEnumeration<>(tmp);
}
/**
* 查找具有给定名称的资源。类加载器实现应该重写此方法，以指定从何处查找资源。
* @param name	资源名称
* @return	用于读取资源的 URL 对象；如果无法找到资源，则返回 null
*/
protected URL findResource(String name) {
return null;
}
/**
* 返回表示所有具有给定名称的资源的 URL 对象的枚举。类加载器实现应该重写此方法，以指定从何处加载资源。
* @param name	资源名称
* @return	资源的 URL 对象的枚举
* @throws IOException
*/
protected Enumeration<URL> findResources(String name) throws IOException {
return java.util.Collections.emptyEnumeration();
}
/**
* 将调用者注册为并行的。
* 注册成功当且仅当满足以下所有条件:
* 1. 没有创建调用者的实例
* 2. 调用者的所有超类(类对象除外)都被注册为并行的
* 请注意，一旦类装入器被注册为具有并行能力，就无法将其更改回来。
* @return 如果调用方成功注册为具有并行能力，则为true;如果调用方注册为具有并行能力，则为false。
*/
@CallerSensitive
protected static boolean registerAsParallelCapable() {
Class<? extends ClassLoader> callerClass =
Reflection.getCallerClass().asSubclass(ClassLoader.class);
// 将给定的类装入器类型注册为并行capabale。
return ParallelLoaders.register(callerClass);
}
/**
* 从用来加载类的搜索路径中查找具有指定名称的资源。
* 此方法通过系统类加载器（参见 getSystemClassLoader()）来查找资源。
* @param name	资源名称
* @return	用于读取资源的 URL 对象，如果找不到资源，则返回 null
*/
public static URL getSystemResource(String name) {
// 获取委托的系统类加载器。
ClassLoader system = getSystemClassLoader();
if (system == null) {
// 获取虚拟机的内置类加载器。
return getBootstrapResource(name);
}
// 查找具有给定名称的资源。
return system.getResource(name);
}
/**
* 从用来加载类的搜索路径中查找所有具有指定名称的资源。
* 找到的资源作为 URL 对象的 Enumeration 返回。
* @param name	资源名称
* @return	资源 URL 对象的枚举
* @throws IOException
*/
public static Enumeration<URL> getSystemResources(String name)
throws IOException
{
// 获取委托的系统类加载器。
ClassLoader system = getSystemClassLoader();
if (system == null) {
// 获取虚拟机的内置类加载器。
return getBootstrapResources(name);
}
// 查找具有给定名称的资源。
return system.getResources(name);
}
/**
* 从VM的内置类加载器中查找资源。
* @param name	资源名称
* @return 用于读取资源的 URL 对象，如果找不到资源，则返回 null
*/
private static URL getBootstrapResource(String name) {
// 返回用于查找系统资源的URLClassPath。
URLClassPath ucp = getBootstrapClassPath();
Resource res = ucp.getResource(name);
return res != null ? res.getURL() : null;
}
/**
* 从VM的内置类加载器中查找资源。
* @param name	资源名称
* @return	资源 URL 对象的枚举
* @throws IOException
*/
private static Enumeration<URL> getBootstrapResources(String name)
throws IOException
{
final Enumeration<Resource> e =
getBootstrapClassPath().getResources(name);
return new Enumeration<URL> () {
public URL nextElement() {
return e.nextElement().getURL();
}
public boolean hasMoreElements() {
return e.hasMoreElements();
}
};
}
/**
* 返回用于查找系统资源的URLClassPath。
* @return
*/
static URLClassPath getBootstrapClassPath() {
return sun.misc.Launcher.getBootstrapClassPath();
}
/**
* 返回读取指定资源的输入流。
* @param name	资源名称
* @return	用于读取资源的输入流，如果无法找到资源，则返回 null
*/
public InputStream getResourceAsStream(String name) {
// 查找具有给定名称的资源。
URL url = getResource(name);
try {
return url != null ? url.openStream() : null;
} catch (IOException e) {
return null;
}
}
/**
* 从用来加载类的搜索路径打开具有指定名称的资源，以读取该资源。
* @param name	资源名称
* @return	用于读取资源的输入流，如果无法找到资源，则返回 null
*/
public static InputStream getSystemResourceAsStream(String name) {
// 从用来加载类的搜索路径中查找具有指定名称的资源。
URL url = getSystemResource(name);
try {
return url != null ? url.openStream() : null;
} catch (IOException e) {
return null;
}
}
// -- Hierarchy --
/**
* 返回委托的父类加载器。一些实现可能使用 null 来表示引导类加载器。
* 如果类加载器的父类加载器就是引导类加载器，则此方法将在这样的实现中返回 null。
* 如果存在安全管理器，且调用者的类加载器既不是 null，也不是此类加载器的祖先，
* 那么此方法将使用 RuntimePermission("getClassLoader") 权限调用安全管理器的 checkPermission 方法，
* 以检验是否允许访问该类的父类加载器。如果无此权限，则抛出 SecurityException 异常。
* @return
*/
@CallerSensitive
public final ClassLoader getParent() {
if (parent == null)
return null;
// 获取系统安全接口
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
/*
* 检查对父类加载器的访问，
* 如果调用方的类加载器与此类加载器相同，执行权限检查。
*/
checkClassLoaderPermission(parent, Reflection.getCallerClass());
}
return parent;
}
/**
* 返回委托的系统类加载器。该加载器是新的 ClassLoader 实例的默认委托父类加载器，
* 通常是用来启动应用程序的类加载器。
* 在运行时启动序列的早期首先调用此方法，这时会创建系统类加载器并将其设置为调用 Thread 的上下文类加载器。
* 默认的系统类加载器是此类的一个与实现有关的实例。
* 如果在第一次调用此方法时定义系统属性 "java.system.class.loader"，
* 那么该属性的值就是将作为系统类加载器返回的那个类的名称。
* 该类是使用默认系统类加载器进行加载的，它必须定义一个公共的构造方法，
* 此构造方法带有用作委托父类加载器的 ClassLoader 类型的单个参数。
* 然后可以使用将默认系统类加载器用作参数的此构造方法创建一个实例。得到的类加载器被定义为系统类加载器。
* 如果存在安全管理器，且调用者的类加载器既不是 null，也不同于或不是系统类加载器的祖先，
* 那么该方法将使用 RuntimePermission("getClassLoader") 权限调用安全管理器的 checkPermission 方法，
* 以检验系统类加载器的访问权。如果无此权限，则抛出 SecurityException 异常。
* @return	委托的系统 ClassLoader，如果没有这样的类加载器，则返回 null
*/
@CallerSensitive
public static ClassLoader getSystemClassLoader() {
// 创建系统类加载器
initSystemClassLoader();
if (scl == null) {
return null;
}
// 获取系统安全接口
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
/*
* 检查对父类加载器的访问，
* 如果调用方的类加载器与此类加载器相同，执行权限检查。
*/
checkClassLoaderPermission(scl, Reflection.getCallerClass());
}
return scl;
}
/**
*
创建系统类加载器
*/
private static synchronized void initSystemClassLoader() {
if (!sclSet) {
if (scl != null)
throw new IllegalStateException("recursive invocation");
sun.misc.Launcher l = sun.misc.Launcher.getLauncher();
if (l != null) {
Throwable oops = null;
// 返回类加载器
scl = l.getClassLoader();
try {
// 启用特权，执行指定的 PrivilegedAction。
scl = AccessController.doPrivileged(
new SystemClassLoaderAction(scl));
} catch (PrivilegedActionException pae) {
// 返回此异常的原因
oops = pae.getCause();
if (oops instanceof InvocationTargetException) {
oops = oops.getCause();
}
}
if (oops != null) {
if (oops instanceof Error) {
throw (Error) oops;
} else {
// 包装异常
throw new Error(oops);
}
}
}
sclSet = true;
}
}
/**
* 如果指定的类加载器可以在该类加载器的委托链中找到，则返回true。
* @param cl
* @return
*/
boolean isAncestor(ClassLoader cl) {
ClassLoader acl = this;
do {
acl = acl.parent;
if (cl == acl) {
return true;
}
} while (acl != null);
return false;
}
/**
* 测试类加载器访问是否需要“getClassLoader”权限检查。
* 类加载器'from'可以访问类加载器'to'，如果类加载器'from'与类加载器'to'或'to'的祖先相同的话。
* system domain中的类加载器可以访问任何类加载器。
* @param from
* @param to
* @return
*/
private static boolean needsClassLoaderPermissionCheck(ClassLoader from,
ClassLoader to)
{
if (from == to)
return false;
if (from == null)
return false;
// 如果指定的类加载器可以在该类加载器的委托链中找到，则返回true。
return !to.isAncestor(from);
}
/**
* 返回类加载器
* @param caller
* @return
*/
static ClassLoader getClassLoader(Class<?> caller) {
// 如果VM请求它，它可以是null
if (caller == null) {
return null;
}
// 绕过安全检查，因为这是包私有的
return caller.getClassLoader0();
}
/**
* 如果调用者的类加载器不为空，且调用者的类加载器与给定cl参数不相同或不是其祖先，
* 则检查运行时权限(“getClassLoader”)权限。
* @param cl
* @param caller
*/
static void checkClassLoaderPermission(ClassLoader cl, Class<?> caller) {
// 获取系统安全接口
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
//如果VM正在请求调用者，则调用者可以为空
ClassLoader ccl = getClassLoader(caller);
if (needsClassLoaderPermissionCheck(ccl, cl)) {
sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);
}
}
}
/*
* 系统的类加载器
*
@GuardedBy (“ClassLoader.class”)
*/
private static ClassLoader scl;
/*
* 一旦系统类加载器被设置为true
* @GuardedBy (“ClassLoader.class”)
*/
private static boolean sclSet;
// -- Package --
/**
* 根据 name 在此 ClassLoader 中定义包。这允许类加载器定义用于它们的类的包。
* 包必须在定义类之前创建，包名在类加载器中必须惟一，并且一旦创建就不能重新定义或更改。
* @param name	包名
* @param specTitle	规范标题
* @param specVersion	规范版本
* @param specVendor	规范供应商
* @param implTitle	实现标题
* @param implVersion	实现版本
* @param implVendor	实现供应商
* @param sealBase	如果不为 null，那么将此包对于给定代码源 URL 对象是密封的。否则，不密封此包。
* @return	新定义的 Package 对象
* @throws IllegalArgumentException
*/
protected Package definePackage(String name, String specTitle,
String specVersion, String specVendor,
String implTitle, String implVersion,
String implVendor, URL sealBase)
throws IllegalArgumentException
{
synchronized (packages) {
// 获取由此类加载器或其任何祖先所定义的 Package
Package pkg = getPackage(name);
if (pkg != null) {
throw new IllegalArgumentException(name);
}
pkg = new Package(name, specTitle, specVersion, specVendor,
implTitle, implVersion, implVendor,
sealBase, this);
packages.put(name, pkg);
return pkg;
}
}
/**
* 返回由此类加载器或其任何祖先所定义的 Package。
* @param name	包名
* @return	与给定名称相对应的 Package；如果没有这样的包，则返回 null
*/
protected Package getPackage(String name) {
Package pkg;
synchronized (packages) {
pkg = packages.get(name);
}
if (pkg == null) {
if (parent != null) {
// 获取祖先所定义的 Package
pkg = parent.getPackage(name);
} else {
// 返回指定名称的已加载系统包。
pkg = Package.getSystemPackage(name);
}
if (pkg != null) {
synchronized (packages) {
Package pkg2 = packages.get(name);
if (pkg2 == null) {
packages.put(name, pkg);
} else {
pkg = pkg2;
}
}
}
}
return pkg;
}
/**
* 返回此类加载器及其祖先所定义的所有 Package
* @return
*/
protected Package[] getPackages() {
Map<String, Package> map;
synchronized (packages) {
map = new HashMap<>(packages);
}
Package[] pkgs;
if (parent != null) {
// 返回祖先所定义的所有 Package
pkgs = parent.getPackages();
} else {
// 返回已加载系统包的数组。
pkgs = Package.getSystemPackages();
}
if (pkgs != null) {
for (int i = 0; i < pkgs.length; i++) {
String pkgName = pkgs[i].getName();
if (map.get(pkgName) == null) {
map.put(pkgName, pkgs[i]);
}
}
}
return map.values().toArray(new Package[map.size()]);
}
// -- Native library access --
/**
* 返回本机库的绝对路径名。虚拟机 (VM) 调用此方法来查找那些属于利用此类加载器加载的类的本机库。
* 如果此方法返回 null，则虚拟机沿指定为 "java.library.path" 属性的路径搜索该库。
* @param libname	库名称
* @return	本机库的绝对路径
*/
protected String findLibrary(String libname) {
return null;
}
/**
* 内部类NativeLibrary表示加载的本机库实例。
* 每个类加载器在私有字段nativeLibraries中包含一个已加载本机库的向量。
* 加载到系统中的本机库被输入到systemNativeLibraries vector。
*
* 每个本机库都需要特定版本的JNI。
* 这由私有的JNI Version字段表示。
* 这个字段是VM在加载库时设置的，
* 并由VM用于将正确版本的JNI传递给本机方法。
*/
static class NativeLibrary {
// 本机库的不透明句柄，在本机代码中使用。
long handle;
// 本机库需要的JNI环境版本。
private int jniVersion;
// 加载库的类还指示此本机库所属的加载器。
private final Class<?> fromClass;
//本机库的规范化名称。或静态库名
String name;
// 指示本机库是否链接到VM
boolean isBuiltin;
// 指示是否加载本机库
boolean loaded;
native void load(String name, boolean isBuiltin);
native long find(String name);
native void unload(String name, boolean isBuiltin);
public NativeLibrary(Class<?> fromClass, String name, boolean isBuiltin) {
this.name = name;
this.fromClass = fromClass;
this.isBuiltin = isBuiltin;
}
protected void finalize() {
synchronized (loadedLibraryNames) {
if (fromClass.getClassLoader() != null && loaded) {
/* 删除本机库名称 */
int size = loadedLibraryNames.size();
for (int i = 0; i < size; i++) {
if (name.equals(loadedLibraryNames.elementAt(i))) {
loadedLibraryNames.removeElementAt(i);
break;
}
}
/* 卸载库。 */
ClassLoader.nativeLibraryContext.push(this);
try {
unload(name, isBuiltin);
} finally {
ClassLoader.nativeLibraryContext.pop();
}
}
}
}
// 在VM中调用，以确定JNI_Load/JNI_Unload中的上下文类
static Class<?> getFromClass() {
return ClassLoader.nativeLibraryContext.peek().fromClass;
}
}
// 我们加载的所有本机库名称。
private static Vector<String> loadedLibraryNames = new Vector<>();
// 属于系统类的本机库。
private static Vector<NativeLibrary> systemNativeLibraries
= new Vector<>();
// 与类装载器关联的本机库。
private Vector<NativeLibrary> nativeLibraries = new Vector<>();
// 正在加载/卸载本机库。
private static Stack<NativeLibrary> nativeLibraryContext = new Stack<>();
// 路径搜索库
private static String usr_paths[];
private static String sys_paths[];
/**
* 初始化库路径
* @param propname
* @return
*/
private static String[] initializePath(String propname) {
// 获取指定键指示的系统属性
String ldpath = System.getProperty(propname, "");
String ps = File.pathSeparator;
int ldlen = ldpath.length();
int i, j, n;
// 计算路径中的分隔符
i = ldpath.indexOf(ps);
n = 0;
while (i >= 0) {
n++;
i = ldpath.indexOf(ps, i + 1);
}
// 分配路径数组- n:'s = n + 1路径元素
String[] paths = new String[n + 1];
// 用ldpath中的路径填充数组
n = i = 0;
j = ldpath.indexOf(ps);
while (j >= 0) {
if (j - i > 0) {
paths[n++] = ldpath.substring(i, j);
} else if (j - i == 0) {
paths[n++] = ".";
}
i = j + 1;
j = ldpath.indexOf(ps, i);
}
paths[n] = ldpath.substring(i, ldlen);
return paths;
}
/**
* 在java.lang中调用。运行时类来实现load和loadLibrary。
* @param fromClass
* @param name
* @param isAbsolute
*/
static void loadLibrary(Class<?> fromClass, String name,
boolean isAbsolute) {
ClassLoader loader =
(fromClass == null) ? null : fromClass.getClassLoader();
if (sys_paths == null) {
usr_paths = initializePath("java.library.path");
sys_paths = initializePath("sun.boot.library.path");
}
if (isAbsolute) {
if (loadLibrary0(fromClass, new File(name))) {
return;
}
throw new UnsatisfiedLinkError("Can't load library: " + name);
}
if (loader != null) {
// 返回本机库的绝对路径名。
String libfilename = loader.findLibrary(name);
if (libfilename != null) {
File libfile = new File(libfilename);
// 测试此抽象路径名是否为绝对路径名。
if (!libfile.isAbsolute()) {
throw new UnsatisfiedLinkError(
"ClassLoader.findLibrary failed to return an absolute path: " + libfilename);
}
if (loadLibrary0(fromClass, libfile)) {
return;
}
throw new UnsatisfiedLinkError("Can't load " + libfilename);
}
}
for (int i = 0 ; i < sys_paths.length ; i++) {
// 加载由 libname 参数指定的系统库。
File libfile = new File(sys_paths[i], System.mapLibraryName(name));
if (loadLibrary0(fromClass, libfile)) {
return;
}
libfile = ClassLoaderHelper.mapAlternativeName(libfile);
if (libfile != null && loadLibrary0(fromClass, libfile)) {
return;
}
}
if (loader != null) {
for (int i = 0 ; i < usr_paths.length ; i++) {
// 加载由 libname 参数指定的用户库。
File libfile = new File(usr_paths[i],
System.mapLibraryName(name));
if (loadLibrary0(fromClass, libfile)) {
return;
}
// 返回给定文件的备用路径名
libfile = ClassLoaderHelper.mapAlternativeName(libfile);
if (libfile != null && loadLibrary0(fromClass, libfile)) {
return;
}
}
}
// 失败
throw new UnsatisfiedLinkError("no " + name + " in java.library.path");
}
private static native String findBuiltinLib(String name);
private static boolean loadLibrary0(Class<?> fromClass, final File file) {
// 检查是否试图访问静态库
String name = findBuiltinLib(file.getName());
boolean isBuiltin = (name != null);
if (!isBuiltin) {
boolean exists = AccessController.doPrivileged(
new PrivilegedAction<Object>() {
public Object run() {
return file.exists() ? Boolean.TRUE : null;
}})
!= null;
if (!exists) {
return false;
}
try {
// 返回此抽象路径名的规范形式
name = file.getCanonicalPath();
} catch (IOException e) {
return false;
}
}
ClassLoader loader =
(fromClass == null) ? null : fromClass.getClassLoader();
Vector<NativeLibrary> libs =
loader != null ? loader.nativeLibraries : systemNativeLibraries;
synchronized (libs) {
int size = libs.size();
for (int i = 0; i < size; i++) {
NativeLibrary lib = libs.elementAt(i);
if (name.equals(lib.name)) {
return true;
}
}
synchronized (loadedLibraryNames) {
if (loadedLibraryNames.contains(name)) {
throw new UnsatisfiedLinkError
("Native Library " +
name +
" already loaded in another classloader");
}
/* 如果正在加载库(必须是同样的线程,因为运行时。加载和运行时。loadLibrary同步)。
* 原因是JNI_OnLoad函数可能导致另一个loadLibrary调用。
*
* 因此，我们可以使用静态堆栈来保存正在加载的库列表。
*
* 如果库有一个挂起的加载操作，
* 我们立即回报成功;否则，我们会产生UnsatisfiedLinkError。
*/
int n = nativeLibraryContext.size();
for (int i = 0; i < n; i++) {
NativeLibrary lib = nativeLibraryContext.elementAt(i);
if (name.equals(lib.name)) {
if (loader == lib.fromClass.getClassLoader()) {
return true;
} else {
throw new UnsatisfiedLinkError
("Native Library " +
name +
" is being loaded in another classloader");
}
}
}
NativeLibrary lib = new NativeLibrary(fromClass, name, isBuiltin);
nativeLibraryContext.push(lib);
try {
lib.load(name, isBuiltin);
} finally {
nativeLibraryContext.pop();
}
if (lib.loaded) {
loadedLibraryNames.addElement(name);
libs.addElement(lib);
return true;
}
return false;
}
}
}
/**
* 在VM类链接代码中调用。
* @param loader
* @param name
* @return
*/
static long findNative(ClassLoader loader, String name) {
Vector<NativeLibrary> libs =
loader != null ? loader.nativeLibraries : systemNativeLibraries;
synchronized (libs) {
int size = libs.size();
for (int i = 0; i < size; i++) {
NativeLibrary lib = libs.elementAt(i);
long entry = lib.find(name);
if (entry != 0)
return entry;
}
}
return 0;
}
// -- Assertion management --
// ssertion管理
final Object assertionLock;
/*
* 断言检查的默认切换。
* @GuardedBy (“assertionLock”)
*/
private boolean defaultAssertionStatus = false;
/*
* 将字符串packageName映射到布尔包的默认断言状态。
* 如果该字段为null，则我们将断言状态查询委托给VM，即没有调用这个类加载器的断言状态修改方法。
* @GuardedBy (“assertionLock”)
*/
private Map<String, Boolean> packageAssertionStatus = null;
/*
* 如果该字段为空，则我们将断言状态查询委托给VM，即没有调用这个类加载器的断言状态修改方法。
* @GuardedBy (“assertionLock”)
*/
Map<String, Boolean> classAssertionStatus = null;
/**
* 设置此类加载器的默认断言状态。
* 此设置确定由此类加载器加载并在将来初始化的类在默认情况下是启用还是禁用断言。
* 通过调用 setPackageAssertionStatus(String, boolean) 或 setClassAssertionStatus(String, boolean)，
* 在每个包或每个类上重写此设置。
* @param enabled	如果由此类加载器加载的类将默认为启用断言，则该参数为 true；如果默认为禁用断言，则该参数为 false。
*/
public void setDefaultAssertionStatus(boolean enabled) {
synchronized (assertionLock) {
if (classAssertionStatus == null)
// 使用VM提供的信息设置断言。
initializeJavaAssertionMaps();
defaultAssertionStatus = enabled;
}
}
/**
* 为指定包设置默认断言状态。包的默认断言状态确定了以后初始化属于指定包或其子包的类的断言状态。
* 名为 p 的包的子包是所有名称以 "p." 开头的包。
* 例如，javax.swing.text 是 javax.swing 的子包，java.util 和 java.lang.reflect 是 java 的子包。
* 如果默认情况下多个包可应用于一个给定类，则默认与最特殊的包相关的包拥有高于其他包的优先级。
* 例如，如果 javax.lang 和 javax.lang.reflect 都具有与之相关的默认包，
* 则将后者应用于 javax.lang.reflect 中的类。
* 包的优先级默认情况下高于类加载器的默认断言状态，
* 并且可以通过调用 setClassAssertionStatus(String, boolean) 在每个类的基础上进行重写。
* @param packageName	要设置其默认包断言状态的包名。
* @param enabled	如果由此类加载器加载并属于指定包或其子包的类在默认情况下启用断言，
*
则该参数为 true；如果在默认情况下禁用断言，则该参数为 false。
*/
public void setPackageAssertionStatus(String packageName,
boolean enabled) {
synchronized (assertionLock) {
if (packageAssertionStatus == null)
// 使用VM提供的信息设置断言。
initializeJavaAssertionMaps();
packageAssertionStatus.put(packageName, enabled);
}
}
/**
* 设置在此类加载器及其包含的嵌套类中指定的最高层类所需的断言状态。
* 该设置的优先级高于类加载器的默认断言状态以及可用的任何包的默认值。
* 如果已经初始化指定类，则此方法无效。（初始化类后，其断言状态无法再改变。）
* 如果指定类不是最高层的类，则此调用对任何类的实际断言都无效。
* @param className	将要设置其断言状态的最高层类的完全限定类名。
* @param enabled	如果指定类在初始化时启用断言，则该参数为true；如果该类禁用断言，则该参数为false。
*/
public void setClassAssertionStatus(String className, boolean enabled) {
synchronized (assertionLock) {
if (classAssertionStatus == null)
initializeJavaAssertionMaps();
classAssertionStatus.put(className, enabled);
}
}
/**
* 将此类加载器的默认断言状态设置为 false，并放弃与此类加载器关联的所有默认包或类断言状态设置。
* 提供此方法可以让类加载器忽略任何命令行或持久断言状态设置，并且“无不良记录”。
*/
public void clearAssertionStatus() {
/*
* 无论“Java断言映射”是否初始化，
* 将它们设置为空映射，有效地忽略任何当前设置。
*/
synchronized (assertionLock) {
classAssertionStatus = new HashMap<>();
packageAssertionStatus = new HashMap<>();
defaultAssertionStatus = false;
}
}
/**
* 返回将分配给指定类的断言状态(如果在调用此方法时初始化该类)。
* 如果指定的类已经设置了断言状态，则返回最近的设置;
* 否则，如果任何包的默认断言状态属于这个类，
* 返回最特定的相关包默认断言状态的最新设置;
* 否则，将返回这个类装入器的默认断言状态。
* @param className	正在查询所需断言状态的类的完全限定类名
* @return	指定类的所需断言状态
*/
boolean desiredAssertionStatus(String className) {
synchronized (assertionLock) {
// assert classAssertionStatus
!= null;
// assert packageAssertionStatus != null;
// 检查类entry
Boolean result = classAssertionStatus.get(className);
if (result != null)
return result.booleanValue();
// 检查大多数特定的包entry
int dotIndex = className.lastIndexOf(".");
if (dotIndex < 0) { // 默认 package
result = packageAssertionStatus.get(null);
if (result != null)
return result.booleanValue();
}
while(dotIndex > 0) {
className = className.substring(0, dotIndex);
result = packageAssertionStatus.get(className);
if (result != null)
return result.booleanValue();
dotIndex = className.lastIndexOf(".", dotIndex-1);
}
// 返回类加载器默认值
return defaultAssertionStatus;
}
}
/**
* 使用VM提供的信息设置断言。
* 注意:应该只在同步块中调用
*/
private void initializeJavaAssertionMaps() {
// assert Thread.holdsLock(assertionLock);
classAssertionStatus = new HashMap<>();
packageAssertionStatus = new HashMap<>();
// 从VM检索断言指令。
AssertionStatusDirectives directives = retrieveDirectives();
// 类断言状态处理
for(int i = 0; i < directives.classes.length; i++)
classAssertionStatus.put(directives.classes[i],
directives.classEnabled[i]);
// 包断言状态处理
for(int i = 0; i < directives.packages.length; i++)
packageAssertionStatus.put(directives.packages[i],
directives.packageEnabled[i]);
// 默认断言状态处理
defaultAssertionStatus = directives.deflt;
}
// 从VM检索断言指令。
private static native AssertionStatusDirectives retrieveDirectives();
}
class SystemClassLoaderAction
implements PrivilegedExceptionAction<ClassLoader> {
private ClassLoader parent;
SystemClassLoaderAction(ClassLoader parent) {
this.parent = parent;
}
public ClassLoader run() throws Exception {
String cls = System.getProperty("java.system.class.loader");
if (cls == null) {
return parent;
}
Constructor<?> ctor = Class.forName(cls, true, parent)
.getDeclaredConstructor(new Class<?>[] { ClassLoader.class });
ClassLoader sys = (ClassLoader) ctor.newInstance(
new Object[] { parent });
Thread.currentThread().setContextClassLoader(sys);
return sys;
}
}