JVM核心之JVM运行和类加载全过程

最新推荐文章于 2022-08-16 22:42:06 发布
原创 最新推荐文章于 2022-08-16 22:42:06 发布 · 231 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #jvm #class #class文件的加载

本文详细介绍了Java类加载的过程，包括主动引用和被动引用的区别，并通过实例展示了如何创建自定义类加载器，如FileSystemClassLoader、NetClassLoader和DecrptClassLoader。此外，还探讨了线程上下文类加载器的概念及其使用，并提到了Tomcat服务器的类加载机制和OSGI模块系统。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package JVMLoad;

public class Demo01 {

    static{
        System.out.println("Demo01类的静态初始化");
    }

    public static void main(String[] args) throws Exception{

        System.out.println("Demo01的main方法");

        // 主动引用
//        new A();
//        System.out.println(A.width);
//        Class.forName("JVMLoad.A");

        // 被动引用,不会发生类的初始化
//        System.out.println(A.MAX);
//        A[] as = new A[10];
        System.out.println(B.width);  //  通过子类的对象调用父类的静态变量时,子类不会被初始化
    }

}

class B extends A{
    static {
        System.out.println("B类的静态初始化");
    }
}

class A extends A_Father{
    public static int width = 100;
    public static final int MAX = 123;

    static {
        System.out.println("A类的静态初始化");
    }

    public A(){
        System.out.println("A类的构造方法初始化");
    }

}

class A_Father{
    static {
        System.out.println("A_Father类的静态初始化...");
    }
}

主动引用

在这里插入图片描述

被动引用

在这里插入图片描述
被动引用之通过子类对象调用父类静态变量(B extends A)
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

package JVMLoad;

public class Demo02 {

    public static void main(String[] args) {

        System.out.println(ClassLoader.getSystemClassLoader());
        System.out.println(ClassLoader.getSystemClassLoader().getParent());
        System.out.println(ClassLoader.getSystemClassLoader().getParent().getParent());

        System.out.println(System.getProperty("java.class.path"));
    }
}

Idea运行
在这里插入图片描述

在这里插入图片描述

自定义加载器

在这里插入图片描述

命令行编译带包的java原文件

在这里插入图片描述
在这里插入图片描述
FileSystemClassLoader

package JVMLoad;

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

/**
 * 自定义文件系统类加载器
 */
public class FileSystemClassLoader extends ClassLoader{

    private String rootDir;

    public FileSystemClassLoader(String rootDir){
        this.rootDir = rootDir;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        Class<?> c = findLoadedClass(name);

        // 先查询有没有加载过这个类.如果已经加载,则直接返回加载好的类.如果没有,则加载
        if (c!=null){
            return c;
        }else {

            ClassLoader parent = this.getParent();

            try {
                c = parent.loadClass(name);  // 委派给父类加载
            }catch (Exception e){

            }

            if (c!=null){
                return c;
            }else {
                // 将指定的class文件转换成byte数组
                byte[] classData = getClassData(name);
                if (classData == null){
                    throw new ClassNotFoundException();
                }else {

                    c = defineClass(name, classData, 0, classData.length);
                }
            }
        }

        return c;

    }

