十五、自定义类加载器在复杂类加载情况下的运行分析

最新推荐文章于 2024-05-22 18:18:00 发布
最新推荐文章于 2024-05-22 18:18:00 发布
阅读量152 收藏
点赞数
分类专栏： jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37661639/article/details/106040641
版权

准备动作：

public class MyCat {
    public MyCat() {
        System.out.println("MyCat is loader by:" + this.getClass().getClassLoader());
    }
}


public class MySample {
    public MySample() {
        System.out.println("MySample is loader by:" + this.getClass().getClassLoader());
        new MyCat();
    }
}

package com.jvm.classloader;

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

public class MyTest17 extends ClassLoader {

    private String classLoaderName;

    private String path; // class文件路径

    private final String fileExtension = ".class";

    public MyTest17(String classLoaderName) {
        super(); // 将系统类加载器作为该类加载器的父类加载器
        this.classLoaderName = classLoaderName;
    }

    public void setPath(String path) {
        this.path = path;
    }

    public MyTest17(ClassLoader parent, String classLoaderName) {
        super(parent); // 显式指定该类加载器的父加载器
        this.classLoaderName = classLoaderName;
    }


    @Override
    public String toString() {
        return "MyTest17{" +
                "classLoaderName='" + classLoaderName + '\'' +
                '}';
    }


    @Override
    protected Class<?> findClass(String className) throws ClassNotFoundException {
        System.out.println("findClass:" + className);
        System.out.println("class loader name:" + this.classLoaderName);
        // 父类中findClass方法返回的是一个异常，所以必须要重写
        byte[] data = this.loadClassData(className);
        return this.defineClass(className, data, 0, data.length);
    }

