类加载过程

类加载过程

什么是类加载

类加载是指将Java类的字节码从外部存储到内存中，并在JVM中创建对应的class对象的过程。

类加载的作用：

1. 跨平台：Java的中间字节码被JVM加载并执行，使得程序的运行和底层平台无关。
2. 动态性：类加载机制能够动态加载和使用类，实现动态代理，插件系统和热部署等。
3. 节省内存：双亲委派保证相同类只会被加载一次，避免了重复加载，节省了内存资源。
4. 安全性：类加载的验证，解析和安全策略，降低了恶意代码的风险。

类加载的阶段

Java类加载过程可以分为以下三个阶段：

1.装载（Loading）：将类的二进制数据读入内存，并为之创建一个java.lang.Class对象。通常，这个过程会从本地文件系统、网络或其他来源中获取类的字节码文件。

2.连接（Linking）：分为验证、准备和解析三个阶段。

• 验证：确保被加载的类符合Java虚拟机规范以及安全方面的要求。
• 准备：为类的静态变量分配内存空间，并设置默认初始化值。
• 解析：将符号引用（比如类名、方法名等）转换为直接引用（即指向内存地址的指针）。

3.初始化（Initialization）：为类的静态变量赋予正确的初始值，并执行类的初始化代码块。

类加载器

Java里有如下几种类加载器

• 引导类加载器：核心类库，比如rt.jar、charsets.jar。
• 扩展类加载器：ext扩展目录的jar包。
• 应用类加载器：自己写的类、代码。
• 自定义加载器：用户自定义路径下的类包。

双亲委派模型

如下图，加载某个类的时候会先委托父类加载器寻找目标类，找不到在委托上层父类加载器寻找，如果都找不到目标类，则交给自己的路径的类加载器加载目标类。

简要的说：先找父类加载，不行再找子类加载。

为什么要双亲委派加载？

• 安全性：防止核心API类库别篡改
• 避免重复加载：当父亲已经加载了该类时，就没有必要子ClassLoader再加载一次，保证被加载类的唯一性

自定义类加载

自定义类加载器需要继承java.lang.ClassLoader类，该类有两个核心的方法：loadClass和findClass。

loadClass实现了双亲委派；findClass可以自定义类加载。

自定义类加载器步骤:

1. 继承ClassLoader
2. 重写findClass()方法
3. 调用defineClass()方法

public class MyClassLoader extends ClassLoader {

    private String classpath;

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

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        try {
            byte[] bytes = loadByte(name);
            return defineClass(name, bytes, 0, bytes.length);
        } catch (IOException e) {
            e.printStackTrace();
            throw new ClassNotFoundException();
        }
    }

    private byte[] loadByte(String className) throws IOException {
        FileInputStream fis = new FileInputStream(classpath + File.separator + className.replace(".", File.separator).concat(".class"));
        byte[] bytes = new byte[fis.available()];
        fis.read(bytes);
        fis.close();
        return bytes;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

在桌面上新建一个demo文件夹,并在文件夹内创建一个Test.java文件,内容如下:

public class Test {
    public static void say() {
        System.out.println("this is a static method!");
    }

    public void print(String s) {
        System.out.println("printing:"+s);
    }
}
1
2
3
4
5
6
7
8
9

使用javac命令编译成字节码文件,然后回到我们的开发工具测试:

    public static void main(String[] args) throws Exception {
        MyClassLoader myClassLoader = new MyClassLoader("C:\\Users\188\\Desktop\\demo");
        Class<?> aClass = myClassLoader.loadClass("Test");
        //调用的静态方法
        aClass.getDeclaredMethod("say").invoke(aClass);
        Object o = aClass.newInstance();
        Method print = aClass.getDeclaredMethod("print", String.class);
        print.invoke(o, "调用的对象方法");

        System.out.println(aClass.getClassLoader());
        System.out.println(aClass.getClassLoader().getParent());
        System.out.println(aClass.getClassLoader().getParent().getParent());
        System.out.println(aClass.getClassLoader().getParent().getParent().getParent());
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

打破双亲委派

Tomcat类加载打破双亲委派原因？

1. Web应用程序隔离性：每个部署在Tomcat上的Web应用程序都应该是相互隔离的，它们可能需要使用不同版本的库和框架。如果采用标准的双亲委派模型，所有Web应用程序都将共享Tomcat的类加载器层次结构，这可能导致类冲突和不稳定性。
2. 支持热部署：Tomcat支持热部署，这意味着您可以在不停止整个服务器的情况下重新部署单个Web应用程序。为了实现这一功能，Tomcat需要具有更灵活的类加载机制，以便能够加载和卸载Web应用程序中的类。
3. 自定义类加载器：有时，Web应用程序需要使用自定义的类加载器来加载特定于应用程序的类或库。这种情况下，打破双亲委派模型是必要的，以便应用程序可以自行管理类加载。