类加载过程 JAVA

最新推荐文章于 2024-05-21 22:13:42 发布
最新推荐文章于 2024-05-21 22:13:42 发布
阅读量911 收藏 21
点赞数 17
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/darkpumpkin/article/details/135747913
版权

1. 类加载的过程

在这里插入图片描述

加载：将字节码文件通过IO流读取到JVM的方法区，并同时在堆中生成Class对像。

验证：校验字节码文件的正确性。

准备：为类的静态变量分配内存，并初始化为默认值；对于final static修饰的变量，在编译时就已经分配好内存了。

解析：将类中的符号引用转换为直接引用。

初始化：对类的静态变量初始化为指定的值，执行静态代码。

2. 类加载器的分类

主要分为两类:

1. JVM内置的类加载器,有Bootstrap加载器、ExtClassLoader加载器和AppClassLoader加载器 三种,分别负责加载不同目录下的.class文件

2. 用户自定义的类加载器,负责的加载目录自己决定。
12345

2.1 引导类加载器 Bootstrap

引导类加载器属于JVM的一部分，由C++代码实现。

引导类加载器负责加载<JAVA_HOME\>\jre\lib路径下的核心类库，由于安全考虑只加载 包名 java、javax、sun开头的类。

package classloader.bootstrap;

import sun.misc.Launcher;

import java.net.URL;

public class Demo01 {
    public static void main(String[] args) {
        //Bootstrap 引导类加载器
        //打印为null,是因为Bootstrap是C++实现的。
        ClassLoader classLoader = Object.class.getClassLoader();
        System.out.println(classLoader);

        //查看引导类加载器会加载那些jar包
        URL[] urLs = Launcher.getBootstrapClassPath().getURLs();
        for (URL urL : urLs) {
            System.out.println(urL);
        }
    }
}
1234567891011121314151617181920

2.2 扩展类加载器 ExtClassLoader

全类名:sum.misc.Launch$ExtClassLoader，Java语言实现。

扩展类加载器的父加载器是Bootstrap启动类加载器 (注:不是继承关系)

扩展类加载器负责加载<JAVA_HOME>\jre\lib\ext目录下的类库。

加载的jar包
在这里插入图片描述
获取扩展类加载器
在这里插入图片描述
注: JDK9是jdk.internal.loader.ClassLoaders$PlatformClassLoader类

2.3 系统类加载器 AppClassLoader

全类名: sun.misc.Launcher$AppClassLoader

系统类加载器的父加载器是ExtClassLoader扩展类加载器（注: 不是继承关系）。

系统类加载器负责加载 classpath环境变量所指定的类库，是用户自定义类的默认类加载器。

获取系统类加载器
在这里插入图片描述
注: JDK9是jdk.internal.loader.ClassLoaders$AppClassLoader类

2.4 三者之间的关系

AppClassLoader的父加载器是ExtClassLoader
ExtClassLoader的父加载器是Bootstrap
Bootstrap是根加载器

三者之间是没有继承关系的。
12345
AppClassLoader和ExtClassLoader都实现了抽象类ClassLoader。

抽象类ClassLoader有一个字段parent, AppClassLoader和ExtClassLoader通过设置该字段引用,指定父加载器。（是组合关系）

AppClassLoader 的parent指向 ExtClassLoader
ExtClassLoader 的parent指向 null,(null的原因是因为Bootstrap是C++实现的,通过代码中逻辑判断来转向Bootstrap)

// The parent class loader for delegation
// Note: VM hardcoded the offset of this field, thus all new fields
// must be added *after* it.
private final ClassLoader parent;
1234567891011

2.5 自定义类加载器

自定义类加载器是为了加载在jvm三个加载器负责的目录范围之外的类

package com;

import java.io.*;

/**
 * @Date: 2022/5/2 10:09
 * @author: ZHX
 * @Description: 自定义类加载器
 */
public class MyClassLoader extends ClassLoader {

    private String classPath;

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

