【JVM】类加载器 and破坏双亲委派模型实现

最近和朋友讨论的时候聊到最近有被问到关于类加载子系统这一块怎么自己实现一个子系统，对这个比较感兴趣，于是整理相关知识，并且实践 了一下。

JVM启动过程：

启动类

1、启动JVM虚拟机，先创建出package sun.misc.Laucher实例

2、Laucher构造方法中看到，loader包装/创建了App、Ext两个类加载器

3、由getClassLoader返回loader对象（不仅仅内含AppClassLoader）

    public ClassLoader getClassLoader() {
return loader;
    }

双亲委派模型

java.lang.ClassLoader#loadClass(java.lang.String, boolean)

双亲委派模型优点：

看看它有啥优点吧，Java字节码文件刚进来就执行这么个方法，那么这么设计必然有其优越性。这里就体现在了——安全性上。沙箱机制

第一次进来的类文件，总是要先过问更高级的类加载器，然后再一级一级下来，直到在类加载器的类路径中找到同全限名的类为止。

保证了核心的类被更高级的类加载器加载，而用户自定义的加载器也无法对Java程序进行程序注入等错误。

而第二次进来就直接去加载器里面找，凡是加载过的都能马上找到，所以也保证了效率。（其他的优点待补充……）

自己实现一个类加载器

public class MyClass {
public static void main(String[] args) throws Exception {
// 自定义D盘类加载器
MyClassLoader classLoader = new MyClassLoader("D:/test");
Class clazz = classLoader.loadClass("com.p1031.hello");
System.out.println(clazz.getClassLoader().getClass().getName());
    }

static class MyClassLoader extends ClassLoader {

private String classPath;

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

/**
* @apiNote  磁盘文件变为 byte[]
*/
private byte[] loadByte(String name) throws Exception {
name = name.replaceAll("\\.", "/");
FileInputStream fis = new FileInputStream(classPath + "/" + name + ".class");
int len = fis.available();
byte[] data = new byte[len];
fis.read(data);
fis.close();
return data;
        }

/**
* 重点是这里，重写findClass方法
* 默认内部是throw new ClassNotFoundException(name);
* 这里重写一下，为了使用 【指定类加载器】加载【指定的类】
*/
protected Class<?> findClass(String name) throws ClassNotFoundException {
try {
// 加载class文件到byte数组中临时存储，因为defineClass使用的是byte数组来进行操作。
byte[] data = loadByte(name);
//defineClass把data转为Class文件
// 1、类的验证；准备；解析过程，赋初始值都在这里做的，这里是一堆native方法
// 2、弄完之后在内存的方法区会出现该类的信息
// 3、走完上述步骤之后会生成一个类模板返回去
return defineClass(name, data, 0, data.length);
            } catch (Exception e) {
e.printStackTrace();
throw new ClassNotFoundException();
            }
        }
    }
}

双亲委派机制还有效吗？

– 如果在指定位置没有发现该类，那么会到类路径中找到该类，说明双亲委派机制还有效 –

破坏双亲委派机制

思路：

2. 上面只是重写了findClass，那么其实里面还是会用到双亲委派，只要是双亲委派，就必定会维护核心的类为更高级的加载器加载。那么如何破坏？
3. 不使用双亲委派机制，只使用一个类加载器，断开双亲的联系
4. 后面证实这样做不行，因为Object类是所有类的父类，所以我们还需要去加载rt.jar包，这个自己重写是没用的。必须要getSystemClassLoader();

实现：

public class MyClass {
public static void main(String[] args) throws Exception {
MyClassLoader classLoader = new MyClassLoader("D:/test");
Class clazz = classLoader.loadClass("com.p1031.hello");
System.out.println(clazz.getClassLoader().getClass().getName());
    }

static class MyClassLoader extends ClassLoader {

private String classPath;

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

protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
synchronized (getClassLoadingLock(name)) {
Class<?> whatIWant = findLoadedClass(name);

// 1、直接让启动类加载器加载一次，不然会报错
ClassLoader systemClassLoader = getSystemClassLoader();
try {
whatIWant = systemClassLoader.loadClass(name);
                } catch (Exception r) {}

// 2、这里就是使用到自己实现的方法找类
if (whatIWant == null) {
long t1 = System.nanoTime();
whatIWant = findClass(name);
sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
sun.misc.PerfCounter.getFindClasses().increment();
                }
if (resolve) {
resolveClass(whatIWant);
                }
return whatIWant;
            }
        }

// @apiNote 磁盘文件变为数组，去上面复制，太长了
private byte[] loadByte(String name) throws Exception {}

// 为了使用 【指定类加载器】加载【指定的类】
protected Class<?> findClass(String name) throws ClassNotFoundException {}
    }
}

成功。

注意：

1、可能的报错

但是如果不加入引导类加载器会爆出这个错误：class (系统找不到指定的路径。)

// 1、重写的loadClass这句话一定要写，直接让启动类加载器加载一次，不然会报错
ClassLoader systemClassLoader = getSystemClassLoader();
try {
whatIWant = systemClassLoader.loadClass(name);
} catch (Exception r) {}

2、hello.java的源文件