类加载器

最新推荐文章于 2024-02-19 11:50:47 发布
最新推荐文章于 2024-02-19 11:50:47 发布
阅读量119 收藏
点赞数
分类专栏： java
自定义类加载器的流程：
                                0：继承：java.lang.ClassLoader
                                1.检查请求的类型是否已经被这个类装载器装载到命名空间中了，如果已经装载，直接返回。
                                2.委派类加载请求给父类加载器，如果父类加载器能够完成，则返回父类加载器加载的Class实例。
                                3.调用本类加载器的findClass()方法，试图获取对应的字节码，如果获取的到，则调用defineClass()导入类型到方法区，如果获取不到对应的字节码或者其它原因失败，返回异常给loadClass() ，loadClass转抛异常，终止加载过程。
    注：被两个类加载器加载的同一个类，JVM不认为是相同的类。
类加载器的层次结构：引导类加载器，扩展类加载器，应用程序类加载器，自定义类加载器（开发人员可以继承java.lang.ClassLoader类的方式实现自己的类加载器，以满足特殊需求）
类加载器的代理模式：代理模式是指交给其它的加载器来加载指定的类，双亲委托机制是加载器代理模式的一种。就是某个特定的类加载器在接到加载类的请求时，首先将加载任务委托给父类加载器，依次追溯，直到最高的爷爷辈的，如果父类加载器可以完成加载任务，就返回。只有父类加载器无法完成类加载任务时，才自己去加载。双亲委托机制保证了java核心库的安全。类加载器除了用于加载类，也是安全的最基本保障。
1. package com.bjsxt.test;
2. import java.io.ByteArrayOutputStream;
3. import java.io.FileInputStream;
4. import java.io.IOException;
5. import java.io.InputStream;
6. /**
7. * 自定义文件系统类加载器
8. * @author 尚学堂高淇 www.sxt.cn
9. *
10. */
11. public class FileSystemClassLoader extends ClassLoader {
12. //com.bjsxt.test.User --> d:/myjava/ com/bjsxt/test/User.class
13. private String rootDir;
14. public FileSystemClassLoader(String rootDir){
15. this.rootDir = rootDir;
16. }
17. @Override
18. protected Class<?> findClass(String name) throws ClassNotFoundException {
19. Class<?> c = findLoadedClass(name);
20. //应该要先查询有没有加载过这个类。如果已经加载，则直接返回加载好的类。如果没有，则加载新的类。
21. if(c!=null){
22. return c;
23. }else{
24. ClassLoader parent = this.getParent();
25. try {
26. c = parent.loadClass(name); //委派给父类加载
27. } catch (Exception e) {
28. // e.printStackTrace();
29. }
30. if(c!=null){
31. return c;
32. }else{
33. byte[] classData = getClassData(name);
34. if(classData==null){
35. throw new ClassNotFoundException();
36. }else{
37. c = defineClass(name, classData, 0,classData.length);
38. }
39. }
40. }
41. return c;
42. }
43. private byte[] getClassData(String classname){ //com.bjsxt.test.User d:/myjava/ com/bjsxt/test/User.class
44. String path = rootDir +"/"+ classname.replace('.', '/')+".class";
45. // IOUtils,可以使用它将流中的数据转成字节数组
46. InputStream is = null;
47. ByteArrayOutputStream baos = new ByteArrayOutputStream();
48. try{
49. is = new FileInputStream(path);
50. byte[] buffer = new byte[1024];
51. int temp=0;
52. while((temp=is.read(buffer))!=-1){
53. baos.write(buffer, 0, temp);
54. }
55. return baos.toByteArray();
56. }catch(Exception e){
57. e.printStackTrace();
58. return null;
59. }finally{
60. try {
61. if(is!=null){
62. is.close();
63. }
64. } catch (IOException e) {
65. e.printStackTrace();
66. }
67. try {
68. if(baos!=null){
69. baos.close();
70. }
71. } catch (IOException e) {
72. e.printStackTrace();
73. }
74. }
75. }
76. }
定义好类加载器后，为了测试该类加载器，我们在d:/java下定义一个HelloWorld.java
编译:javac -d . HelloWorld.java   这里要指定目录主要是 HelloWorld中有包。我们没写包，就得指定路径。
1. public class Demo03 {
2. public static void main(String[] args) throws Exception{
3. FileSystemClassLoader loader = new FileSystemClassLoader("d:/myjava");
4. FileSystemClassLoader loader2 = new FileSystemClassLoader("d:/myjava");
5. Class<?> c = loader.loadClass("com.bjsxt.gaoqi.HelloWorld");
6. Class<?> c2 = loader.loadClass("com.bjsxt.gaoqi.HelloWorld");
7. Class<?> c3 = loader2.loadClass("com.bjsxt.gaoqi.HelloWorld");
8. Class<?> c4 = loader2.loadClass("java.lang.String");
9. Class<?> c5 = loader2.loadClass("com.bjsxt.test.Demo01");
10. System.out.println(c.hashCode());
11. System.out.println(c2.hashCode());//c2=c
12. System.out.println(c3.hashCode()); //同一个类，被不同的加载器加载，JVM认为也是不相同的类
13. System.out.println(c4.hashCode());
14. System.out.println(c4.getClassLoader()); //引导类加载器
15. System.out.println(c3.getClassLoader()); //自定义的类加载器
16. System.out.println(c5.getClassLoader()); //系统默认的类加载器
17. }
18. }
网络类加载器:::