    private byte[] getClassData(String classname){
        String path = rootDir + "/" + classname.replace(".", "/") + ".class";

        InputStream is = null;
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try {
             is = new FileInputStream(path);

             byte[] buffer = new byte[1024];
             int temp = 0;
             while ((temp=is.read(buffer))!=-1){
                 baos.write(buffer, 0, temp);
             }

             return baos.toByteArray();

        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }finally {
            if (is!=null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (baos!=null){
                try {
                    baos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

Demo03

package JVMLoad;

/**
 * 测试自定义的FileSystemClassLoader
 */

public class Demo03 {

    public static void main(String[] args) throws Exception{

        FileSystemClassLoader loader = new FileSystemClassLoader("/home/sweetheart");
        FileSystemClassLoader loader2 = new FileSystemClassLoader("/home/sweetheart");

        Class<?> c1 = loader.loadClass("JVMLoad.Test");
        Class<?> c2 = loader.loadClass("JVMLoad.Test");
        Class<?> c3 = loader2.loadClass("JVMLoad.Test");

        Class<?> c4 = loader2.loadClass("java.lang.String");
        Class<?> c5 = loader2.loadClass("JVMLoad.Demo01");

        System.out.println(c1.hashCode());
        System.out.println(c2.hashCode());
        System.out.println(c3.hashCode());  // 用一个类,被不同的加载器加载,JVM认为也是不相同的类

        System.out.println(c3.getClassLoader());  // 自定义加载器
        System.out.println(c4.getClassLoader());  // 引导类加载器
        System.out.println(c5.getClassLoader());  // 系统默认的类加载器
    }
}

在这里插入图片描述
网络类加载器

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;

/**
 * 网络类加载器
 */
public class NetClassLoader extends ClassLoader{

    private String rootUrl;

    public NetClassLoader(String rootDir){
        this.rootUrl = rootDir;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        Class<?> c = findLoadedClass(name);

        // 先查询有没有加载过这个类.如果已经加载,则直接返回加载好的类.如果没有,则加载
        if (c!=null){
            return c;
        }else {

            ClassLoader parent = this.getParent();

            try {
                c = parent.loadClass(name);  // 委派给父类加载
            }catch (Exception e){

            }

            if (c!=null){
                return c;
            }else {
                // 将指定的class文件转换成byte数组
                byte[] classData = getClassData(name);
                if (classData == null){
                    throw new ClassNotFoundException();
                }else {

                    c = defineClass(name, classData, 0, classData.length);
                }
            }
        }

        return c;

    }

    private byte[] getClassData(String classname){
        String path = rootUrl + "/" + classname.replace(".", "/") + ".class";

        InputStream is = null;
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try {
            URL url = new URL(path);
            is = url.openStream();

            byte[] buffer = new byte[1024];
            int temp = 0;
            while ((temp=is.read(buffer))!=-1){
                baos.write(buffer, 0, temp);
            }

            return baos.toByteArray();

        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }finally {
            if (is!=null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (baos!=null){
                try {
                    baos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

加密解密类加载器

加密工具类

package JVMLoad;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 加密工具类
 */
public class EncrptUtil {

    public static void encrpt(String src, String dest){

        FileInputStream fis = null;
        FileOutputStream fos = null;

        try {
            fis = new FileInputStream(src);
            fos = new FileOutputStream(dest);

            int temp = -1;
            while ((temp=fis.read())!=-1){
                fos.write(temp^0xff);  // 取反操作
            }


        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if (fis!=null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (fos!=null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

加载文件系统中加密后的class字节码的类加载器

package JVMLoad;

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

/**
 * 加载文件系统中加密后的class字节码的类加载器
 */
public class DecrptClassLoader extends ClassLoader{

    private String rootDir;

    public DecrptClassLoader(String rootDir){
        this.rootDir = rootDir;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        Class<?> c = findLoadedClass(name);

        // 先查询有没有加载过这个类.如果已经加载,则直接返回加载好的类.如果没有,则加载
        if (c!=null){
            return c;
        }else {

            ClassLoader parent = this.getParent();

            try {
                c = parent.loadClass(name);  // 委派给父类加载
            }catch (Exception e){

            }

            if (c!=null){
                return c;
            }else {
                // 将指定的class文件转换成byte数组
                byte[] classData = getClassData(name);
                if (classData == null){
                    throw new ClassNotFoundException();
                }else {

                    c = defineClass(name, classData, 0, classData.length);
                }
            }
        }

        return c;

    }

    private byte[] getClassData(String classname){
        String path = rootDir + "/" + classname.replace(".", "/") + ".class";

        InputStream is = null;
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try {
             is = new FileInputStream(path);

            int temp = -1;
            while ((temp=is.read())!=-1){
                baos.write(temp^0xff);  // 取反操作
            }
             return baos.toByteArray();

        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }finally {
            if (is!=null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (baos!=null){
                try {
                    baos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

Demo04

package JVMLoad;

/**
 * 测试简单加密解密(取反操作)
 */
public class Demo04 {

    public static void main(String[] args) throws Exception{
        int a = 3;  // 00000011
        System.out.println(Integer.toBinaryString(a^0xff));

//        EncrptUtil.encrpt("/home/sweetheart/JVMLoad/Test.class", "./src/JVMLoad/Test.class");

//        FileSystemClassLoader loader = new FileSystemClassLoader("./src");
//
//        Class<?> c = loader.loadClass("JVMLoad.Test");
//        System.out.println(c);

        DecrptClassLoader loader = new DecrptClassLoader("./src");

        Class<?> c = loader.loadClass("JVMLoad.Test");
        System.out.println(c);

    }
}

在这里插入图片描述

当用之前普通的类加载器加载时,出现ClassFormatError错误
在这里插入图片描述
利用对应的解密类加载器

在这里插入图片描述

线程上下文类加载器

在这里插入图片描述

package JVMLoad;

public class Demo05 {

    public static void main(String[] args) throws Exception{

        ClassLoader loader = Demo05.class.getClassLoader();
        System.out.println(loader);

        ClassLoader loader2 = Thread.currentThread().getContextClassLoader();
        System.out.println(loader2);

        Thread.currentThread().setContextClassLoader(new FileSystemClassLoader("./"));
        System.out.println(Thread.currentThread().getContextClassLoader());

        Class<Demo01> c = (Class<Demo01>) Thread.currentThread().getContextClassLoader().loadClass("JVMLoad.Demo01");
        System.out.println(c);
        System.out.println(c.getClassLoader());
    }
}

在这里插入图片描述

Tomcat服务器的类加载机制

在这里插入图片描述

OSGI

在这里插入图片描述
在这里插入图片描述

【深入理解JVM 一】一个Java程序的执行流程
MaoLin Tian's Blog
03-01 2247
本篇是《深入理解JVM》系列博客的第一篇，旨在全局把控，先对整体流程有个认识，然后再分阶段详解。程序从编写到执行整体可以划分为以下几个步骤：编辑源码->编译生成class文件、(加载class文件、运行class字节码文件)，其中后两个步骤都是在jvm虚拟机上执行的，整体的执行流程如下： 编辑生成源代码 编辑源代码是经历的第一个环节，编辑源代码，就是我们在任何一个工具上编写源代码，可以是记事本，也可以是IDE，这部分相当于我们在IDEA上 新建一个.java的Class 然后写内容，这里我们创建几个
JVM中类加载的过程详解
程序员资料站
01-13 655
类从被加载到虚拟机内存中开始，到卸载出内存，它的整个生命周期包括：加载（Loading）、验证（Verification）、准备（Preparation）、解析（Resolution）、初始化（Initiallization）、使用（Using）和卸载（Unloading）这7个阶段。其中验证、准备、解析3个部分统称为连接（Linking）
JVM运行、类加载的全过程
weixin_34087307的博客
04-10 65
JVM运行、类加载的全过程 类加载机制：JVM把CLASS文件加载到内存，并对数据进行校验、解析和初始化，最终形成JVM可以直接使用的Java文件。 加载：把class文件字节码加载到内存中，并且将这些静态数据转换成方法区中的运行时数据结构，并且在堆中创建一个对象，作为调用这些方法和属性的入口。这个过程需要类加载器。 链接：将Java...
01-JVM类的加载到运行全流程
zy97vip的博客
05-31 141
01-JVM类的加载到运行全流程自定义JAVA类JVM类的加载到运行流程图JVM类的加载到运行流程说明 你好，这篇文章通过上帝的视角带你去看JVM类的加载到运行的整个流程。 自定义JAVA类 /** * @Author ：ying.sir * @Date ：Created in 2021/5/31 15:32 * @Description ：自定义类 */ public class ObjectTest { public static final int initValue = 10;
JVM类加载过程
蠢蠢欲动的猫
03-03 235
JVM类加载详细过程
JVM核心教程之JVM运行与类加载全过程详解
08-27
《JVM核心教程之JVM运行与类加载全过程详解》 在Java开发中，了解JVM（Java Virtual Machine）的工作原理对于优化程序性能至关重要。本文将深入探讨JVM如何加载和运行类，揭示这一过程的详细步骤。 首先，类加载器...
JVM之类加载运行全过程
斯巴达人的博客
06-12 1340
JVM之类加载运行全过程 public class ClassLoading{ public static final int data = 666; public static User user = new User(); public int handle() { int a = 1; int b = 2; int c = a + b; return c; } public static void main(String[] args) { Math math = new Math(); math.c
JVM类加载过程.pptx
05-07
JVM的类加载机制是JVM的核心机制之一，它把描述类的数据从class文件加载到内存，并对数据进行校验、转换解析和初识化，形成可以被虚拟机直接使用的Java类型。 Java代码执行流程是JVM的核心流程之一，它首先通过...
深入理解JVM：类加载、运行与初始化全过程
本文档深入探讨了JVM运行与类加载的全过程，从Java程序运行的基本流程出发，指出类加载在Java语言中的重要性，特别是它带来的灵活性，如面向接口编程的动态实现和Android插件化等场景。理解类加载过程对于连接JVM...
JVM运行数据区加载.class文件及new一个对象的过程
h1458280799的博客
01-14 324
 文章转载自：https://blog.csdn.net/qq_28666081/article/details/85346470         以下我们将会结合JVM运行时数据区+(加载、验证、准备、解析、初始化、使用、卸载) 来讲解加载过程，此过程不涉及到JVM运行时数据区外的内存空间。更多相关内存请看后续文章。 1 先概述下JVM运行时数据区： 2 再说说[加载、验证、准备、解析、初始...
Java程序执行流程（JVM）
消极的人永远是对的，积极的人选择勇往直前
08-03 1039
首先了解JVM架构：https://mp.csdn.net/console/editor/html/107181269
深入理解JVM(九)——类加载的过程
大闲人柴毛毛
04-26 9469
通过之前的介绍可知，类加载过程共有5个步骤，分别是：加载、验证、准备、解析、初始化。其中，验证、准备、解析称为连接。下面详细介绍这5个过程JVM所做的工作。加载注意：“加载”是“类加载”过程的第一步，千万不要混淆。1. 加载的过程在加载过程中，JVM主要做3件事情： 通过一个类的全限定名来获取这个类的二进制字节流，即class文件： 在程序运行过程中，当要访问一个类时，若发现这个类尚未被加载，并满
JVM 系列(二) --- JVM 类加载的基本流程
Fug_Lee的博客
05-23 2539
JVM 的基本流程
java---JVM类加载过程详解
m0_58196614的博客
08-16 841
程序主动使用某个类时，如果该类还未被加载到内存中，系统会通过加载、连接(验证、准备、解析)、初始化三个步骤对类进行加载也叫初始化。这里注意，解析这个过程不一定是顺序进行的，也可能在初始化阶段之后，这个是为了支持Java的运行时绑定。...............
笔记 - JVM简介及执行流程
zjf1165的专栏
10-09 3868
时隔一年，兜兜转转又转回Android开发，在开发过程中，对JAVA虚拟机内容有点疑惑，于是翻看了很多博客，根据自己的理解在此记录总结下，以便后续复习，非常感谢各位博主的辛勤付出。 JVM简介 JVM即java虚拟机，对于虚拟机有过了解的同学都知道虚拟机实际上是通过虚拟计算机硬件来运行一个系统的，实现相应的功能。jvm既然被称为java虚拟机，那么它必然也有相应的结构来完成java代码的执行（详见...
类在JVM中的执行过程
younger的博客
04-28 3518
在java源文件（.java）被编译成字节码（.class）文件后，启用命令java Demo，就会调用Demo类的main（）方法来启动java虚拟机（jvm）。即JVM加载到内存后，就调用Demo的main（）方法开始它的工作。JVM将按特定顺序做三件事：加载、链接和初始化。
Java虚拟机（JVM）之类的加载过程详解
qq_40837310的博客
06-30 2463
java程序在对某个类进行引用、使用时，就会开始对该类进行加载，比如直接使用类加载器进行显式加载、创建该类的对象、使用该类的类变量等情况。类的加载是通过java虚拟机的类加载子系统完成的。类的加载主要分为三个阶段。 类的加载步骤 类加载子系统负责从文件系统或者网络上加载class文件，class文件在文件开头会有特定的文件标志。 ClassLoader只负责class文件的加载，至于他是否可以运行，则有执行引擎决定。 加载的类信息存放在一块称为方法区的内存空间中，除了类信息外，方法区还会存放运行时常量池
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值