类加载机制

一个java类的main方法是如何执行的？第一步就是通过类加载器将其加载到JVM中。

类加载过程：加载 > 验证 > 准备 > 解析 > 初始化 > 使用 > 卸载

加载：通过IO读入字节码文件，在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口。

验证：验证字节码文件的正确性，比如验证这是不是一个class文件，格式正不正确。

准备：给静态变量分配内存和赋默认值。

解析：把一些静态方法替换为指针或者句柄等，是把符号引用替换为直接引用，称之为静态链接。

初始化：静态变量赋指定值，执行静态代码块。

类被加载到方法区之后，方法区包含哪些：运行时常量池、类型信息、字段信息、方法信息、类加载器的引用、对应class实例的引用等。

 

注意一点，一个包里面的类不是一次性全部加载的，使用时才会加载，看下面的Demo示例：

public class DynamicLoad {
    static {
        System.out.println("测试使用时才会加载类");
    }
    public static void main(String[] args) {
        new A();
        B b = null;
    }
}
class A {
    static {
        System.out.println("加载A");
    }
    public A() {
        System.out.println("初始化A");
    }
}
class B {
    static {
        System.out.println("加载B");
    }
    public B() {
        System.out.println("初始化B");
    }
}

输出结果：

测试使用时才会加载类
加载A
初始化A

类加载器：

• 引导类加载器，加载JRE的lib目录下的核心类库
• 扩展类加载器，加载JRE的lib目录下的ext中的拓展类库
• 应用程序类加载器，负责加载ClassPath路径下的类
• 自定义加载器：负责加载用户自定义路径下的类

打印一下某个加载器能加载到哪些类：

# 引导类加载器加载文件
URL[] urls = Launcher.getBootstrapClassPath().getURLs();
for (int i = 0; i < urls.length; i++) {
    System.out.println(urls[i]);
}
System.out.println("********************");
# 扩展类加载器加载文件
System.out.println(System.getProperty("java.ext.dirs"));
System.out.println("********************");
# 应用程序类加载器加载文件
System.out.println(System.getProperty("java.class.path"));

类加载器都是由com.misc.Launcher这个类负责创建的，可以看下这个类的构造方法：

// 这个类是单例的
private static Launcher launcher = new Launcher();    
public Launcher() {
　　Launcher.ExtClassLoader var1;
　　　　try {
　　　　// 引导类加载器，其父加载器设置为null，因为父加载器是引导类加载器，这是虚拟机处理的，不属于java的范畴
　　　　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);
　　　　}
　　}
}

从上面构造方法，了解到了应用程序类加载器的父加载器是扩展类加载器，这其实是为了双亲委派的加载模式，加载某个类时，会先委托父加载器加载，如果父加载器在类加载路径下都加载不到，会再返回给自己的类加载器加载。

AppClassLoader的顶级父类是ClassLoader，在它的loadClass方法中实现了双亲委派模式：

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 thrown if class not found
　　　　　　　　// from the non-null parent class loader
　　　　　　}
　　　　　　if (c == null) {
　　　　　　　　// class还未被加载，调用findClass加载类
　　　　　　　　long t1 = System.nanoTime();
　　　　　　　　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) {
　　　　　　resolveClass(c);
　　　　}
　　　　return c;
　　}
}    

设计双亲委派的意义在于：避免类库被随意加载，比如java.lang.Integer类只能由引导类加载器加载，如果任何一个加载器都能加载的话，不就可以篡改了么。第二点是避免重复加载。

一个类被加载之后，它所依赖的类也会被当前类的类加载器所加载，除非显示的指定使用其他的类加载器。

下面自定义一个类加载器：

// 定义一个User类，之后通过自定义类加载器进行加载
public class User {

    private String id;

    private String name;
    
    public void print() {
        System.out.println("CustomClassLoader user");
    }
}

要自定义类加载器，需要继承ClassLoader，重写findClass即可

public class CustomClassLoader extends ClassLoader {

    String classPath;

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

