// 查看類加載器層級結構的示例代碼
public class ClassLoaderHierarchy {
    public static void main(String[] args) {
        // 獲取當前類的類加載器
        ClassLoader classLoader = ClassLoaderHierarchy.class.getClassLoader();
        System.out.println("當前類的類加載器：" + classLoader);
        
        // 獲取父類加載器
        ClassLoader parentClassLoader = classLoader.getParent();
        System.out.println("父類加載器：" + parentClassLoader);
        
        // 獲取祖父類加載器
        ClassLoader grandParentClassLoader = parentClassLoader.getParent();
        System.out.println("祖父類加載器：" + grandParentClassLoader);
        
        // 輸出結果：
        // 當前類的類加載器：sun.misc.Launcher$AppClassLoader@2a139a55
        // 父類加載器：sun.misc.Launcher$ExtClassLoader@15db9742
        // 祖父類加載器：null (Bootstrap ClassLoader由C++實現，在Java中顯示為null)
    }
}

graph TD
    A[自定義類加載器] --> B[應用程序類加載器]
    B --> C[擴展類加載器]
    C --> D[啟動類加載器]
    D --> E{能否加載?}
    E -->|能| F[加載完成]
    E -->|不能| G[委派給子類加載器]
    G --> H{擴展類加載器能否加載?}
    H -->|能| I[加載完成]
    H -->|不能| J[委派給子類加載器]
    J --> K{應用程序類加載器能否加載?}
    K -->|能| L[加載完成]
    K -->|不能| M[委派給子類加載器]
    M --> N{自定義類加載器能否加載?}
    N -->|能| O[加載完成]
    N -->|不能| P[拋出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 {
                    // 如果沒有父類加載器，說明是啟動類加載器
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {
                // 如果父類加載器拋出ClassNotFoundException
                // 說明父類加載器無法完成加載請求
            }

            if (c == null) {
                // 如果父類加載器無法加載，則調用自己的findClass方法進行加載
                long t1 = System.nanoTime();
                c = findClass(name);
                
                // 記錄加載時間統(tǒng)計
                sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                sun.misc.PerfCounter.getFindClasses().increment();
            }
        }
        if (resolve) {
            resolveClass(c);
        }
        return c;
    }
}

public class CustomClassLoader extends ClassLoader {
    @Override
    protected Class<?> loadClass(String name, boolean resolve) 
        throws ClassNotFoundException {
        // 首先檢查是否已經加載
        Class<?> c = findLoadedClass(name);
        if (c == null) {
            // 對于自定義的類，直接由當前類加載器加載
            if (name.startsWith("com.example.")) {
                c = findClass(name);
            } else {
                // 其他類仍然遵循雙親委派
                c = super.loadClass(name, resolve);
            }
        }
        if (resolve) {
            resolveClass(c);
        }
        return c;
    }
    
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        // 實現自定義的類加載邏輯
        byte[] classData = loadClassData(name);
        return defineClass(name, classData, 0, classData.length);
    }
    
    private byte[] loadClassData(String name) {
        // 從自定義位置加載類的字節(jié)碼
        // 這里可以從網絡、數據庫等位置加載
        return null; // 簡化示例
    }
}

public class ContextClassLoaderExample {
    public static void main(String[] args) {
        // 獲取當前線程的上下文類加載器
        ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
        System.out.println("上下文類加載器：" + contextClassLoader);
        
        // 設置自定義的上下文類加載器
        Thread.currentThread().setContextClassLoader(new CustomClassLoader());
        
        // 在某些框架中，會使用上下文類加載器來加載類
        // 例如：JDBC驅動加載、Spring容器等
    }
}

public class HotSwapClassLoader extends ClassLoader {
    @Override
    protected Class<?> loadClass(String name, boolean resolve) 
        throws ClassNotFoundException {
        Class<?> c = findLoadedClass(name);
        if (c == null) {
            // 對于需要熱替換的類，每次都重新加載
            if (isHotSwapClass(name)) {
                c = findClass(name);
            } else {
                c = super.loadClass(name, resolve);
            }
        }
        if (resolve) {
            resolveClass(c);
        }
        return c;
    }
    
    private boolean isHotSwapClass(String name) {
        // 判斷是否是需要熱替換的類
        return name.startsWith("com.example.hotswap");
    }
}

// Tomcat的類加載器層級結構
// Bootstrap ClassLoader
//     |
// System ClassLoader
//     |
// Common ClassLoader
//     |
// Catalina ClassLoader  Shared ClassLoader
//                           |
//                      WebApp ClassLoader