1. package com.bjsxt.test;
2. import java.io.ByteArrayOutputStream;
3. import java.io.FileInputStream;
4. import java.io.IOException;
5. import java.io.InputStream;
6. import java.net.URL;
7. /**
8. * 网络类加载器
9. * @author 尚学堂高淇 www.sxt.cn
10. *
11. */
12. public class NetClassLoader extends ClassLoader {
13. //com.bjsxt.test.User --> www.sxt.cn/myjava/ com/bjsxt/test/User.class
14. private String rootUrl;
15. public NetClassLoader(String rootUrl){
16. this.rootUrl = rootUrl;
17. }
18. @Override
19. protected Class<?> findClass(String name) throws ClassNotFoundException {
20. Class<?> c = findLoadedClass(name);
21. //应该要先查询有没有加载过这个类。如果已经加载，则直接返回加载好的类。如果没有，则加载新的类。
22. if(c!=null){
23. return c;
24. }else{
25. ClassLoader parent = this.getParent();
26. try {
27. c = parent.loadClass(name); //委派给父类加载
28. } catch (Exception e) {
29. // e.printStackTrace();
30. }
31. if(c!=null){
32. return c;
33. }else{
34. byte[] classData = getClassData(name);
35. if(classData==null){
36. throw new ClassNotFoundException();
37. }else{
38. c = defineClass(name, classData, 0,classData.length);
39. }
40. }
41. }
42. return c;
43. }
44. private byte[] getClassData(String classname){ //com.bjsxt.test.User d:/myjava/ com/bjsxt/test/User.class
45. String path = rootUrl +"/"+ classname.replace('.', '/')+".class";
46. // IOUtils,可以使用它将流中的数据转成字节数组
47. InputStream is = null;
48. ByteArrayOutputStream baos = new ByteArrayOutputStream();
49. try{
50. URL url = new URL(path);
51. is = url.openStream();
52. byte[] buffer = new byte[1024];
53. int temp=0;
54. while((temp=is.read(buffer))!=-1){
55. baos.write(buffer, 0, temp);
56. }
57. return baos.toByteArray();
58. }catch(Exception e){
59. e.printStackTrace();
60. return null;
61. }finally{
62. try {
63. if(is!=null){
64. is.close();
65. }
66. } catch (IOException e) {
67. e.printStackTrace();
68. }
69. try {
70. if(baos!=null){
71. baos.close();
72. }
73. } catch (IOException e) {
74. e.printStackTrace();
75. }
76. }
77. }
78. }
自定义加密解密加载器：
1. package com.bjsxt.test;
2. import java.io.File;
3. import java.io.FileInputStream;
4. import java.io.FileNotFoundException;
5. import java.io.FileOutputStream;
6. import java.io.IOException;
7. /**
8. * 加密工具类
9. * @author 尚学堂高淇 www.sxt.cn
10. *
11. */
12. public class EncrptUtil {
13. public static void main(String[] args) {
14. encrpt("d:/myjava/HelloWorld.class", "d:/myjava/temp/HelloWorld.class");
15. }
16. public static void encrpt(String src, String dest){
17. FileInputStream fis = null;
18. FileOutputStream fos = null;
19. try {
20. fis = new FileInputStream(src);
21. fos = new FileOutputStream(dest);
22. int temp = -1;
23. while((temp=fis.read())!=-1){
24. fos.write(temp^0xff); //取反操作
25. }
26. } catch (Exception e) {
27. e.printStackTrace();
28. }finally{
29. try {
30. if(fis!=null){
31. fis.close();
32. }
33. } catch (IOException e) {
34. e.printStackTrace();
35. }
36. try {
37. if(fos!=null){
38. fos.close();
39. }
40. } catch (IOException e) {
41. e.printStackTrace();
42. }
43. }
44. }
45. }
1. package com.bjsxt.test;
2. import java.io.ByteArrayOutputStream;
3. import java.io.FileInputStream;
4. import java.io.IOException;
5. import java.io.InputStream;
6. /**
7. * 加载文件系统中加密后的class字节码的类加载器
8. * @author 尚学堂高淇 www.sxt.cn
9. *
10. */
11. public class DecrptClassLoader extends ClassLoader {
12. //com.bjsxt.test.User --> d:/myjava/ com/bjsxt/test/User.class
13. private String rootDir;
14. public DecrptClassLoader(String rootDir){
15. this.rootDir = rootDir;
16. }
17. @Override
18. protected Class<?> findClass(String name) throws ClassNotFoundException {
19. Class<?> c = findLoadedClass(name);
20. //应该要先查询有没有加载过这个类。如果已经加载，则直接返回加载好的类。如果没有，则加载新的类。
21. if(c!=null){
22. return c;
23. }else{
24. ClassLoader parent = this.getParent();
25. try {
26. c = parent.loadClass(name); //委派给父类加载
27. } catch (Exception e) {
28. // e.printStackTrace();
29. }
30. if(c!=null){
31. return c;
32. }else{
33. byte[] classData = getClassData(name);
34. if(classData==null){
35. throw new ClassNotFoundException();
36. }else{
37. c = defineClass(name, classData, 0,classData.length);
38. }
39. }
40. }
41. return c;
42. }
43. private byte[] getClassData(String classname){ //com.bjsxt.test.User d:/myjava/ com/bjsxt/test/User.class
44. String path = rootDir +"/"+ classname.replace('.', '/')+".class";
45. // IOUtils,可以使用它将流中的数据转成字节数组
46. InputStream is = null;
47. ByteArrayOutputStream baos = new ByteArrayOutputStream();
48. try{
49. is = new FileInputStream(path);
50. int temp = -1;
51. while((temp=is.read())!=-1){
52. baos.write(temp^0xff); //取反操作,相当于解密
53. }
54. return baos.toByteArray();
55. }catch(Exception e){
56. e.printStackTrace();
57. return null;
58. }finally{
59. try {
60. if(is!=null){
61. is.close();
62. }
63. } catch (IOException e) {
64. e.printStackTrace();
65. }
66. try {
67. if(baos!=null){
68. baos.close();
69. }
70. } catch (IOException e) {
71. e.printStackTrace();
72. }
73. }
74. }
75. }
1. public class Demo04 {
2. public static void main(String[] args) throws Exception {
3. //测试取反操作
4. // int a = 3; //0000011
5. // System.out.println(Integer.toBinaryString(a^0xff));
6. //加密后的class文件，正常的类加载器无法加载，报classFormatError
7. // FileSystemClassLoader loader = new FileSystemClassLoader("d:/myjava/temp");
8. // Class<?> c = loader.loadClass("HelloWorld");
9. // System.out.println(c);
10. DecrptClassLoader loader = new DecrptClassLoader("d:/myjava/temp");
11. Class<?> c = loader.loadClass("HelloWorld");
12. System.out.println(c);
13. }
14. }
双亲委托机制以及类加载器的问题：
                    一般情况下，保证同一个类中所关联的其它类都是由当前类的类加载器所加载的。例如ClassA本身是在Ext下找到的，那么他里面new出来的一些类也只能用Ext去加载了，不会低一个级别。所以有些明明APP可以找到的，却找不到了。例如JDBC API的接口与实现类。
                    线程类加载器是为了抛弃双亲委派加载链模式，每个线程都有一个关联的上下文类加载器，如果使用new Thread()方式生成新的线程，新线程将继承其父线程的上下文加载器，如果程序对线程上下文类加载器没有任何改动的话，程序中所有的线程都使用系统类加载器作为上下文类加载器。
                    Thread.currentThread().getContextClassLoader()
                    Thread.currentThread().setContextClassLoader()
