深入理解类加载机制：拨开迷雾见真章

package cn.itlemon.naixue.reflection.classload;

public class ClInitTest {

    private static int index;

    static {
        index = 1000;
    }

}

public class cn/itlemon/naixue/reflection/classload/ClInitTest {

  // compiled from: ClInitTest.java

  // access flags 0xA
  private static I index

  // access flags 0x1
  public <init>()V
   L0
    LINENUMBER 7 L0
    ALOAD 0
    INVOKESPECIAL java/lang/Object.<init> ()V
    RETURN
   L1
    LOCALVARIABLE this Lcn/itlemon/naixue/reflection/classload/ClInitTest; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

  // access flags 0x8
  static <clinit>()V
   L0
    LINENUMBER 12 L0
    SIPUSH 1000
    PUTSTATIC cn/itlemon/naixue/reflection/classload/ClInitTest.index : I
   L1
    LINENUMBER 13 L1
    RETURN
    MAXSTACK = 1
    MAXLOCALS = 0
}

public class MethodHandleMainClass {

    private static int index;

    static {
        index = 10;
        System.out.println("MethodHandleTest init！");
    }

    public static void method(String message) {
        System.out.println("Print Message:" + message);
    }

}

import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;

/**
 * @author jiangpingping
 * @date 2020/7/16 22:20
 */
public class MethodHandleTest {

    public static void main(String[] args) {
        MethodHandles.Lookup lookup = MethodHandles.lookup();
        try {
            MethodHandle method = lookup.findStatic(MethodHandleMainClass.class, "method",
                    MethodType.methodType(void.class, String.class));
            method.invoke("Test init！");
        } catch (Throwable e) {
            e.printStackTrace();
        }
    }

}

MethodHandleTest init！
Print Message:Test init！

public class ParentClass {

    protected static int index = 10;

    static {
        System.out.println("Parent Class init！");
    }

}

public class SonClass extends ParentClass {

    static {
        System.out.println("Son Class init！");
    }

}

public class InitTest {

    public static void main(String[] args) {
        // 通过子类来引用父类静态变量
        System.out.println(SonClass.index);
    }
}

Parent Class init！
10

public class CustomClassLoader extends ClassLoader {

    @Override
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        try {
            String fileName = name.substring(name.lastIndexOf(".") + 1) + ".class";
            // 从classpath下加载指定的类
            InputStream is = getClass().getResourceAsStream(fileName);
            if (is == null) {
                return super.loadClass(name);
            }
            byte[] bytes = new byte[is.available()];
            is.read(bytes);
            return defineClass(name, bytes, 0, bytes.length);
        } catch (IOException e) {
            throw new ClassNotFoundException();
        }
    }
}

public class ClassLoaderTest {

    public static void main(String[] args) throws ClassNotFoundException {
        CustomClassLoader loader = new CustomClassLoader();
        Class<?> aClass1 = loader.loadClass(ClassLoaderTest.class.getName());
        Class<?> aClass2 = loader.loadClass(ClassLoaderTest.class.getName());
        System.out.println(aClass1 == aClass2);
    }

}

Exception in thread "main" java.lang.LinkageError: loader (instance of  cn/itlemon/naixue/reflection/classloader/CustomClassLoader): attempted  duplicate class definition for name: "cn/itlemon/naixue/reflection/classloader/ClassLoaderTest"
	at java.lang.ClassLoader.defineClass1(Native Method)
	at java.lang.ClassLoader.defineClass(ClassLoader.java:763)
	at java.lang.ClassLoader.defineClass(ClassLoader.java:642)
	at cn.itlemon.naixue.reflection.classloader.CustomClassLoader.loadClass(CustomClassLoader.java:25)
	at cn.itlemon.naixue.reflection.classloader.ClassLoaderTest.main(ClassLoaderTest.java:14)

public class ClassLoaderTest {

    public static void main(String[] args) throws ClassNotFoundException {
        // 首先打印出main方法中ClassLoaderTest的类加载器
        System.out.println("ClassLoaderTest默认加载器是：" + ClassLoaderTest.class.getClassLoader());
        CustomClassLoader loader = new CustomClassLoader();
        // 使用我们自定义的类加载器再次加载一遍
        Class<?> aClass = loader.loadClass(ClassLoaderTest.class.getName());
        System.out.println("ClassLoaderTest加载器是：" + aClass.getClassLoader());
        System.out.println("不同类加载器加载的ClassLoaderTest的Class是否相等：" + aClass.equals(ClassLoaderTest.class));
    }

}

ClassLoaderTest默认加载器是：sun.misc.Launcher$AppClassLoader@18b4aac2
ClassLoaderTest加载器是：cn.itlemon.naixue.reflection.classloader.CustomClassLoader@6bc168e5
不同类加载器加载的ClassLoaderTest的Class是否相等：false

