JVM03_类加载器、双亲委派机制、沙箱安全机制

类加载器的分类

所有派生于抽象类加载器的都划分为了 自定义加载器，也就是说，除了引导类加载器，其他的都是自定义加载器，包括扩展类，系统类加载器等

Bootstrap Class Loader是C和C++实现的，其他是java实现的

默认使用的是系统类加载器

public class ClassLoaderTest {
    public static void main(String[] args) {

        //获取系统类加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2

        //获取其上层：扩展类加载器
        ClassLoader extClassLoader = systemClassLoader.getParent();
        System.out.println(extClassLoader);//sun.misc.Launcher$ExtClassLoader@1540e19d

        //获取其上层：获取不到引导类加载器
        ClassLoader bootstrapClassLoader = extClassLoader.getParent();
        System.out.println(bootstrapClassLoader);//null

        //对于用户自定义类来说：默认使用系统类加载器进行加载
        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
        System.out.println(classLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2

        //String类使用引导类加载器进行加载的。---> Java的核心类库都是使用引导类加载器进行加载的。
        ClassLoader classLoader1 = String.class.getClassLoader();
        System.out.println(classLoader1);//null


    }
}

自带加载器

System.out.println("**********启动类加载器**************");
        //获取BootstrapClassLoader能够加载的api的路径
        URL[] urLs = sun.misc.Launcher.getBootstrapClassPath().getURLs();
        for (URL element : urLs) {
            System.out.println(element.toExternalForm());
        }
        //从上面的路径中随意选择一个类,来看看他的类加载器是什么:引导类加载器
        ClassLoader classLoader = Provider.class.getClassLoader();
        System.out.println(classLoader);//null

凡是获取不到类加载器的都是引导类加载器

System.out.println("***********扩展类加载器*************");
        String extDirs = System.getProperty("java.ext.dirs");
        for (String path : extDirs.split(";")) {
            System.out.println(path);
        }

        //从上面的路径中随意选择一个类,来看看他的类加载器是什么:扩展类加载器
        ClassLoader classLoader1 = CurveDB.class.getClassLoader();
        System.out.println(classLoader1);//sun.misc.Launcher$ExtClassLoader@1540e19d

用户自定义类加载器

ClassLoader

public static void main(String[] args) {
        try {
            //1.
            ClassLoader classLoader = Class.forName("java.lang.String").getClassLoader();
            System.out.println(classLoader);
            //2.
            ClassLoader classLoader1 = Thread.currentThread().getContextClassLoader();
            System.out.println(classLoader1);

            //3.
            ClassLoader classLoader2 = ClassLoader.getSystemClassLoader().getParent();
            System.out.println(classLoader2);

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

双亲委派机制,吃苹果hhhhh

比如说new String()
String类的加载会一直向上委托，知道引导类加载器，由于java包下的类就是由引导类加载器加载，所以java.lang.String 类得到加载
一旦被加载，那么就不会再向下委托了

public class StringTest {

    public static void main(String[] args) {
        java.lang.String str = new java.lang.String();
        System.out.println("hello,atguigu.com");

        StringTest test = new StringTest();
        System.out.println(test.getClass().getClassLoader());
    }
}

对于边StringTest类的加载，首先还是向上委托，直到引导类加载器，引导类加载器不能完成加载，就会向下委托，直到系统类加载器可以加载

上边的实验，
当我定义一个java.lang.String类
由于类的加载是双亲委派机制，这时会向上委托到引导类加载器，引导类加载器中有String类，但是没有main方法， 所以会报错没有main方法

例子2
程序中需要用到SPI接口，SPI接口属于核心API，所以由双亲委派机制，到达引导类加载器进行加载，
而用到的一些接口实现类，涉及到第三方jar包，这时候因为引导类加载器不能加载，就会反向委托，由系统类加载器加载。
实际上由线程上下文类加载器来加载实现类。

优势

1、避免类的重复加载
2、保护程序安全，防止核心API被随意篡改

比如在java.lang下定义一个类，由于双亲委派机制，会向上委托来到引导类加载器，引导类加载器发现是java开头的，那么就有引导类加载器加载，但是java.lang有访问权限，直接就阻止包名自定义类，报出安全异常，这样就起到了对引导类加载器的保护，
禁止用户自定义类使用java.lang的包名。

沙箱安全机制

类加载器的引用

类的主动使用和被动使用