1. public class Demo05 {
2. public static void main(String[] args) throws Exception {
3. ClassLoader loader = Demo05.class.getClassLoader();
4. System.out.println(loader);
5. ClassLoader loader2 = Thread.currentThread().getContextClassLoader();
6. System.out.println(loader2);
7. Thread.currentThread().setContextClassLoader(new FileSystemClassLoader("d:/myjava/"));
8. System.out.println(Thread.currentThread().getContextClassLoader());
9. Class<Demo01> c = (Class<Demo01>) Thread.currentThread().getContextClassLoader().loadClass("com.bjsxt.test.Demo01");
10. System.out.println(c);
11. System.out.println(c.getClassLoader());
12. }
13. }
tomcat服务器的类加载机制：
                    一切都是为了安全，TOMCAT不能使用系统默认的类加载器，如果TOMCAT跑你的WEB项目使用系统的类加载器是相当危险的，你可以直接毫无忌惮的操作系统的各个目录了。
                    对于运行在J2EE容器中的WEB应用来说，类加载器的实现方式与一般的JAVA应用有所不同。每个WEB应用都有一个对应的类加载器实例，该类加载器也使用代理模式，所不同的是它是首先尝试去加载某个类，如果找不到再代理给父类加载器，与一般类加载器的顺序是相反的，但也是为了保证安全，这样核心库就不在查询范围之内。为了安全TOMCAT需要实现自己的类加载器，。