    //parent: 指定父加载器, AppClassLoader/ExtClassLoader/Bootstrap
    public MyClassLoader(ClassLoader parent, String classPath) {
        super(parent);
        this.classPath = classPath;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        //要求返回的是你要加载的字节码文件的Class对象.

        //这里都是我们说了算的。
        //步骤：
        //1. 从本地或网络某处读一个输入流到内存中 .
        //2. 将流内容字节数组 封装成Class对象 (直接调ClassLoader的defineClass方法，JVM会帮我们按照.class文件格式创建好的。)

        //1.
        //处理得到完整路径
        String path = this.classPath + name.replace(".", File.separator) + ".class";

        //2.读取到内存
        try (FileInputStream fis = new FileInputStream(path); ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
            byte[] buffer = new byte[1024];
            int len = 0;
            while ((len = fis.read(buffer)) != -1) {
                //用ByteArrayOutputStream暂存一下。
                baos.write(buffer, 0, len);
            }
            byte[] allByte = baos.toByteArray();
            //将字节数组生成Class对象
            return super.defineClass(name, allByte, 0, allByte.length);
        } catch (IOException e) {
            throw new ClassNotFoundException(name + "加载失败");
        }
    }

	//测试下
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        //使用自己的类加载器，加载D:\\ + com.ali.Hello
        MyClassLoader myClassLoader = new MyClassLoader("d:\\");  //
        //加载 全限定名类
        Class<?> clazz = myClassLoader.loadClass("com.ali.Hello");

        clazz.newInstance();

        System.out.println(clazz.getClassLoader()); //out: 使用的类加载器 MyClassLoader@481248
    }
}
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364

加载jar包的写法:

从jar包加载类:String path = "jar:file:\\" + classPath + "!/" + name.replace(".", File.separator) + ".class";
1

2.6 注：谁来准备类加载器呢?

AppClassLoader和ExtClassLoader是Launcher的静态内部类，在程序启动时JVM会创建Launcher对象，Launcher构造器会同时会创建扩展类加载器和应用类加载器。

Launcher类
在AAAA述

3. 双亲委派机制

双亲委派机制就是: 每个类加载器都很懒，加载类时都先让父加载器去尝试加载，父加载器加载不了时自己才去加载。

在这里插入图片描述
图片来源 : https://www.bilibili.com/video/BV16T4y1P79h?p=2

例如: 加载自定义类Demo.class的流程

  1. 首先使用AppClassLoader类加载器尝试加载，AppClassLoader加载器会先检查它的缓存，查看该类是否已经被加载，有则不加载，没有则向上交给ExtClassLoader加载器。
  2. ExtClassLoader加载器同样会先检查它的缓存，查看该类是否已经被加载，有则不加载，没有则向上交给Bootstrap加载器。
  3. Bootstrap加载器同样会先检查它的缓存，查看该类是否已经被加载。有则不加载，没有则尝试从它负责的目录中加载，
  4. Bootstrap加载器加载失败(不在它负责的目录范围)则向下交给ExtClassLoader加载器。
  5. ExtClassLoader加载器会从它负责的目录中尝试加载，加载失败则向下交给AppClassLoader加载器
  6. AppClassLoader加载器从它负责的classpath尝试加载，加载完成。

双亲委派机制的好处:

  1. 避免类的重复加载：当父加载器已经加载该类时，就没有必要子加载器再加载一遍，保证被加载类的唯一性。
  2. 同时Java有沙箱安全机制：自定义类的包名以 java.开头被禁止， 防止核心API被篡改，判断逻辑在defineClass方法中。在这里插入图片描述

打破双亲委派机制

双亲委派机制的实现其实就是在loadClass方法中实现的。
直接调用findClass方法就可以跳过双亲委派机制,这样就可以直接加载,而不用向上委托了。
12
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        //使用上面自定义的类加载器。
        MyClassLoader myClassLoader1 = new MyClassLoader("d:\\");

        //find方法调用，加载 全限定名类
        Class<?> clazz1 = myClassLoader1.findClass("com.ali.Hello");
        
		System.out.println(clazz1.hashCode()); //out: 26508395

        System.out.println(clazz1.getClassLoader()); //out: 使用的类加载器 MyClassLoader@481248
}
1234567891011
//如果要想一个类加载两次，就需要创建两个类加载器。（因为判断缓存中该字节码文件是否已经已经被加载是在defineClass方法中,而该方法为final我们没法改写.）
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
    //使用上面自定义的类加载器。
    MyClassLoader myClassLoader1 = new MyClassLoader("d:\\");
    MyClassLoader myClassLoader2 = new MyClassLoader("d:\\");

    //加载 全限定名类
    Class<?> clazz1 = myClassLoader1.findClass("com.ali.Hello");
    Class<?> clazz2 = myClassLoader2.findClass("com.ali.Hello");

    System.out.println(clazz1.hashCode());//out: 22913620
    System.out.println(clazz2.hashCode());//out: 29768086

    System.out.println(clazz1.getClassLoader()); //out: 使用的类加载器 MyClassLoader@481248
    System.out.println(clazz2.getClassLoader()); //out: 使用的类加载器 MyClassLoader@1947c6b
}
12345678910111213141516

