java虚拟机（JVM）笔记一：java和Tomcat类加载机制

文章部分来源图灵学院，部分来源网络博文，因为链接具体找不到，这里深感抱歉，如果介意，请留言
知乎：https://zhuanlan.zhihu.com/p/397669677

Java类加载

当我们用java命令运行某个类的main函数启动程序时，首先需要通过类加载器把主类加载到jvm中。类似流程图如下。

loadClass加载步骤

类全生命周期：加载>>验证>>准备>>解析>>初始化>>使用>>卸载。

加载：在硬盘上查找并通过IO兑入字节码文件，使用到类时才会加载，例如调用类的main方法，new对象等等，在加载阶段会在内存中生成一个代表这个类的java.lang.Class对象（推荐），放在堆中，作为访问这个类在方法区中类元数据的各个数据的接口。
验证：校验字节码文件的正确性。如：文件格式的验证，元数据的验证，字节码的验证，符号引用的验证。
准备：给类的静态变量分配内存，并赋予默认值，此处给默认值，不一定是我们程序中赋予的值。如果被final修饰，在编译的时候会给属性添加ConstantValue属性，准备阶段直接完成赋值，即没有赋初值这一步

解析：将符号引用替换为直接引用，该阶段会把一些静态方法（符号引用，比如main()方法）替换为指向数据所存内存的指针或者句柄等（直接引用），这是所谓的静态链接过程（类加载期间完成），动态链接是在程序运行期间完成的，将符号引用替换为直接引用（// TODO 待补充），解析后的信息存储在ConstantPoolCache类实例中
初始化：对类的静态变量初始化为指定的值，执行静态代码块，比如：initData 的666值是此时才赋予的。构造放在在静态代码块之后。

public static final int initData=666;

类被加载到方法区中后，主要包含运行时常量池、类型信息、字段信息、方法信息、类加载器的引用、对应class实例的引用等信息。
类加载器的引用：这个类到 类加载器实例 的引用。
对应class实例的引用：类加载器在加载类信息放到方法区中后，会创建一个对应的Class类型的对象实例放到堆（Heap）中，作为开发人员访问方法区中类定义的入口和切入点。
注意：主类在运行过程中如果使用到其他类，会逐步加载这些列。jar包或者war包里的类不是一次性全部加载的，是使用到时才加载。代码示例如下：

public class TestDynamicLoad {
    static {
        System.out.println("*************load TestDynamicLoad************");
    }

    public static void main(String[] args) {
        new A();
        System.out.println("*************load test************");
        B b = null; //B不会加载，除非这里执行 new B()
    }

}

class A {
    static {
        System.out.println("*************load A************");
    }

    public A() {
        System.out.println("*************initial A************");
    }
}

class B {
    static {
        System.out.println("*************load B************");
    }

    public B() {
        System.out.println("*************initial B************");
    }
}

结果：

*************load TestDynamicLoad************
*************load A************
*************initial A************
*************load test************

类加载机制

类加载过程主要是通过类加载器来实现的，java里有如下几种类加载器。

• 引导类加载器（bootstrapLoader）：负责加载支撑JVM运行的位于JRE的lib目录下的核心类库，比如：rt.jar、charsets.jar等
• 扩展类加载器（ExtClassLoader）：负责加载支撑JVM运行的位于JRE的lib目录下的ext扩展目录中的JAR类包
• 应用程序类加载器（AppClassLoader）：负责加载ClassPath路径下的类包，主要就是加载自己写的那些类。自定义加载器：负责加载用户自定义路径下的类包。

类加载器初始化过程

由上面的加载过程图可知，JVM启动，实例sun.misc.Launcher类，而sun.misc.Launcher构造方法内部，创建了两个类加载器，分别是sun.misc.Launcher.ExtClassLoader(扩展类加载器)和sun.misc.Launcher.AppClassLoader(应用类加载器)。

JVM会默认调用Launcher中的getClassLoader()方法，返回的加载器会是AppClassLoader来加载我们的应用程序。代码截取

//Launcher的构造方法
public Launcher() {
 Launcher.ExtClassLoader var1;
 try {
 //构造扩展类加载器，在构造的过程中将其父加载器设置为null
 var1 = Launcher.ExtClassLoader.getExtClassLoader();
 } catch (IOException var10) {
 throw new InternalError("Could not create extension class loader", var10);
 }

 try {
 //构造应用类加载器，在构造的过程中将其父加载器设置为ExtClassLoader，
 //Launcher的loader属性值是AppClassLoader，我们一般都是用这个类加载器来加载我们自
己写的应用程序
 this.loader = Launcher.AppClassLoader.getAppClassLoader(var1);
 } catch (IOException var9) {
 throw new InternalError("Could not create application class loader", var9);
 }

 Thread.currentThread().setContextClassLoader(this.loader);
 String var2 = System.getProperty("java.security.manager");
 。。。 。。。 //省略一些不需关注代码

}


 public ExtClassLoader(File[] var1) throws IOException {
  // Launcher.ExtClassLoader.getExtClassLoader(); 实例化会走到地方，他父加载器传的是null
  super(getExtURLs(var1), (ClassLoader)null, Launcher.factory);
  SharedSecrets.getJavaNetAccess().getURLClassPath(this).initLookupCache(this);
}