OSGI模块介绍：OSGI是JAVA上的动态模块系统，它为开发人员提供了面向服务和基于组件的运行环境，并提供标准的方式用来管理软件的生命周期。OSGI已经被实现和部署在很多系统上， eclipse就是基于OSGI技术来构建的。OSGI中的每个模块都包含JAVA包和类，模块可以声明它所依赖的需要导入的其它模块的包和类，也可以声明导出自己的包和类。OSGI中的每个模块都有一个类加载器，它负责加载模块自己所包含的类和包，当它需要加载JAVA核心库的类时，它会代理给父类加载器来完成。当它需要加载所导入的JAVA类时，它会代理给导出此JAVA类的模块来完成加载。详细可以学习Equinox(OSGI的一个实现)


JDK类加载器剖析
nanxiaotao的博客
04-05 1617
我之所以深入研究 Java 类加载器，是为了解决一个奇怪的问题。流行出版物，也就是人们所认为的 Java 世界的灯塔，充斥着关于这个主题的相互矛盾和过时的信息。这种矛盾引发了我的调查 — — 在 Java 类加载器的迷宫中寻求清晰的答案。 作为一名 Java 开发人员，您可能遇到过ClassNotFoundException一些NoClassDefFoundError神秘的消息，它们会暂时中断您的编码流程。旨在阐明这些问题的在线资源往往反而增加了混乱。
JVM类加载器
rockvine的博客
05-17 3305
文章目录一、类加载器二、类与类加载器三、双亲委派模型四、破坏双亲委派模型4.1、Tomcat4.1.1、WebApp类加载器4.1.2、Shared类加载器4.1.3、Catalina类加载器4.1.4、Common类加载器4.1.5、Jsp类加载器4.2、JDBC 一、类加载器 从Java虚拟机的角度来讲，只存在两种不同的类加载器：一种是启动类加载器（Bootstrap ClassLoader），这个类加载器使用C++语言实现，是虚拟机自身的一部分；另一种就是所有其他的类加载器，这些类加载器都由Java语
Java - 类加载器
热门推荐
从零开始的博客
05-02 1万+
文章目录1. 类加载的过程2. 类加载器的分类2.1 启动类加载器 Bootstrap2.2 扩展类加载器 ExtClassLoader2.3 系统类加载器 AppClassLoader3. 双亲委派机制4. ClassLoader抽象类2.4 加载时机3. 参考资料 1. 类加载的过程 图片来源: 系统学习让你轻松定义java类加载器 类加载器的作用就是将.class文件加载到内存。 2. 类加载器的分类 2.1 启动类加载器 Bootstrap 启动类加载器属于JVM的一部分，C++实现。 负责加
Java类加载器
纯洁的小魔鬼
01-19 2528
一.类的生命周期 1. 加载（Loading）：找 Class 文件 1. 通过一个类的全限定名来获取定义此类的二进制字节流。 2.将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构。 3.在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口。 这里既可以从 ZIP 包中读取（比如从 jar 包和 war 包中读取），也可以在运行时计算生成（动态代理），也可以由其它文件生成（比如将 JSP 文件转换成对应的 Class 类）。 2. 验证（
Android类加载器
zhukui66的专栏
02-21 3080
Android类加载器
类加载器详解
我的博客
08-28 1万+
类加载器的分类 JVM支持两种类型的类加载器,分别为引导类加载器(BootstrapClassLoader)和自定义类加载器(User-Defined ClassLoader) 从概念上来讲, 自定义类加载器一般指的是程序中由开发人员自定义的一类,类加载器,但是Java虚拟机规范却没有这么定义,而是将所有派生于抽象类ClassLoader的类加载器都划分为自定义类加载器 无论类加载器的类型如何划分,在程序中我们最常见的类加载器始终只有3个,如下所示: 所以具体为引导类加载器(BootstrapClassL
一文彻底搞懂什么是类加载器
永远在路上
02-19 1785
在Java中，类加载器（Class Loader）是Java虚拟机（JVM）的重要组成部分，JVM只会运行二进制文件，而类加载器（ClassLoader）的主要作用就是从文件系统、网络等地方加载Java类文件到内存，并在运行时动态链接和验证这些类。类加载器负责加载Java字节码文件，并将其转换为可执行的Java类或接口。现有的类加载器基本上都是java.lang.ClassLoader的子类，该类的只要职责就是用于将指定的类找到或生成对应的字节码文件，同时类加载器还会负责加载程序所需要的资源。
类加载器详解(自己实现类加载器)
超负荷运转
05-09 3572
目的：看懂4，并且自己实现一个类加载器 1.类加载器是什么东西 2.类加载器的种类 3.类加载器的机制 4.自己实现一个类加载器 在这里引用大佬的链接，这个是讲的很详细的，如果心急,不想细细研究那就直接看我总结的吧 类加载器是什么东西？ 1.类加载器就是加载所有的类的工具，它加载的类在内存中只会存在一份，也就是生成的堆中的Class对象。不可以重复加载 2.在我们java编码里，一个类是用全限定名(包名加类名)标识的唯一的一个类，但在jvm里是根据类加载器+全限定名来标识，也就是说不同类加载器加载的同一个类
JVM之类加载器
缘友一世的博客
11-11 1183
一个Tomcat程序中是可以运行多个Web应用的，如果这两个应用中出现了相同限定名的类，比如Servlet类，Tomcat要保证这两个类都能加载并且它们应该是不同的类。如果不打破双亲委派机制，当应用类加载器加载Web应用1中的MyServlet之后，Web应用2中相同限定名的MyServlet类就无法被加载。Tomcat使用了自定义类加载器来实现应用之间类的隔离。每一个应用会有一个独立的类加载器加载对应的类。先来分析ClassLoader的原理，ClassLoader中包含了4个核心方法。
classloader类加载器_基于java类的加载方式详解
08-29
Java类加载器（ClassLoader）是Java虚拟机（JVM）中的一个重要组成部分，用于将Java类文件加载到JVM中，以便能够执行Java程序。在Java中，类加载器的设计采用了一种称为“双亲委派模式”（Parent Delegation Model）...
Java基于自定义类加载器实现热部署过程解析
08-19
"Java基于自定义类加载器实现热部署过程解析" Java中基于自定义类加载器实现热部署是指在不重启应用的情况下，当类的定义即字节码文件修改后，能够替换该Class创建的对象。热部署是Java中的一个重要概念，它可以...
java类加载器
11-12
类加载器的设计遵循双亲委派模型，它分为三个主要部分：启动类加载器、扩展类加载器和应用类加载器。 #### 二、类加载过程 类加载过程主要包括三个步骤： 1. **加载**：通过类的全限定名找到该类的二进制字节流。...
java类加载器详解，通过java文件详细说明java的类加载器
05-04
Java类加载器是Java语言的核心组件之一，负责从文件系统或网络中加载Class文件，Class文件在文件开头有特定的文件标识（即CA FE BA BE）。类加载器只负责加载类，并不负责类的实例化，这一点是由JVM的运行时数据区中...
Java类加载器加载类顺序
12-22
java ClassLoader的学习 　java是一门解释执行的语言，由开发人员编写好的java源文件先编译成字节码文件.class... 　一个类如果要被JVM所调度执行，必须先把这个类加载到JVM内存里，java.lang下有个很重要的类ClassL
网络工程师面试题(80%命中率).doc
07-08
网络工程师面试题(80%命中率).doc
springboot基于起点小说网数据的文本分析系统设计与实现_7134v95o_kk003.zip
07-08
springboot基于起点小说网数据的文本分析系统设计与实现_7134v95o_kk003
论多网融合在通信工程中的应用(1).docx
最新发布
07-09
论多网融合在通信工程中的应用(1).docx
【Java开发工具】Maven下载安装与配置教程：项目管理和构建自动化工具详细指南
07-08
内容概要：本文详细介绍了Maven的下载、安装与配置方法。Maven是基于项目对象模型（POM）的概念，用于项目管理和构建自动化的工具，能有效管理项目依赖、规范项目结构并提供标准化的构建流程。文章首先简述了Maven的功能特点及其重要性，接着列出了系统要求，包括操作系统、磁盘空间等。随后，分别针对Windows、macOS和Linux系统的用户提供了详细的下载和安装指导，涵盖了解压安装包、配置环境变量的具体操作。此外，还讲解了如何配置本地仓库和镜像源（如阿里云），以优化依赖项的下载速度。最后，给出了常见的错误解决方案，如环境变量配置错误、JDK版本不兼容等问题的处理方法。 适合人群：适用于初学者以及有一定经验的Java开发人员，特别是那些希望提升项目构建和依赖管理效率的技术人员。 使用场景及目标： ①帮助开发者掌握Maven的基本概念和功能特性； ②指导用户完成Maven在不同操作系统上的安装与配置； ③教会用户如何配置本地仓库和镜像源以加快依赖项下载； ④解决常见的安装和配置过程中遇到的问题。 阅读建议：由于Maven的安装和配置涉及多个步骤，建议读者按照文中提供的顺序逐步操作，并仔细检查每个环节的细节，尤其是环境变量的配置。同时，在遇到问题时，可参考文末提供的常见问题解决方案，确保顺利完成整个配置过程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值