Java虚拟机类加载器及双亲委派机制

System.out.println("boot:"   System.getProperty("sun.boot.class.path"));
System.out.println("ext:"   System.getProperty("java.ext.dirs"));
System.out.println("app:"   System.getProperty("java.class.path"));

public Launcher() {
    Launcher.ExtClassLoader var1;
    try {
        //初始化扩展类加载器，构造函数没有入参，无法获取启动类加载器
        var1 = Launcher.ExtClassLoader.getExtClassLoader();
    } catch (IOException var10) {
        throw new InternalError("Could not create extension class loader", var10);
    }

    try {
        //初始化应用类加载器，入参为扩展类加载器
        this.loader = Launcher.AppClassLoader.getAppClassLoader(var1);
    } catch (IOException var9) {
        throw new InternalError("Could not create application class loader", var9);
    }

    // 设置上下文类加载器
    Thread.currentThread().setContextClassLoader(this.loader);
    
   //...
}

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) {
                    //如果当前类没有被加载且父类加载器不为null，则请求父类加载器进行加载操作
                    c = parent.loadClass(name, false);
                } else {
                   //如果当前类没有被加载且父类加载器为null，则请求根类加载器进行加载操作
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {
            }

            if (c == null) {
                long t1 = System.nanoTime();
               //如果父类加载器加载失败，则由当前类加载器进行加载，
                c = findClass(name);
                //进行一些统计操作
               // ...
            }
        }
        //初始化该类
        if (resolve) {
            resolveClass(c);
        }
        return c;
    }
}

//加载驱动程序
Class.forName("com.mysql.jdbc.Driver");
//连接数据库
Connection conn = DriverManager.getConnection(url, user, password);

//建立数据库连接底层方法
private static Connection getConnection(
        String url, java.util.Properties info, Class<?> caller) throws SQLException {
    //获取调用者的类加载器
    ClassLoader callerCL = caller != null ? caller.getClassLoader() : null;
    synchronized(DriverManager.class) {
        //由启动类加载器加载的类，该值为null，使用上下文类加载器
        if (callerCL == null) {
            callerCL = Thread.currentThread().getContextClassLoader();
        }
    }

    //...

    for(DriverInfo aDriver : registeredDrivers) {
        //使用上下文类加载器去加载驱动
        if(isDriverAllowed(aDriver.driver, callerCL)) {
            try {
                //加载成功，则进行连接
                Connection con = aDriver.driver.connect(url, info);
                //...
            } catch (SQLException ex) {
                if (reason == null) {
                    reason = ex;
                }
            }
        } 
        //...
    }
}

callerCL = Thread.currentThread().getContextClassLoader();

// 设置上下文类加载器
Thread.currentThread().setContextClassLoader(this.loader);

public class ClassLoaderTest extends ClassLoader {

	private String classPath;

	public ClassLoaderTest(String classPath) {
		this.classPath = classPath;
	}

	/**
	 * 编写findClass方法的逻辑
	 *
	 * @param name
	 * @return
	 * @throws ClassNotFoundException
	 */
	@Override
	protected Class<?> findClass(String name) throws ClassNotFoundException {
		// 获取类的class文件字节数组
		byte[] classData = getClassData(name);
		if (classData == null) {
			throw new ClassNotFoundException();
		} else {
			// 生成class对象
			return defineClass(name, classData, 0, classData.length);
		}
	}

	/**
	 * 编写获取class文件并转换为字节码流的逻辑
	 *
	 * @param className
	 * @return
	 */
	private byte[] getClassData(String className) {
		// 读取类文件的字节
		String path = classNameToPath(className);
		try {
			InputStream is = new FileInputStream(path);
			ByteArrayOutputStream stream = new ByteArrayOutputStream();
			byte[] buffer = new byte[2048];
			int num = 0;
			// 读取类文件的字节码
			while ((num = is.read(buffer)) != -1) {
				stream.write(buffer, 0, num);
			}
			return stream.toByteArray();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 类文件的完全路径
	 *
	 * @param className
	 * @return
	 */
	private String classNameToPath(String className) {
		return classPath   File.separatorChar
				  className.replace('.', File.separatorChar)   ".class";
	}

	public static void main(String[] args) {
		String classPath = "/Users/zzs/my/article/projects/java-stream/src/main/java/";
		ClassLoaderTest loader = new ClassLoaderTest(classPath);

		try {
			//加载指定的class文件
			Class<?> object1 = loader.loadClass("com.secbro2.classload.SubClass");
			System.out.println(object1.newInstance().toString());
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

SuperClass static init
SubClass static init
com.secbro2.classload.SubClass@5451c3a8