4. ClassLoader抽象类

所有的类加载器(除了Bootstrap)都要继承ClassLoader抽象类。

主要方法

方法名作用
public Class<?> loadClass(String name)双亲委派机制的实现
protected Class<?> findClass(String name)读取字节码文件到内存并调用defindClass方法生成Class对象
protected final Class<?> defineClass(String name, byte[] b, int off, int len)先判断是否加载过，然后将字节数组解析成Class对象
protected final void resolveClass(Class<?> c)连接指定的类

loadClass()方法源码

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) { //没有
	        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();
	            //真正将字节码文件加载到内存。
	            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;
	}
}
1234567891011121314151617181920212223242526272829303132333435363738

5. URLClassLoader类

java.net.URLClassLoader继承了ClassLoader类. 拓展了功能，能够从网络或本地加载类。默认的父加载器是AppClassLoader系统类加载器。
在这里插入图片描述
加载磁盘上的类

package classloader.urlclassloader;

/**
 * @Date: 2022/4/30 9:35
 * @author: ZHX
 * @Description:
 */
public class LoadLocal {

    public LoadLocal(){
        System.out.println("本地的字节码文件");
    }

}
1234567891011121314
package classloader.urlclassloader;

import java.io.File;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;

/**
 * @Date: 2022/4/30 0:51
 * @author: ZHX
 * @Description:
 */
public class Demo {

    public static void main(String[] args) throws MalformedURLException, ClassNotFoundException, InstantiationException, IllegalAccessException {

        File file = new File("D:\\Project\\java-advence\\day16-classloader\\src\\main\\java\\");
        URL url = file.toURI().toURL();

        URLClassLoader urlClassLoader = new URLClassLoader(new URL[]{url});

        Class<?> clazz = urlClassLoader.loadClass("classloader.urlclassloader.LoadLocal");
        clazz.newInstance(); //out: 本地的字节码文件
    }
}

1234567891011121314151617181920212223242526

加载网络上的类

package classloader.urlclassloader;

/**
 * @Date: 2022/4/30 9:35
 * @author: ZHX
 * @Description:
 */
public class LoadURL {

    public LoadURL(){
        System.out.println("网络上的字节码文件");
    }
}
12345678910111213
package classloader.urlclassloader;

import java.io.File;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;

/**
 * @Date: 2022/4/30 0:51
 * @author: ZHX
 * @Description:
 */
public class Demo {

