ClassLoader

作者: 洋葱520 | 来源:发表于2020-05-14 22:28 被阅读0次

1. 类的加载、连接、初始化

加载：查找并加载类的二进制数据
连接：
-- 验证：确保被加载类的正确性
-- 准备：为类的静态变量分配内存，并将其初始化为默认值
-- 解析：把类中的符号引用转换为直接引用
初始化：为类的静态变量赋予正确的初始化值
12.png

1.1 符号引用&直接引用

静态解析：有些符号引用在类加载阶段或者第一次使用时就会转换为直接引用，这种转换叫做静态解析
-- 静态方法
-- 父类方法
-- 构造方法
-- 私有方法（无法被重写）
-- 这四类方法称为非虚方法，他们是在类加载阶段就可以把符号引用转换为直接引用的
动态链接：一些符号引用则在每次运行期转换为直接引用，这种转换叫做动态链接，这体现为Java的多态性
感觉这个文章讲的挺好的： https://blog.csdn.net/coslay/article/details/49404823

1、invokeinterface：调用接口中的方法，实际上是在运行期决定到底调用实现该接口的那个对象的特定方法
2、invokestatic：调用静态方法
3、invokespecial：调用自己的私有方法，构造方法（<init>）以及父类的方法
4、invokevirtual：调用虚方法，运行期动态查找的过程
5、invokedynamic：动态调用方法

public class Test5 {
    // 方法重载，是一种静态行为，编译器就可以完全确定
    public void test(Grandpa grandpa) {
        System.out.println("grandpa");
    }
    public void test(Father father) {
        System.out.println("father");
    }
    public static void main(String[] args) {
        // 方法的静态分派：
        // g1 的类型是Grandpa,而实际类型(指向的类型)是Father
        // 变量的静态类型是不会发生改变的。变量的实际类型可以发生变化(多态的体现)，实际类型在运行期方可确定
        Grandpa g1 = new Father();

        Test5 test5 = new Test5();
        test5.test(g1);
    }
}
class Grandpa {
}
class Father extends Grandpa {
}



public class Test6 {

    public static void main(String[] args) {
        Fruit fruit = new Fruit();
        Fruit apple = new Apple();

        // 方法的动态分派：方法接收者
        // invokevirtual字节码指令的多态查找流程，

        // 比较方法重载(overload)和方法重写（override），可以得到这样一个结论
        // 方法重载时静态的，是编译器行为；方法重写是动态的，是运行期行为

        fruit.test();
        apple.test();

        fruit = new Apple();
        fruit.test();
    }
}

class Fruit {

    public void test() {
        System.out.println("Fruit");
    }
}

class Apple extends Fruit {

    @Override
    public void test() {
        System.out.println("Apple");
    }
}

1.1 加载

jvm规范允许类加载器在预料某个类将要被使用的时候就预先加载它，如果在预先加载的过程中遇到了.class文件缺失或者存在错误，类加载器必须在程序首次主动使用该类是，才报告错误(LinkkageError错误)
如果这个类一直没有被程序主动使用，那么类加载器就不会报告错误

1.2 验证

类的验证内容
-- 类文件的结构检查
-- 语义检查
-- 字节码验证
-- 二进制兼容性验证

1.3 准备

在准备阶段，Java虚拟机为类的静态变量分配内存，并设置默认的初始值，列如对于以下Sample类，在准备阶段，将int类型的静态变量a分配4个字节的内存空间，并且赋予默认值0，为long类型的静态变量b分配8个字节的内存空间，并且赋予默认值0


class Sample {
    private static int a = 1;// 在静态变量的声明处初始化
    public static long b;
    public static long c;
    static {
        b = 2;// 在静态代码块中进行初始化
    }
}

1.4 初始化

在初始化阶段，Java虚拟机执行类的初始化语句，为类的静态变量赋予初始值，在程序中，静态变量的初始化有两种途径，
-- 1-在静态变量的声明处进行初始化，
-- 2-在静态代码块中进行初始化，

1.5 初始化的时机

请看 《6、接口》 样例
当Java虚拟机初始化一个类的时候，要求他的所有父类都已经被初始化，但是这条规则并不适应于接口
-- 在初始化一个类时，并不会先初始化他所实现的接口
-- 在初始化一个接口时，并不会先初始化他的父接口
只有当程序首次使用特定接口的静态变量时，才会导致该接口初始化