双亲委派机制

JVM类加载器是有亲子层级结构的，如下图：

这里类加载其实就是一个双亲委派机制，加载某个类时，launcher的getClassLoader会给出appClassLoader这个加载器，调用其最上层抽象ClassLoader的loadClass方法，其流程是会先找自己有没**有加载过（并不是加载）**这个类，如果有直接返回，如果没有，则委托父加载器寻找目标类，而此时父加载器（扩展类加载器）同样是实现ClassLoader的类，同样走loadClass方法，逻辑也是找自身是否加载过此类，如果没有，则继续委托其父加载器；如果依然找不到目标类，则在自己的类加载路径中查找并载入目标类。

比如我们的Math类，最先会找应用程序类加载器加载，应用程序类加载器会先委托扩展类加载 器加载，扩展类加载器再委托引导类加载器，顶层引导类加载器在自己的类加载路径里找了半天没找到Math类，则向下退回加载Math类的请求，扩展类加载器收到回复就自己加载，在自己的类加载路径里找了半天也没找到Math类，又向下退回Math类的加载请求给应用程序类加载器，应用程序类加载器于是在自己的类加载路径里找Math类，结果找到了就自己加载了。

//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) {
                    // If still not found, then invoke findClass in order
                    // to find the class.
                    long t1 = System.nanoTime();
                    //都会调用URLClassLoader的findClass方法在加载器的类路径里查找并加载该类
                    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;
        }

双亲委派说简单的，就是先找父亲加载，不行再有儿子自己加载，此处注意：父类加载器和父类不是一个概念。

全盘负责委托机制

“全盘负责”是指当一个ClassLoader装载一个类时，除非显示的使用另一个ClassLoader，该类所有依赖及引用的类也有这个ClassLoader一次载入完毕。（因为正常情况下，依赖和引用类是只有在使用的时候才加载的。）

类关系图

自定义类加载器

自定义类加载器只需要继承java.lang.ClassLoader类，该类由两个核心方法，一个是loadClass(String,boolean),实现了双亲委派机制，还有一个是findClass，默认实现是空方法，所以我们自定义类加载器主要是重写findClass方法（app和ext因为都是继承URLClassLoader，此方法在URLClassLoader中实现了）。

package com.tuling.jvm;

import java.io.File;
import java.io.FileInputStream;
import java.lang.reflect.Method;

/**
 * @Description: 自定义类加载器
 * @ClassName: MyClassLoaderTest
 * @Author: 
 * @Date: 2021/8/11 0:42
 **/
public class MyClassLoaderTest {
    static class MyClassLoader extends ClassLoader {
        private String classPath;

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

        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;

        }

        protected Class<?> findClass(String name) throws ClassNotFoundException {
            try {
                byte[] data = loadByte(name);
                //defineClass将一个字节数组转为Class对象，这个字节数组是class文件读取后最终的字节 数组。
                return defineClass(name, data, 0, data.length);
            } catch (Exception e) {
                e.printStackTrace();
                throw new ClassNotFoundException();
            }
        }
    }

    public static void main(String args[]) throws Exception {
        //初始化自定义类加载器，会先初始化父类ClassLoader，其中会把自定义类加载器的父加载 器设置为应用程序类加载器AppClassLoader
        MyClassLoader classLoader = new MyClassLoader("D:"+ File.separator+"program_test");
        //D盘创建 test/com/tuling/jvm 几级目录，将User类的复制类User1.class丢入该目录
        Class clazz = classLoader.loadClass("com.tuling.jvm.User1");
        Object obj = clazz.newInstance();
        Method method = clazz.getDeclaredMethod("sout", null);
        method.invoke(obj, null);
        System.out.println(clazz.getClassLoader().getClass().getName());
    }
}

打破双亲委派机制

package com.tuling.jvm;

import java.io.File;
import java.io.FileInputStream;
import java.lang.reflect.Method;

/**
 * @Description: 双亲委派和反
 * @ClassName: MyClassLoaderTest
 * @Author: 
 * @Date: 2021/8/11 0:42
 **/
public class MyClassLoaderTest {
    static class MyClassLoader extends ClassLoader {
        private String classPath;

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

        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;

        }

        protected Class<?> findClass(String name) throws ClassNotFoundException {
            try {
                byte[] data = loadByte(name);
                //defineClass将一个字节数组转为Class对象，这个字节数组是class文件读取后最终的字节 数组。
                return defineClass(name, data, 0, data.length);
            } catch (Exception e) {
                e.printStackTrace();
                throw new ClassNotFoundException();
            }
        }