    public static void main(String[] args) throws MalformedURLException, ClassNotFoundException, InstantiationException, IllegalAccessException {
    	//放到了tomcat服务器上。
        URL url = new URL("http://localhost/");

        URLClassLoader urlClassLoader = new URLClassLoader(new URL[]{url});

        Class<?> clazz = urlClassLoader.loadClass("classloader.urlclassloader.LoadURL");

        clazz.newInstance(); //out: 网络上的字节码文件
    }
}
长空空空
关注
  • 17
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java类加载过程详解.doc
10-27
java类加载过程详解
Java 类的加载流程
Android 领域开发程序员，希望通过写博客的方式不断的总结提升自己，大家共同进步哦！
01-30 1241
指的是将类的.class 文件中的二进制数据读入到内存中，将其放在运行时数据区的方法区内，然后在堆区创建一个 java.lang.Class 对象，用来封装类在方法区内的数据结构。类从被加载到虚拟机内存中开始，到卸载出内存为止，它的整个生命周期包括：、使用和卸载七个阶段。
Java类加载过程详解
chris3will的博客
04-19 3653
首先我们应明确在Java中类的生命周期是什么，引用一张图像进行说明使用（Using）卸载（Unloading）
java类的加载过程
伤何
05-16 6243
java类的加载过程
Java的类加载过程
Never say never
11-25 1125
其中的可以理解为阶段。类不单单只会在创建对象的时候被加载，一个类可能会有静态/非静态变量，静态/成员方法等等，再操作这些类里的“东西”的时候也会被加载，先简单介绍一下：1）使用new关键字来实例化对象；2）读取或者设置一个类的静态字段；3）调用一个类的静态方法；4）对类进行反射调用（java.lang.reflect），如果类没有被加载，就要先进行加载；5）初始化一个类的时候，如果其父类还没被初始化，则要先对这个父类进行初始化；
Java类的加载过程
w1lgy的博客
08-20 8652
应用程序根据自身需要自定义的ClassLoader，如Tomcat、Jboss都会根据j2ee规范实现ClassLoader。
Java类加载机制实现流程及原理详解
08-19
主要介绍了Java类加载机制实现流程及原理详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java类加载基本过程详细介绍
08-31
主要介绍了Java类加载基本过程详细介绍的相关资料,需要的朋友可以参考下
深入理解Java 类加载全过程
08-31
主要介绍了深入理解Java 类加载全过程的相关资料,需要的朋友可以参考下
java类的加载过程以及类加载器的分析
08-27
给大家详细讲述了java类的加载过程以及类加载器的相关知识点内容，有需要的朋友可以学习下。
jar包增量更新分析
junlaiyan的专栏
05-16 276
借助jdeps分析出jar包的增量文件
Spring-Cloud 微服务
weixin_65127444的博客
05-15 907
先来思考一个问题*通过上一章的操作，我们已经可以实现微服务之间的调用。但是我们把服务提供者的网络地址（ip，端口）等硬编码到了代码中，这种做法存在许多问题：1.一旦服务提供者地址变化，就需要手工修改代码2. 一旦是多个服务提供者，无法实现负载均衡功能3.一旦服务变得越来越多，人工维护调用关系困难那么应该怎么解决呢，这时候就需要通过注册中心动态的实现。
java实现拼图小游戏
monkey108的博客
05-16 638
本文主要提供用java实现的拼图小游戏源代码。
命令执行漏洞（二）
XLbb的博客
05-15 911
POST方法，S2-045-bypass-2漏洞存在！,程序更改为S2-045-bypass-2漏洞测试模式, 响应码: 200。POST方法，S2-046-bypass漏洞存在！POST方法，S2-045-bypass漏洞存在！POST方法，S2-046-1漏洞存在！POST方法，S2-046-2漏洞存在！POST方法，S2-046-3漏洞存在！POST方法，S2-045-1漏洞存在！POST方法，S2-045-3漏洞存在！POST方法，S2-045-2漏洞存在！POST方法，S2-045-4漏洞存在！
java数据结构与算法(验证二叉搜索树)
磐门的博客
05-17 251
节点返回空为ture,节点的值不在对应数据大小范围内返回false。将验证二叉搜索树计算同样可以转换为相同子问题，所以比较适合用递归。node为root的左节点时，max更新为root.val。node为root的右节点时，min更新为root.val。
SpringMVC基础
Java小白的博客 致力分享每一天学到的知识
05-15 1306
介绍了有关SpringMVC的基础内容
C++ 11
qq_65112813的博客
05-17 657
对于类类型，如果定义了接受。
Kubernetes 审计日志采集与分析最佳实践
观测云的博客
05-17 1026
​Kubernetes 在 1.7 版本中发布了审计（Audit）日志功能，通过审计日志，我们能够非常清晰的知道 K8S 集群到底发生了什么事情。
Spring6基础笔记
最新发布
质胜文则野，文胜质则史。文质彬彬，然后君子。
05-21 542
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。时至今日，Spring 俨然
java 类加载过程
05-26
Java的类加载过程可以分为以下三个步骤： 1. 加载：当程序要使用一个类时，JVM会先检查该类是否已经被加载到内存中，如果没有，则使用ClassLoader将该类的class文件加载到内存中。ClassLoader是Java中的一个重要概念，它负责将class文件加载到JVM中，Java中有三种ClassLoader：Bootstrap ClassLoader、Extension ClassLoader和App ClassLoader。 2. 链接：类加载完成后，JVM会对类进行链接处理，分为三个阶段： （1）验证：验证class文件是否符合JVM规范，例如class文件格式、语法、依赖等。 （2）准备：为类变量（static修饰的变量）分配内存，并设置默认初始值。 （3）解析：将符号引用转换为直接引用，例如将类名转换为类的实例。 3. 初始化：类加载和链接都完成后，JVM会对类进行初始化，即执行类的构造方法。在初始化阶段，JVM会按照静态代码块和静态变量的顺序依次执行。 以上就是Java类加载过程的三个步骤。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值