2. 加载.class文件的方式

从本地系统中直接加载
通过网络下载.class文件
从zip，jar等归档文件中加载.class文件
从专有的数据库中提取.class文件
将Java源文件动态编译为.class

3. 主动使用（7种）

创建类的实例
访问某个类或接口的静态变量
调用类的静态方法
反射如 Class.forName("");
初始化一个类的子类
Java虚拟机启动时被标明为启动的类的类
JDK1.7开始提供动态语言支持：java.lang.invoke.MethodHandle实例解析的结果REF_getStatic, REF_putStatic, REF_invokeStatic句柄对应的类没有初始化，则初始化

4. 静态初始化

final静态常量：在编译阶段会存入到调用这个常量方法所在的类的常量池中，本质上没有直接引用定义常量的类，因此不会触发初始化
final动态常量：常量的值在编译期间不可以确定的，那么其值就不会放到调用类的常量池中，程序运行导致主动使用，初始化此类
静态常量：只有直接定义了该字段的类才会被初始化
父类：当一个类在初始化时，要求其父类先全部初始化
助记符：
-- ldc：将int、float、String类型的常量值从常量池推送至栈顶
-- bipush：将单字节(-128 ~ 127)的常量值推送至栈顶
-- sipush：将一个短整型(-32768 ~ 32767)推送至栈顶
-- iconst_1：将int类型的1推送至栈顶(iconst_1 ~ iconst_5)

-XX:+TraceClassLoading 打印类加载信息
-XX:+<option> 表示开启option选项
-XX:-<option> 表示关闭option选项
-XX:<option>=<value> 表示设置option选项值

输出结果：
2
---------------
P static init
1de47824-58c7-47ea-9f51-3f9bdf86e7c2
---------------
1

public class Test1 {

    public static void main(String[] args) {
        System.out.println(C.c1); // final常量，C P都不会初始化
        System.out.println("---------------");
        // System.out.println(C.p2); // final动态值，导致P初始化,C不会初始化
        System.out.println("---------------");
        System.out.println(C.p); // 类静态常量，导致P初始化，C也不会初始化
    }
}

class P {

    public static int          p  = 1;
    public static final int    p1 = 11;
    public static final String p2 = UUID.randomUUID().toString();
    static {
        System.out.println("P static init");
    }
}

class C extends P {

    public static int       c  = 2;
    public static final int c1 = 2;
    static {
        System.out.println("C static init");
    }
}

5. 数组