        /**
         * 重写类加载方法，实现自己的加载逻辑，不委派给双亲加载
         *
         * @param name
         * @param resolve
         * @return
         * @throws ClassNotFoundException
         */
        protected Class<?> loadClass(String name, boolean resolve)
                throws ClassNotFoundException {
            synchronized (getClassLoadingLock(name)) {
                // First, check if the class has already been loaded
                Class<?> c = findLoadedClass(name);
                if (c == null) {
                    // 特定类打破 这里的判断和实现方式可以更换，思想是这样
                    if (name.startsWith("com.tuling.jvm")) {
                        c = findClass(name);
                    } else {
                        c = super.loadClass(name, false);
                    }
                }

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


    public static void main(String args[]) throws Exception {
        //初始化自定义类加载器，会先初始化父类ClassLoader，其中会把自定义类加载器的父加载 器设置为应用程序类加载器AppClassLoader
        MyClassLoader classLoader = new MyClassLoader("D:" + File.separator + "program_test");
        //D盘创建 test/com/tuling/jvm 几级目录，将User类的复制类User1.class丢入该目录
        Class clazz = classLoader.loadClass("com.tuling.jvm.User1");
        Object obj = clazz.newInstance();
        Method method = clazz.getDeclaredMethod("sout", null);
        method.invoke(obj, null);
        System.out.println(clazz.getClassLoader().getClass().getName());
    }
}

Tomcat类加载器

思考：tomcat是web容器，他需要解决什么问题？

1. 一个web容器可能需要部署两个及以上的应用程序，不同的应用程序可能会依赖同一个第三方类库的不同版本，不能要求同一个类库在同一个服务器只有一份，因此要保证每个应用程序的类库都是独立的，保证相互隔离。
2. 部署在同一个web容器中的**相同的类库相同的版本可以共享。**否则，如果服务器有10个应用程序，那么要有10分相同的类库加载进入虚拟机
3. **web容器也有自己依赖的类库，不能与应用程序的类库混淆，**基于安全考虑，应该让容器的类库和程序的类库隔离开来。
4. web容器要支持JSP的修改，jsp文件最终也要编译成class文件才能在虚拟机中运行，但是jsp修改频繁，需要热加载。

为了解决以上问题，tomcat是如何实现类加载机制的？

• commonClassLoader：tomcat最基本的类加载器，加载路径中的class可以被Tomcat容器本身以及各个WebApp访问；
• catalinaClassLoader：tomcat容器私有的类加载器，加载路径中的class对于WebApp不可见。
• sharedClassLoader：各个WebApp共享的类加载器，加载路径中的class对于所有WebApp可见，但是对于Tomcat容器不可见
• WebAppClassLoader：各个WebApp私有的类加载器，加载路径中的class只对于当前WebApp可见，比如加载war包里的相关类，每个war包应用都有自己的WebAppClassLoader，实现相互隔离，比如不同war包应用引入了不同的spring版本，这样实现就能加载给咱的spring版本。webappClassLoader加载自己的目录下的class文件，不会传递给父类加载器，打破了双亲委派机制。
  委派关系：

1. CommonClassLoader能加载的类都可以被Catalina ClassLoader和SharedClassLoader使用，从而实现了公有类库的共用，而CatalinaClassLoader和Shared ClassLoader自己能加载的类则与对方相互隔离。
2. WebAppClassLoader可以使用SharedClassLoader加载到的类，但WebAppClassLoader实例之间相互隔离。
3. JasperLoader的加载范围仅仅是这个JSP文件所编译出来的那一个.Class文件，它出现的目的就是为了被丢弃：当Web容器检测到JSP文件被修改时，会替换掉目前的JasperLoader的实例，并通过再建立一个新的Jsp类加载器来实现JSP文件的HotSwap功能。

加载类关系：

**注意：**同一个JVM内，两个相同包名和类名的类对象可以共存，因为他们的类加载器可以不一样，所以看两个类对象是否是同一个，除了看类的包名和类名是否都相同之外，还需要他们的类加载器也是同一个才能认为他们是同一个。

课后小问题

1.为什么先执行静态代码块，后执行构造方法？

答：因为在初始化的时候，会执行静态代码块的内容，而构造方法是在new对象的时候调用的。这也正证实加载并不会new一个完整对象出来。而仅仅只会有一个class对象到堆中。

2.为什么要设计双亲委派机制？

答：（1）沙箱安全机制：自己写的java.lang.String.class类不会被加载，这样便可以防止核心API库被随意篡改。
（2）避免类的重复加载：当父亲已经加载了该类时，就没有必要子Classloader在加载一次，保证被加载的类的唯一性。

3.Tomcat如果使用默认的双亲委派类加载机制行不行？ 为什么？

答：不行。这就涉及到Tomcat要解决的问题。

• 如果使用默认的类加载器机制，那么是无法加载两个相同类库的不同版本的，默认的类加载器是不管类的版本，只根据全名查找，且只有一份。
• 如何实现jsp的热加载问题，因为jsp会编译成calss文件，如果修改了jsp，但是类名并没有变，类加载器会直接取方法区中的已存在的信息，修改的并不会被加载到。所以，Tomcat的处理办法是，当你修改jsp，他会卸载掉这个jsp的类加载器，重新创建新的类加载器，加载jsp文件。

4.Tomcat打破了类加载机制，是否可以恶意定义HashMap？是否安全

答：不可以，因为上层类加载器依然没有变，根据列关系图，都会走到secureClassLoader，做安全校验。