    /**
     * 读取class文件，将文件读取为字节数组
     *
     * @param name
     * @return
     * @throws Exception
     */
    private byte[] loadByte(String name) throws Exception {
        // 包名替换成路径
        name = name.replaceAll("\.", "/");
        // 获取class文件路径
        FileInputStream fis = new FileInputStream(classPath + "/" + name + ".class");
        int len = fis.available();
        byte[] data = new byte[len];
        fis.read(data);
        fis.close();
        return data;
    }

    /**
     * 重写findClass，将字节数组转为Class对象，只要调用ClassLoader的defineClass方法即可
     *
     * @param name
     * @return
     * @throws ClassNotFoundException
     */
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        try {
            byte[] data = loadByte(name);
            return defineClass(name, data, 0, data.length);
        } catch (Exception e) {
            e.printStackTrace();
            throw new ClassNotFoundException();
        }
    }

    public static void main(String[] args) throws Exception {
        CustomClassLoader customClassLoader = new CustomClassLoader("/Users/project/JVM/src/main/java");
        Class<?> clazz = customClassLoader.findClass("com.dluo.loader.User");
        Object instance = clazz.newInstance();
        Method print = clazz.getDeclaredMethod("print");
        print.invoke(instance, null);
        System.out.println(instance.getClass().getClassLoader().getClass());
    }
    
}

看输出结果，成功执行了User的print方法，打印类加载器的类名，是我们自定义的类加载器

CustomClassLoader user
class com.dluo.loader.CustomClassLoader

常规场景下类加载机制都会使用双亲委派模式，但有些情况下双亲委派会产生限制。比如我们使用tomcat时，它可能会部署多个程序，不同的程序可能使用不同的类库版本，比如一个项目是spring4，而另一个项目是spring5，这样就不能要求一个类只能有一份了，需要使其隔离。所以，从这个角度出发，tomcat类加载器，至少要实现多个版本的类库实现。再拓展来说，同一个容器中的类库应实现共享，要不就会重复，容器自己依赖的类库和应用程序的类库也应该隔离。还有一点值得注意，jsp文件需要编译成class文件运行，而且jsp经常要修改，应该保证能动态更新，所以每个jsp应该都是独一无二的类加载器，加载完即卸载，更新时再重新创建类加载器加载jsp文件。综上，tomcat这种类加载的方式一定违背了双亲委派模式。

重写类加载方法，实现自己的加载逻辑，不委派给双亲加载

    protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
        synchronized (getClassLoadingLock(name)) {
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                long t1 = System.nanoTime();
                // 非自定义的类还是走双亲委派加载
                if (!name.startsWith("com.dluo.loader")) {
                    c = this.getParent().loadClass(name);
                } else {
                    c = findClass(name);
                }
                sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                sun.misc.PerfCounter.getFindClasses().increment();
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }

现在测试一下，看一下能不能加载两个User类。

创建两个目录：

mkdir -p temp1/com/dluo/loader
mkdir -p temp2/com/dluo/loader

将User的print方法输出不同的内容，分别编译为.class文件，copy到对应的temp文件中测试使用

    public static void main(String[] args) throws Exception {
        CustomClassLoader customClassLoader1 = new CustomClassLoader("/Users/dluo/temp1");
        Class<?> clazz1 = customClassLoader1.loadClass("com.dluo.loader.User");
        Object instance1 = clazz1.newInstance();
        Method method1 = clazz1.getDeclaredMethod("print");
        method1.invoke(instance1, null);
        System.out.println(clazz1.getClassLoader());

        CustomClassLoader customClassLoader2 = new CustomClassLoader("/Users/dluo/temp2");
        Class<?> clazz2 = customClassLoader2.loadClass("com.dluo.loader.User");
        Object instance2 = clazz2.newInstance();
        Method method2 = clazz2.getDeclaredMethod("print");
        method2.invoke(instance2, null);
        System.out.println(clazz2.getClassLoader());
    }

输出结果：

版本一类加载器
com.dluo.loader.CustomClassLoader@58372a00
版本二类加载器
com.dluo.loader.CustomClassLoader@568db2f2

从这里可以看到，虽然都是使用CustomClassLoader，但是已经是不同的类加载器实例初始化的了，一个JVM程序中同时存在两个User类，打破了双亲委派加载模式。