数据类型：其类型是由jvm在运行期间动态生成的，表示为 [I 这种形式，动态生成的类型，其父类型是object
数组不会导致类进行初始化
助记符
-- anewarray：表示创建一个引用类型的(类、接口、数组)数组、并将其引用值压入栈顶
-- newarray：表示创建一个原始类型(int、float、char等)的数组，并将其引用值压入栈顶

输出结果
class [Lcom.hui.classloader.P4;
class java.lang.Object
-----------------------
class [[Lcom.hui.classloader.P4;
class java.lang.Object
-----------------------
class [I
class java.lang.Object
-----------------------
null
null
-----------------------
P4 static init
com.hui.classloader.P4@7530d0a


public class Test4 {

    public static void main(String[] args) {
        P4[] p4s = new P4[1];
        System.out.println(p4s.getClass());
        System.out.println(p4s.getClass().getSuperclass());
        System.out.println("-----------------------");

        P4[][] p4s1 = new P4[1][1];
        System.out.println(p4s1.getClass());
        System.out.println(p4s1.getClass().getSuperclass());
        System.out.println("-----------------------");

        int[] ints = new int[1];
        System.out.println(ints.getClass());
        System.out.println(ints.getClass().getSuperclass());
        System.out.println("-----------------------");

        System.out.println(new String[1].getClass().getClassLoader());//根加载器
        System.out.println(ints.getClass().getClassLoader());//原生类型没有加载器
        System.out.println("-----------------------");

        System.out.println(new P4());
    }
}
class P4 {
    static {
        System.out.println("P4 static init");
    }
}

6、接口

父接口：一个接口/类初始化时，并不要求其父接口都完成初始化，只有在真正使用父接口的时候(如引用接口中定义的常量)，才会初始化接口

输出结果：
==========================================================
C5 static init
1
-----------------------
T5 static init
com.hui.classloader.T5@7530d0a
==========================================================


public class Test5 {

    public static void main(String[] args) {
        System.out.println("==========================================================");
        System.out.println(C5.c5);
        System.out.println("-----------------------");
        System.out.println(C5.t5);
        System.out.println("==========================================================");
    }
}

interface P5 {
    // 接口默认就是 public static final
    public static final T5 t5 = new T5();
}

class C5 implements P5 {
    public static int c5 = 1;
    static {
        System.out.println("C5 static init");
    }
}

class T5 {
    static {
        System.out.println("T5 static init");
    }
}

7、初始化顺序

语句是自上而下进行初始化的

输出结果：
i1=2
i2=1
--------------------
2
3

public class Test6 {

    public static void main(String[] args) {
        P6 p = P6.getInstance();
        System.out.println("--------------------");
        System.out.println(P6.i1);
        System.out.println(P6.i2);
    }

}

class P6 {

    public static int i1 = 1;
    private static P6 p6 = new P6();

    private P6(){
        i1++;
        i2++;// p6构造方法在i2初始化语句上方,所以此时i2=0
        System.out.println("i1=" + i1);
        System.out.println("i2=" + i2);
    }

    // i1常量，p6常量初始化后，对i2初始化，i2又被改为2
    public static int i2 = 2;

    public static P6 getInstance() {
        return p6;
    }
}

8. 父亲委托

20.png

9. ClassLoader.loadClass

输出：
class com.hui.classloader.CL
-----------------
CL static
class com.hui.classloader.CL

public class Test12 {
    public static void main(String[] args) throws Exception {
        ClassLoader loader = ClassLoader.getSystemClassLoader();
        // ClassLoader.loadClass不会导致类初始化
        Class<?> aClass = loader.loadClass("com.hui.classloader.CL");
        System.out.println(aClass);
        System.out.println("-----------------");
        Class<?> aClass1 = Class.forName("com.hui.classloader.CL");// 导致类初始化
        System.out.println(aClass1);
    }
}
class CL {
    static {
        System.out.println("CL static");
    }
}

10. 获取ClassLoader的途径

获取当前类的ClassLoader
-- clazz.getClassLoader()
获取当前线程的上下文ClassLoader
-- Thread.currentThread().getContextClassLoader()
获取系统的ClassLoader
-- ClassLoader.getSystemClassLoader()
获取调用者的ClassLoader
-- Reflection.getCallerClass().getClassLoader()

11. 卸载

由用户自定义的类加载器所加载的类，是可以被卸载的

12. 命名空间

每个类加载器都有自己的命名空间，命名空间由该加载器及所有父加载器所加载的类组成
在同一个命名空间中，不会出现类的完整名字相同的类
在不同的命名空间中，有可能会出现类的完整名字相同的两个类
1. 子加载器所加载的类能够访问到父加载器所加载的类
1. 父加载器所加载的类无法访问到子加载器所加载的类

13. 类加载器的双亲委托模型的好处

可以确保核心库的类型安全：借助于双亲委托模型，Java核心类库中的类加载工作都是由启动类加载器来统一完成的，从而确保了Java应用所使用的都是同一个版本的Java核心类库，他们之间是相互兼容的
可以确保Java核心类库所提供的类不会被自定义的类所替代
不同的类加载器可以为相同名称的类创建额外的命名空间，相同名称的类可以并存在Java虚拟机中，只需要用不同的类加载器来加载他们即可，不同类加载器所加载的类之间是不兼容的，这就相当于在Java虚拟机内部创建了一个又一个的相互隔离的Java类空间，这类技术在很多框架中都得到了实际应用

14. 自定义类加载器

内建于jvm中的启动类加载器会加载java.lang.ClassLoader以及其他的Java平台类，当jvm启动时，一块特殊的机器码会运行，他会加载扩展类加载器与系统类加载器
启动类加载器并不是Java类，它是特定于平台的机器指令，它负责开启整个加载过程，而其他的加载器则都是Java类，
所有的类加载器(除了启动类加载器)都被实现为Java类，不过总归要有一个组件来加载第一个类加载器，从而让整个加载过程能够顺利进行下去，加载第一个纯Java类加载器就是启动类加载器的职责

public class Test161 extends ClassLoader {

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        File file = new File("/class/" + name);// 加载class目录下的类
        byte[] data = FileUtils.readFileToByteArray(file);
        return this.defineClass(name, data, 0, data.length);
    }
}

public class Test23 {

    public static void main(String[] args) {
        System.out.println(System.getProperty("sun.boot.class.path"));
        System.out.println(System.getProperty("java.ext.dirs"));
        System.out.println(System.getProperty("java.class.path"));

        System.out.println(ClassLoader.class.getClassLoader());
        System.out.println(Launcher.class.getClassLoader());
        System.out.println("-----------------------------");
        System.out.println(System.getProperty("java.system.class.loader"));
        System.out.println(Test23.class.getClassLoader());
        // -Djava.system.class.loader=com.hui.classloader.Test16
        System.out.println("===============================");
        System.out.println(ClassLoader.getSystemClassLoader());

    }
}

15. 当前类加载器

每个类都会使用自己的类加载器(加载自身的类加载器)来去加载所依赖的类，如果ClassX引用了ClassY，那么ClassX的类加载器就会去加载ClassY

16. 线程上下文类加载器

通过 Thread.currentThread().getContextClassLoader() 和 Thread.currentThread().setContextClassLoader(); 获取和设置线程上下文类加载器
如果没有通过setContextClassLoader 进行设置的话，线程将继承父线程的上下文加载器，Java应用的运行时的初始线程上下文加载器是系统类加载器，在线程中运行的代码可以通过该类加载器来加载类和资源

16. SPI

父ClassLoader可以使用当前线程Thread.currentThread().getContextClassLoader()所指定的classLoader加载类，这就改变了父ClassLoader不能使用子ClassLoader或者其他没有直接父子关系的ClassLoader加载的类情况，即改变了父亲委托模型
线程上下文类加载器就是当前线程的Current ClassLoader
在双亲委托模型下，类加载是由下至上的，即下层的类加载器会委托上层进行加载，但是对于SPI来说，有些接口是Java核心库提供的，而Java核心库是由启动类加载器来加载的，而这些接口的实现却来自不同的jar包，Java的启动类加载器是不会加载其他来源的jar包的，这样传统的双亲委托模型就无法满足SPI的要求，而通过给当前线程设置上下文类加载器，就可以由设置的上下文类加载器来实现对于接口实现类的加载
ContextClassLoader的作用就是为了破坏Java的类加载委托机制，
当高层提供统一的接口让底层实现，同时又在高层加载（或实例化）底层类时，就必须通过线程上下文类加载器来帮助高层的ClassLoader找到并加载该类

线程上下文类加载器的一般使用模式（获取 - 使用 - 还原）

ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
try {
    Thread.currentThread().setContextClassLoader(target);
    method();
} finally {
    Thread.currentThread().setContextClassLoader(classLoader);
}



public class Test26 {
    public static void main(String[] args) {
        //   点入可以看到使用的线程上下文加载器
        ServiceLoader<Driver> loader = ServiceLoader.load(Driver.class);

        Iterator<Driver> iterator = loader.iterator();
        while (iterator.hasNext()) {
            Driver driver = iterator.next();
            System.out.println("driver:" + driver.getClass() + ", loader:" + driver.getClass().getClassLoader());
        }

        System.out.println("线程上下文加载器：" + Thread.currentThread().getContextClassLoader());
        System.out.println("ServiceLoader：" + ServiceLoader.class.getClassLoader());
    }
}
public class Test27 {
    public static void main(String[] args) throws Exception {
        // 点入可以看到，使用的调用类的加载器即Test27.class.getClassLoader()
        Class<?> aClass = Class.forName("com.mysql.jdbc.Driver");
        Connection connection = DriverManager.getConnection("", "", "");
    }
}

ClassLoader

1. 类的加载、连接、初始化

1.1 符号引用&直接引用

1.1 加载

1.2 验证

1.3 准备

1.4 初始化

1.5 初始化的时机

2. 加载.class文件的方式

3. 主动使用（7种）

4. 静态初始化

5. 数组

6、接口

7、初始化顺序

8. 父亲委托

9. ClassLoader.loadClass

10. 获取ClassLoader的途径

11. 卸载

12. 命名空间

13. 类加载器的双亲委托模型的好处

14. 自定义类加载器

15. 当前类加载器

16. 线程上下文类加载器

16. SPI

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读