    private byte[] loadClassData(String className) {
        InputStream is = null;
        byte[] data = null;
        ByteArrayOutputStream baos = null;
        className = className.replace(".", "/");
        try {
            is = new FileInputStream(new File(this.path + className + this.fileExtension));
            System.out.println(this.path + className + this.fileExtension);
            baos = new ByteArrayOutputStream();
            int ch;
            while (-1 != (ch = is.read())) {
                baos.write(ch);
            }
            data = baos.toByteArray();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                is.close();
                baos.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return data;
    }

public class MyTest18 {
    public static void main(String[] args) throws Exception {
        MyTest17 loader1 = new MyTest17("loader1");
        Class<?> aClass = loader1.loadClass("com.jvm.classloader.MySample");
        System.out.println("aclass: " + aClass.hashCode());
        Object o = aClass.newInstance();
    }
}

我的想法：
MySample应该是应用类加载器加载的，但是MySample里面的MyCat是哪个类加载器加载的呢？应该也是app吧。
实际结果：

aclass: 1163157884
MySample is loader by:sun.misc.Launcher$AppClassLoader@18b4aac2
MyCat is loader by:sun.misc.Launcher$AppClassLoader@18b4aac2

分析，通过反射的方式是对MySample的主动使用，会初始化，当然也会被加载，而在MySample的初始化方法中，new了一个MyCat对象，当然也会被初始化和加载。
如果注视掉反射那行Object o = aClass.newInstance();，则MyCat不会被初始化，就不一定会被加载，可以通过jvm参数来观察是否被加载。

此时的核心问题是：加载MyCat的类加载器跟加载MySample的是不是同一个类加载器？

操作：在桌面上保存这个这两个类的class文件，main方法如下：

public static void main(String[] args) throws Exception {
        MyTest17 loader1 = new MyTest17("loader1");
        loader1.setPath("C:/Users/lifeline张/Desktop/");
        Class<?> aClass = loader1.loadClass("com.jvm.classloader.MySample");
        System.out.println("aclass: " + aClass.hashCode());
        Object o = aClass.newInstance();
    }

1、删除ide中的mycat的class文件，运行代码。此时会报class文件找不到异常。两者都是由app加载的。运行结果如下：

aclass: 1163157884
MySample is loader by:sun.misc.Launcher$AppClassLoader@18b4aac2
Exception in thread "main" java.lang.NoClassDefFoundError: com/jvm/classloader/MyCat
	at com.jvm.classloader.MySample.<init>(MySample.java:6)
	at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
	at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
	at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
	at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
	at java.lang.Class.newInstance(Class.java:442)
	at com.jvm.classloader.MyTest18.main(MyTest18.java:9)
Caused by: java.lang.ClassNotFoundException: com.jvm.classloader.MyCat
	at java.net.URLClassLoader.findClass(URLClassLoader.java:382)
	at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
	at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:349)
	at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
	... 7 more

2、如果删除MySample的class文件，保留mycat的，此时正常输出，sample由loader1加载，cat由app加载。

findClass:com.jvm.classloader.MySample
class loader name:loader1
C:/Users/lifeline张/Desktop/com/jvm/classloader/MySample.class
aclass: 356573597
MySample is loader by:MyTest17{classLoaderName='loader1'}
MyCat is loader by:sun.misc.Launcher$AppClassLoader@18b4aac2

3、在2的基础上，改变MyCat的实例化方法：

public class MyCat {
    public MyCat() {
        System.out.println("MyCat is loader by:" + this.getClass().getClassLoader());
        System.out.println(MySample.class);
    }
}

输出结果为：

findClass:com.jvm.classloader.MySample
class loader name:loader1
C:/Users/lifeline张/Desktop/com/jvm/classloader/MySample.class
aclass: 356573597
MySample is loader by:MyTest17{classLoaderName='loader1'}
MyCat is loader by:sun.misc.Launcher$AppClassLoader@18b4aac2
Exception in thread "main" java.lang.NoClassDefFoundError: com/jvm/classloader/MySample
	at com.jvm.classloader.MyCat.<init>(MyCat.java:6)
	at com.jvm.classloader.MySample.<init>(MySample.java:6)
	at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
	at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
	at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
	at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
	at java.lang.Class.newInstance(Class.java:442)
	at com.jvm.classloader.MyTest18.main(MyTest18.java:9)
Caused by: java.lang.ClassNotFoundException: com.jvm.classloader.MySample
	at java.net.URLClassLoader.findClass(URLClassLoader.java:382)
	at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
	at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:349)
	at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
	... 8 more

加载是都加载完了，但是在mycat中没有找到mysqmple的Class对象。本质原因是两个类是由不同的类加载器加载，属于不同的命名空间

4、改造mycat与myxample如下：

public class MyCat {
    public MyCat() {
        System.out.println("MyCat is loader by:" + this.getClass().getClassLoader());
//        System.out.println(MySample.class);
    }
}

public class MySample {
    public MySample() {
        System.out.println("MySample is loader by:" + this.getClass().getClassLoader());
        new MyCat();
        System.out.println("from MySample" + MyCat.class);
    }
}

将两者class文件放到桌面上，删除sample的class文件，运行结果如下：

findClass:com.jvm.classloader.MySample
class loader name:loader1
C:/Users/lifeline张/Desktop/com/jvm/classloader/MySample.class
aclass: 356573597
MySample is loader by:MyTest17{classLoaderName='loader1'}
MyCat is loader by:sun.misc.Launcher$AppClassLoader@18b4aac2
from MySampleclass com.jvm.classloader.MyCat

这个跟3形成了对比，自定义类加载器命名空间里面包含了其父类的命名空间中的类。

总结：**子加载器所加载的类可以访问父加载器加载的类；而父加载器加载的类无法访问子加载器所加载的类。**核心原因就是：命名空间由该加载器及所有父加载器所加载的类组成

