JVM类加载机制与双亲委派使用及说明

public class ClassLoaderDemo {
    public static void main(String[] args) {
        // 1. 核心类：由Bootstrap加载，输出null
        ClassLoader bootstrapLoader = String.class.getClassLoader();
        System.out.println("String类加载器: " + bootstrapLoader);

        // 2. 系统类加载器（应用类加载器）
        ClassLoader appLoader = ClassLoaderDemo.class.getClassLoader();
        System.out.println("自定义类加载器: " + appLoader);

        // 3. 应用类加载器的父加载器：扩展类加载器
        ClassLoader extLoader = appLoader.getParent();
        System.out.println("应用类加载器的父加载器: " + extLoader);

        // 4. 扩展类加载器的父加载器：Bootstrap，输出null
        System.out.println("扩展类加载器的父加载器: " + extLoader.getParent());
    }
}

protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
    synchronized (getClassLoadingLock(name)) {
        // 1. 检查类是否已经被当前加载器加载
        Class<?> c = findLoadedClass(name);
        if (c == null) {
            try {
                // 2. 递归委托父加载器加载
                if (parent != null) {
                    c = parent.loadClass(name, false);
                } else {
                    // 3. 无父加载器，直接使用启动类加载器
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {
                // 父加载器无法加载，捕获异常
            }
            // 4. 父加载器加载失败，当前加载器自行加载
            if (c == null) {
                c = findClass(name);
            }
        }
        // 解析类
        if (resolve) {
            resolveClass(c);
        }
        return c;
    }
}

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.IOException;

/**
 * 打破双亲委派的自定义类加载器
 */
public class CustomClassLoader extends ClassLoader {
    // 自定义类加载路径
    private final String classPath;

    public CustomClassLoader(String classPath) {
        // 关键：不指定父加载器（默认父加载器为系统类加载器，也可手动设置）
        this.classPath = classPath;
    }

    /**
     * 重写loadClass，核心：跳过双亲委派的向上委托逻辑
     */
    @Override
    public Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
        synchronized (getClassLoadingLock(name)) {
            // 1. 检查是否已加载
            Class<?> clazz = findLoadedClass(name);
            if (clazz != null) {
                return clazz;
            }

            // 2. 打破规则：核心类仍交给Bootstrap加载，避免JDK核心类加载异常
            if (name.startsWith("java.")) {
                return getSystemClassLoader().loadClass(name);
            }

            // 3. 不委托父加载器，直接自己加载
            try {
                clazz = findClass(name);
            } catch (Exception e) {
                // 加载失败，降级为系统类加载器加载
                return super.loadClass(name, resolve);
            }

            if (resolve) {
                resolveClass(clazz);
            }
            return clazz;
        }
    }

    /**
     * 重写findClass：从自定义路径读取字节码
     */
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        byte[] classData = getClassBytes(name);
        if (classData == null) {
            throw new ClassNotFoundException("无法找到类：" + name);
        }
        // 将字节码转换为Class对象
        return defineClass(name, classData, 0, classData.length);
    }

    /**
     * 从文件系统读取.class字节码
     */
    private byte[] getClassBytes(String className) {
        String path = classPath + "/" + className.replace(".", "/") + ".class";
        try (FileInputStream fis = new FileInputStream(path);
             ByteArrayOutputStream bos = new ByteArrayOutputStream()) {

            byte[] buffer = new byte[1024];
            int len;
            while ((len = fis.read(buffer)) != -1) {
                bos.write(buffer, 0, len);
            }
            return bos.toByteArray();
        } catch (IOException e) {
            return null;
        }
    }
}

public class TestCustomLoader {
    public static void main(String[] args) throws Exception {
        // 自定义加载路径
        CustomClassLoader loader = new CustomClassLoader("D:/test/classes");
        // 加载自定义类
        Class<?> clazz = loader.loadClass("com.test.DemoClass");
        // 打印加载器，验证为自定义加载器
        System.out.println("类加载器: " + clazz.getClassLoader());
    }
}