类加载器

最新推荐文章于 2024-05-22 18:18:00 发布
转载 最新推荐文章于 2024-05-22 18:18:00 发布 · 119 阅读 · 0

自定义类加载器的流程：
                                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类加载器
什么是类加载器，类加载器如何分类
weixin_46665411的博客
11-02 2006
③ 在内存中生成一个代表这个类的java.lang.Class对象，任何类被使用时，系统都会为创建一个java.lang.Class对象，即加载完毕创建一个class对象。链接阶段的第一步，这一阶段为了确保Class文件字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机的自身安全，即文件中的信息是否符合虚拟机规范，有没有安全隐患。将类的二进制数据流中的符号引用替换为直接引用，即本类中如果用到了其他的类，此时就需要找到对应的类。类加载器：负责将.class文件（存储的物理文件）加载到内存中。
Java 自定义类加载器
进击的小猴
05-22 1376
自定义类加载器在Java中是非常有用的，它们提供了许多高级功能和灵活性，使得开发者能够根据自己的需求定制类的加载行为。自定义类加载器允许开发者创建独立的类空间，从而隔离不同的类库。这对于某些插件式架构或模块化系统非常有用，其中每个插件或模块都有自己的类库和依赖项。通过使用不同的类加载器加载这些类库，可以避免版本冲突和依赖问题。自定义类加载器允许在不重启应用程序的情况下，重新加载和更新已加载的类。这对于需要频繁更新或替换代码的系统非常有用，如Web应用程序。
类加载器详解
我的博客
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的子类，该类的只要职责就是用于将指定的类找到或生成对应的字节码文件，同时类加载器还会负责加载程序所需要的资源。
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
2013年春季省开课程网络形考“经营管理实务”第三次作业.doc
07-08
2013年春季省开课程网络形考“经营管理实务”第三次作业.doc
【数据科学工具】Anaconda下载安装与配置教程：涵盖系统要求、安装步骤及环境配置
07-08
内容概要：本文详细介绍了Anaconda的下载、安装与配置方法（2025最新版）。Anaconda是一个开源的Python/R数据科学集成开发平台，预装了1500多个科学计算库，并提供conda包管理和环境管理功能。文章首先列出了系统要求，接着分别讲述了适用于不同操作系统的下载方式，包括官方下载和国内镜像下载。然后，具体讲解了Windows、macOS和Linux三种操作系统的安装步骤，以及环境变量的手动配置方法。此外，还提供了验证安装是否成功的命令和配置国内镜像源的方法，以提高下载速度。最后，列出了一些常用conda命令和常见问题的解决方案。 适合人群：从事数据科学、机器学习领域的研究人员和开发者，特别是需要频繁使用Python科学计算库的用户。 使用场景及目标：①帮助用户快速搭建Python开发环境，尤其是需要多个Python版本共存或隔离环境的情况下；②解决因网络原因导致的下载速度慢的问题；③提供详细的安装指南，确保安装过程顺利进行；④指导用户正确配置环境变量，避免常见的安装后无法使用的错误。 阅读建议：由于Anaconda涉及多平台安装和配置，建议读者根据自己的操作系统选择相应的章节重点阅读，并严格按照步骤操作。对于初次使用者，建议先从简单的安装入手，再逐步学习环境管理和包管理的相关命令。
综合布线设计内容.doc
最新发布
07-08
综合布线设计内容.doc
成功的项目管理.docx
07-08
成功的项目管理.docx
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值