lifeline张
关注
专栏目录
深入理解Java的类加载机制，类加载流程及自定义类加载器
fudaihb的博客
05-30 1218
在Java程序运行过程中，类加载器扮演着至关重要的角色。它们负责将Java类从类文件或其他来源加载进JVM内存，为应用程序的顺利执行奠定基础。本文将深入解析Java的类加载流程，简述类加载机制，并教你如何创建自定义类加载器。这些知识对于深入理解Java的运行机制、优化Java应用程序的运行效率甚为关键。
自定义类加载器在复杂类加载情况下的运行分析
weixin_30510153的博客
06-03 70
在之前咱们都在研究自定义类加载器的一些东东，不过接一来的学习还会依托于之前咱们写的MyTest16这个自定义类加载器，这里先再回顾一下： public class MyTest16 extends ClassLoader { private String classLoaderName; /* 从什么地方去加载，这是个绝对路径 */ private String...
JVM学习笔记19——自定义类加载器在复杂类加载情况的运行分析
yshuoo的博客
05-08 87
public class MyCat { public MyCat(){ System.out.println("MyCat is loaded by: " + this.getClass().getClassLoader()); } } public class MySample { public MySample(){ System.out.println("MySample is loaded by: " + this.getCl.
19_自定义类加载器在复杂类加载情况下的运行分析
qq_3316359388的博客
10-24 86
没有使用的类，一般不会加载，但是不一定，只是可能性比较大。
【Tomcat源码篇】自定义类加载器那点儿事儿
波波烤鸭的博客
06-23 1270
  我们要分析清楚Tomcat中的类加载器相关的内容之前我们还是需要把JVM中的类加载器给大家理清楚。  类加载器的作用就是从文件系统或者网络中加载Class文件，至于他是否可以运行就不是ClassLoader的工作了。  JVM中支持的类加载器有两种类型，分别是 【Bootstrap ClassLoader】和 【User-Defined ClassLoader】  在Java虚拟机层面定义：所有派生于抽象类ClassLoader的类加载器都划分为自定义类加载器。可以通过源码看到对应的类加载器的继承关系E
用自定义类加载器实现Java类隔离
Hopefully Sky的博客
06-04 2972
类隔离就是让不同模块的jar包用不同的类加载器加载，要做到这一点，就需要让JVM能够使用自定义的类加载器加载我们写的类以及其关联的类。
Java 自定义类加载器
最新发布
进击的小猴
05-22 976
自定义类加载器在Java中是非常有用的，它们提供了许多高级功能和灵活性，使得开发者能够根据自己的需求定制类的加载行为。自定义类加载器允许开发者创建独立的类空间，从而隔离不同的类库。这对于某些插件式架构或模块化系统非常有用，其中每个插件或模块都有自己的类库和依赖项。通过使用不同的类加载器加载这些类库，可以避免版本冲突和依赖问题。自定义类加载器允许在不重启应用程序的情况下，重新加载和更新已加载的类。这对于需要频繁更新或替换代码的系统非常有用，如Web应用程序。
java的类加载器以及如何自定义类加载器
blueheartstone的博客
11-10 4626
类加载
深入理解Java类加载器(ClassLoader)
热门推荐
zejian的博客
06-26 24万+
【版权申明】未经博主同意，谢绝转载！（请尊重原创，博主保留追究权） http://blog.csdn.net/javazejian/article/details/73413292 出自【zejian的博客】 关联文章： 深入理解Java类型信息(Class对象)与反射机制 深入理解Java枚举类型(enum) 深入理解Java注解类型(@Annotation) 深入理解
基于自定义类加载器的在线代码执行器(线上编译执行)
跳小闹成长记
12-04 3280
本文将介绍一种基于”自定义类加载器“的在线执行方法实践。通过该方法，我们就可以在不打包，不上线，不发布，不重启的前提下，在线上直接执行某些代码逻辑，或者打印任何需要的日志。
自定义类加载器实现自定义加载
01-27
在Java编程语言中，类加载器（ClassLoader）是运行时环境...理解类加载机制并正确实现自定义加载器是提升Java应用开发能力的重要一步。在实际项目中，合理利用类加载器可以解决很多复杂问题，比如模块化、动态更新等。
Java类重新加载101对象类和类加载器Java开发Jav
11-25
在“Java类重新加载101对象类和类加载器”的主题中，开发者还需要理解类加载的生命周期、类的可见性以及类加载器的层次结构。这些都是深入学习Java动态性的重要部分，也是提升开发技能和解决问题的关键。通过深入...
类加载-自定义类加载器
Waiting_Mr_Liu的博客
10-28 685
3.2.4. 自定义类加载器ClassLoader 3.2.4.1. 自定义类加载器介绍 1）自定义类加载器的作用 a.安全。避免核心类库被随意篡改。此外，Bootstrap、Extension、Application类加载器只能加载指定路径下的类字节码，如果想要加载某些特定位置的类文件或者加载网络上的某个类文件时上述三种类加载器就不适用了，需要使用自定义的类加载器。 b.加密。java字节码很容易被反编译，通过定制ClassLoader使得字节码先加密防止别人下载后反编译，这里的ClassLoader相当
七、接口初始化规则与类加载器准备阶段和初始化阶段的重要意义分析
lifeline张的博客
05-04 2124
注：这节课的例子不能说明这节课的结论。 1、引例：判断接口有没有被初始化 public class MyTest5 { public static void main(String[] args) { System.out.println(MyChild5.b); } } interface MyParent5 { int a = 5; } interf...
一、在jvm学习之前
lifeline张的博客
05-03 386
一、jvm学习 jvm学习不像一般的应用框架。一般的框架学完之后直接就可以测试应用，但是jvm偏理论，略显枯燥。 本课程基于jdk8，主要讲解一些核心知识，忽略各个不同版本之间的细微差别。主要介绍一些常用的参数。 ...
六、编译期常量与运行期常量的区别及数组创建本质分析
lifeline张的博客
05-03 312
1、编译期常量与运行期常量 引例：判断MyParent3会不会初始化？ import java.util.UUID; public class MyTest3 { public static void main(String[] args) { System.out.println(MyParent3.str); } } class MyParent3 { ...
十七、类加载器总结及扩展类加载器要点分析
lifeline张的博客
05-11 295
1、类加载器双亲委托模型的好处 1、可以确保java核心库的类型安全：所有的java应用都至少会引用java.lang.Object类，也就是说在运行期，这个类会被加载到虚拟机中；如果这个加载过程是由自定义类加载器所完成的，那么很可能就会在jvm中存在多个版本的Object类，而且这些类之间还是不兼容的，相互不可见的（是因为命名空间）。借助于双亲委托机制，java核心类库中的加载动作都是由启动类加载器来统一完成加载工作，从而保证了java应用所使用的都是同一个版本的java核心类，他们之间是相互兼容的。
五、常量的本质含义与反编译及助记符详解
lifeline张的博客
05-03 227
1、关于加载的先后顺序 问题引入： public class MyTest1 { public static void main(String[] args) { System.out.println(MyChild1.str); } } class MyParent1 { public static String str = "hello world";...
四、类的加载、连接与初始化过程详解
lifeline张的博客
05-03 207
java类加载分为以下几个过程： java程序对类的使用方式可分为两种: 主动使用 被动使用 所有的java虚拟机实现必须在每个类或接口被java程序“首次主动使用”时才初始化他们。（1、必须是首次 2、必须是主动使用） 1、主动使用 创建类的实例 访问某个类或接口的静态变量，或者对该静态变量赋值（对于静态字段来说，只有直接定义了该字段的类才会被初始化，见例1） 调用类的静态方法 反射 初...
Java自定义类加载器实现与双亲委派模型
"这篇文档提供了一个关于如何在Java中实现自定义类加载器的代码示例，主要关注点在于理解类加载器的...理解并掌握自定义类加载器的实现有助于我们更好地控制程序的运行时行为，特别是在复杂和高度可定制化的系统中。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值