public Class<?> loadClass(String name) throws ClassNotFoundException {
    return loadClass(name, false);
}

protected Class<?> loadClass(String name, boolean resolve)
	throws ClassNotFoundException
{
    // 通过类的全限定名称来获取synchronized关键字所需的锁对象
    synchronized (getClassLoadingLock(name)) {
        // 从缓存中根据类名称来查找是否已经加载过该类，这里使用到了native方法，稍后我们一起阅读以下OpenJDK8的源码，看看从缓存中查找的基本逻辑
        Class<?> c = findLoadedClass(name);
        if (c == null) {
        	// 进入到if内，说明该类是第一次被加载
            long t0 = System.nanoTime();
            try {
                if (parent != null) {
                	// 如果父类加载器不为空，将调用父类加载器的loadClass方法去加载指定的类，这里其实利用了递归的思想，直到parent指向了Bootstrap ClassLoader，此时Bootstrap ClassLoader的父类加载器为null，将进入到else代码块中
                    c = parent.loadClass(name, false);
                } else {
               		// 这里启用Bootstrap ClassLoader去尝试加载类
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {
                // ClassNotFoundException thrown if class not found
                // from the non-null parent class loader
            }
			// 如果父类加载器加载的结果是null，将进入到if方法块中由子类加载器的findClass方法去尝试加载类，这也是每个递归都要判断的一个流程，如果某个子类加载器最后加载到了类，那么c将不为null，此时它的子类加载器将不会进入到if方法块中，这就保证了每个类只能被一个类加载器进行加载一次
            if (c == null) {
                // If still not found, then invoke findClass in order
                // to find the class.
                long t1 = System.nanoTime();
                // 由子类加载器自己去尝试加载类，这个方法在ClassLoader类中并没有实现，而是直接抛出ClassNotFoundException，URLClassLoader实现了该方法，该实现也是被Application ClassLoader和Extension ClassLoader所继承共用，稍后我们一起分析一下该方法的逻辑
                c = findClass(name);

                // this is the defining class loader; record the stats
                sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                sun.misc.PerfCounter.getFindClasses().increment();
            }
        }
        if (resolve) {
        	// 如果resolve是true，那么加载后将进行解析
            resolveClass(c);
        }
        return c;
    }
}

protected final Class<?> findLoadedClass(String name) {
	// 检验名称是否有效
    if (!checkName(name))
        return null;
    // 调用native方法去查找缓存
    return findLoadedClass0(name);
}

private native final Class<?> findLoadedClass0(String name);

JNIEXPORT jclass JNICALL
Java_java_lang_ClassLoader_findLoadedClass0(JNIEnv *env, jobject loader,
                                           jstring name)
{
    if (name == NULL) {
        return 0;
    } else {
        return JVM_FindLoadedClass(env, loader, name);
    }
}

JVM_ENTRY(jclass, JVM_FindLoadedClass(JNIEnv *env, jobject loader, jstring name))
  JVMWrapper("JVM_FindLoadedClass");
  // THREAD表示当前线程
  ResourceMark rm(THREAD);
  // 处理name为空的情况
  Handle h_name (THREAD, JNIHandles::resolve_non_null(name));
  // 根据类名获取对应的Handle
  Handle string = java_lang_String::internalize_classname(h_name, CHECK_NULL);

  const char* str   = java_lang_String::as_utf8_string(string());
  // 正常性检查，为空返回null
  if (str == NULL) return NULL;
  // 检查长度是否符合要求
  const int str_len = (int)strlen(str);
  if (str_len > Symbol::max_length()) {
    // It's impossible to create this class;  the name cannot fit
    // into the constant pool.
    return NULL;
  }
  TempNewSymbol klass_name = SymbolTable::new_symbol(str, str_len, CHECK_NULL);

  // Security Note:
  //   The Java level wrapper will perform the necessary security check allowing
  //   us to pass the NULL as the initiating class loader.
  // 获取类加载器对应的Handle
  Handle h_loader(THREAD, JNIHandles::resolve(loader));
  if (UsePerfData) {
    is_lock_held_by_thread(h_loader,
                           ClassLoader::sync_JVMFindLoadedClassLockFreeCounter(),
                           THREAD);
  }
  // 查找目标类对象是否存在
  Klass* k = SystemDictionary::find_instance_or_array_klass(klass_name,
                                                              h_loader,
                                                              Handle(),
                                                              CHECK_NULL);
   // 转换Klass为jclass并返回
  return (k == NULL) ? NULL :
            (jclass) JNIHandles::make_local(env, k->java_mirror());
JVM_END