JVM类加载器

类加载器

1.启动类加载器：
​ 负责加载支持JVM运行的位于JRE的lib目录下的核心类库，比如rt.jar、charset.jar等

2.扩展类加载器：
​ 负责加载支持JVM运行的位于JRE的lib目录下的ext扩展目录中的jar包

3.应用程序类加载器：
​ 负责加载ClassPath路径下的类包，主要就是加载你自己写的那些类

4.自定义类加载器：
​ 负责加载用户自定义路径下的类包

// 示例
public class JdkClassLoaderTest {
    public static void main(String[] args) {
        System.out.println(String.class.getClassLoader());
        System.out.println(com.sun.crypto.provider.DESKeyFactory.class.getClassLoader().getClass().getName());
        System.out.println(JdkClassLoaderTest.class.getClassLoader().getClass().getName());
        System.out.println(ClassLoader.getSystemClassLoader().getClass().getName());
    }
}
// 结果
null	// 启动类加载器是C++语言实现，所以打印不出来
sun.misc.Launcher$ExtClassLoader
sun.misc.Launcher$AppClassLoader
sun.misc.Launcher$AppClassLoader

自定义一个类加载器

// 示例
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;
        }

        @Override
        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 {
        MyClassLoader classLoader = new MyClassLoader("D:\\study\\jvm\\MyClassLoader");
        Class clazz = classLoader.loadClass("com.sly.demo.jvm.classloader.User");
        Object obj = clazz.newInstance();
        Method method= clazz.getDeclaredMethod("sout", null);
        method.invoke(obj, null);
        System.out.println(clazz.getClassLoader().getClass().getName());
    }

}
// 结果
使用自定义类加载器加载
com.sly.demo.jvm.classloader.MyClassLoaderTest$MyClassLoader

双亲委派机制

1.首先，检查一下指定名称的类是否已经加载过，如果加载过了，就不需要再加载，直接返回。

2.如果此类没有加载过，那么，再判断一下是否有父加载器；如果有父加载器，则由父加载器加载（即调用parent.loadClass(name, false);）。或者是调用bootstrap类加载器来加载。

3.如果父加载器及bootstrap类加载器都没有找到指定的类，那么调用当前类加载器的findClass方法来完成类加载。

双亲委派机制说简单点就是，先找父亲加载，不行再由儿子自己加载

设计双亲委派机制原因

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

打破双亲委派
以Tomcat类加载为例：

1.一个web容器可能需要部署两个应用程序，不同的应用程序可能依赖同一个第三方类库的不同版本，不能要求同一个类库在同一个服务器只有一份，因此要保证每个应用程序的类库都是独立的，保证相互隔离。

2.部署在同一个web容器中相同的类库相同的版本可以共享。否则，如果服务器有10个应用程序，那么要有10份相同的类库加载进虚拟机。

3.web容器也有自己依赖的类库，不能与应用程序的类库混淆。基于安全考虑，应该让容器的类库和程序的类库隔离开来。

4.web容器要支持jsp的修改，我们知道，jsp 文件最终也是要编译成class文件才能在虚拟机中运行，但程序运行后修改jsp已经是司空见惯的事情， web容器需要支持 jsp 修改后不用重启。

tomcat的几个主要类加载器：

commonLoader：Tomcat最基本的类加载器，加载路径中的class可以被Tomcat容器本身以及各个Webapp访问；

catalinaLoader：Tomcat容器私有的类加载器，加载路径中的class对于Webapp不可见；

sharedLoader：各个Webapp共享的类加载器，加载路径中的class对于所有Webapp可见，但是对于Tomcat容器不可见；

WebappClassLoader：各个Webapp私有的类加载器，加载路径中的class只对当前Webapp可见；

每个webappClassLoader加载自己的目录下的class文件，不会传递给父类加载器，打破了双亲委派机制。

如何打破双亲委派
可以通过重写类加载器的loadClass()方法实现

// 示例
public class BlockDelegationClassLoaderTest {

    static class BlockDelegationClassLoader extends ClassLoader {
        private String classPath;

        public BlockDelegationClassLoader(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;
        }

        @Override
        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();
            }
        }

        @Override
        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) {
                    /*
                     * 直接执行findClass()...什么意思呢? 首先会使用自定义类加载器加载类, 不在向上委托, 直接由
                     * 自己执行
                     *
                     * jvm自带的类还是需要由引导类加载器自动加载
                     */
                    if (!name.startsWith("com.sly.demo.jvm.classloader")) {
                        c = this.getParent().loadClass(name);
                    } else {
                        c = findClass(name);
                    }
                }

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

    public static void main(String[] args) throws Exception {
        BlockDelegationClassLoader classLoader = new BlockDelegationClassLoader("D:\\study\\jvm\\MyClassLoader");
        Class clazz = classLoader.loadClass("com.sly.demo.jvm.classloader.User");
        Object obj = clazz.newInstance();
        Method method= clazz.getDeclaredMethod("sout", null);
        method.invoke(obj, null);
        System.out.println(clazz.getClassLoader().getClass().getName());
    }
}
// 结果
使用自定义类加载器加载
com.sly.demo.jvm.classloader.BlockDelegationClassLoaderTest$BlockDelegationClassLoader

查看类加载过程
添加jvm参数

-verbose:class

// 示例
@Test
public void test1() {
    new A();
    System.out.println("============load test============");
    new B();
}
// 结果 可以看到类A和类B都加载了
[Loaded com.sly.demo.jvm.classloader.A from file:/D:/workspace/idea/demo-jvm/target/classes/]
============class A init============
============load test============
[Loaded com.sly.demo.jvm.classloader.B from file:/D:/workspace/idea/demo-jvm/target/classes/]
============class B init============

// 示例
@Test
public void test2() {
    new A();
    System.out.println("============load test============");
    B b = null;
}
// 结果 可以看到类A加载了,类B没有加载因为没有使用到
[Loaded com.sly.demo.jvm.classloader.A from file:/D:/workspace/idea/demo-jvm/target/classes/]
============class A init============
============load test============
[Loaded org.junit.runner.notification.RunNotifier$7 from file:/D:/devenvironment/repository/junit/junit/4.12/junit-4.12.jar]