ClassLoader_类加载器

于 2023-04-29 19:49:47 发布
阅读量1.6k 收藏
点赞数
文章标签： java c# c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41812346/article/details/130377677
版权

1.

package com.example.demo10;


public class Demo10Application {

    public static void main(String[] args) {
       Calculator calculator = new Calculator(6000);
       double result = calculator.calculate();
       System.out.println(result);
    }

}

package com.example.demo10;

public class Calculator {

    private int number;

    private double multiple = 1.2;

    public double calculate(){
        return this.number * this.multiple;
    }

    public Calculator() {
    }

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    public Calculator(int number) {
        this.number = number;
    }
}

运行结果：

 

 

 2.从classpath类路径外加载  Calculator 类

package com.example.demo10;


import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;

public class Demo10Application {

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

        //创建URL对象
        URL url = new URL("file:C:/Minecloud/IDEA_workspace/myapp.jar");
        //创建一个URLClassLoader，负责加载的范围是 {url}
        URLClassLoader urlClassLoader = new URLClassLoader(new URL[] {url});
        // 到urlClassLoader所负责的范围 寻早并加载 指定的类
        Class clazz = urlClassLoader.loadClass("com.example.Calculator");
        //调用有参构造创建该类的对象，参数是有参构造的参数列表(区分重载)
        Object obj = clazz.getConstructor(int.class).newInstance(20000);
        //获取指定的方法
        Method method = clazz.getMethod("calculate");
        //调用该方法
        double result = (double) method.invoke(obj);

        System.out.println(result);
    }

}

将Calculator打成jar包放到类路径外
package com.example;

public class Calculator {

    private int number;

    private double multiple = 1.2;

    public double calculate(){
        return this.number * this.multiple;
    }

    public Calculator() {
    }

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    public Calculator(int number) {
        this.number = number;
    }
}

 

运行程序

 

 

3.修改class文件，自定义类加载器

修改class文件

package com.example.demo10;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class Demo {
    public static void main(String[] args) throws Exception{
        //原文件
        File originalFile = new File("C:\\Minecloud\\IDEA_workspace\\springboot02\\myapp\\target\\classes\\com\\example\\Calculator.class");
        FileInputStream originalFis = new FileInputStream(originalFile);

        //修改后的目标文件
        File targetFile = new File("C:\\Minecloud\\IDEA_workspace\\Calculator.class");
        FileOutputStream targetFos = new FileOutputStream(targetFile);

        //原文件头部添加一个字节（值为8），形成目标文件
        int code = 8;
        targetFos.write(code);

        //fis.read() = -1 代表已经读到文件的末尾
        while( (code=originalFis.read()) != -1 ){
            targetFos.write(code);
        }

        originalFis.close();
        targetFos.close();

    }
}

将修改后的class文件打成jar包

 自定义类加载器需要实现ClassLoader 

SecureClassLoader 实现了ClassLoader 

自定义类加载器 继承 SecureClassLoader

自定义类加载器从jar中读取修改后的class文件

package com.example.demo10;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.nio.ByteBuffer;
import java.security.SecureClassLoader;
import java.util.ArrayList;

public class MyClassLoader extends SecureClassLoader {

    private String jarFile;

    //重写findClass 自定义如何加载类
    @Override
    protected Class<?> findClass(String name) {
        //类名转换为路径
        String classPath = name.replace(".","/").concat(".class");
        int code;
        byte[] b;
        ByteArrayOutputStream bs = new ByteArrayOutputStream();
        try{
            //读取class文件 为 byte数组
            URL url = new URL( "jar:file:\\" + this.jarFile + "!/" + classPath);
            InputStream is = url.openStream();
            while ( (code=is.read()) !=   -1 ){
                bs.write( (byte)code );
            }
            b = bs.toByteArray();


            /*
            defineClass将二进制字节流转换成 Class 对象实例
            参数：
            name：字符串类型，表示要装入作为类名的二进制名称。如 com.example.MyClass
            b：byte 数组类型，表示要装入内存的二进制数据。
            off：int 类型，表示数组起始位置的偏移量（offset）。（这里跳过一个字节才能正确解析，）
            len：int 类型，表示要装入的数组长度。
             */
            return this.defineClass(name,b,1,b.length-1);

        }catch(Exception e){
            e.printStackTrace();
            return null;
        }finally {
            try {
                bs.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public MyClassLoader() {
    }

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

    public String getJarFile() {
        return jarFile;
    }

    public void setJarFile(String jarFile) {
        this.jarFile = jarFile;
    }
}

package com.example.demo10;

import java.lang.reflect.Method;


public class Demo010 {
    public static void main(String[] args) throws Exception{
        //创建自定义的类加载器
        MyClassLoader classLoader = new MyClassLoader("C:\\Minecloud\\IDEA_workspace\\myapp.jar");

        //加载指定类 （loadClass 中会调用 findClass ）
        Class clazz = classLoader.loadClass("com.example.Calculator");

        //调用有参构造创建该类的对象，参数是有参构造的参数列表(区分重载)
        Object obj = clazz.getConstructor(int.class).newInstance(20000);
        //获取指定的方法
        Method method = clazz.getMethod("calculate");
        //调用该方法
        double result = (double) method.invoke(obj);

        System.out.println(result);
    }
}

运行结果：

 

4.

打破双亲委派

ClassLoader中的 loadClass

        1.  findLoadedClass(name)从缓存中查找是否已经加载过该类

        2.没有加载过 且 有父加载器，调用父加载器 loadClass,没有父加载器（即当前为Bootstrap类加载器），调用findBootstrapClassOrNull(name) 从Bootstrap类加载器负责的范围中加载所需的类。从父加载器中没有加载到需要的类，再调用 当前类加载器findClass(name) 去加载所需要的类。

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;
        }
    }

自定义类加载器中重写loadClass

package com.example.demo10;

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


public class MyClassLoader extends SecureClassLoader {

    private String jarFile;

    //重写 loadClass 方法 ，打破双亲委派
    @Override
    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){
                //优先调用当前类加载器的 findClass 加载所需要的类
                c = this.findClass(name);
                // 当前类加载器加载不到所需要的类，再让父加载器去加载
                if( c == null  ){
                    c = super.loadClass(name,resolve);
                }
            }
            return c;
        }


    }

    //重写findClass 自定义如何加载类
    @Override
    protected Class<?> findClass(String name) {
        //类名转换为路径
        String classPath = name.replace(".","/").concat(".class");
        int code;
        byte[] b;
        ByteArrayOutputStream bs = new ByteArrayOutputStream();
        try{
            //读取class文件 为 byte数组
            URL url = new URL( "jar:file:\\" + this.jarFile + "!/" + classPath);
            InputStream is = url.openStream();
            while ( (code=is.read()) !=   -1 ){
                bs.write( (byte)code );
            }
            b = bs.toByteArray();


            /*
            defineClass将二进制字节流转换成 Class 对象实例
            参数：
            name：字符串类型，表示要装入作为类名的二进制名称。如 com.example.MyClass
            b：byte 数组类型，表示要装入内存的二进制数据。
            off：int 类型，表示数组起始位置的偏移量（offset）。
            len：int 类型，表示要装入的数组长度。
             */
            return this.defineClass(name,b,0,b.length);

        }catch(Exception e){
            return null;
        }finally {
            try {
                bs.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public MyClassLoader() {
    }

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

    public String getJarFile() {
        return jarFile;
    }

    public void setJarFile(String jarFile) {
        this.jarFile = jarFile;
    }
}

类路径下的 Calculator类

package com.example;

public class Calculator {

    private int number;

    private double multiple = 1;

    public double calculate(){
        return this.number * this.multiple;
    }

    public Calculator() {
    }

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    public Calculator(int number) {
        this.number = number;
    }
}

类路径外 jar 中的 Calculator 类

package com.example;

public class Calculator {

    private int number;

    private double multiple = 1.2;

    public double calculate(){
        return this.number * this.multiple;
    }

    public Calculator() {
    }

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    public Calculator(int number) {
        this.number = number;
    }
}

 main方法

package com.example.demo10;

import java.lang.reflect.Method;


public class Demo010 {
    public static void main(String[] args) throws Exception{
        //创建自定义的类加载器
        MyClassLoader classLoader = new MyClassLoader("C:\\Minecloud\\IDEA_workspace\\myapp.jar");

        //加载指定类 （loadClass 中会调用 findClass ）
        Class clazz = classLoader.loadClass("com.example.Calculator");

        //调用有参构造创建该类的对象，参数是有参构造的参数列表(区分重载)
        Object obj = clazz.getConstructor(int.class).newInstance(20000);
        //获取指定的方法
        Method method = clazz.getMethod("calculate");
        //调用该方法
        double result = (double) method.invoke(obj);

        System.out.println(result);
    }
}

结果：加载的是类路径外 jar 中的Calculator 类

 

如果不重写 loadClass 

结果：加载的是类路径下 的Calculator 类

 


                

        

        

    




    

      

        

            

              
                
                  若云止水
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
URLClassLoader初体验

				
			

			

				

					08-08
				

			

		

		

			
				
NULL
博文链接：https://shihuan830619.iteye.com/blog/2160884

			
		

	



                

              
                



	

		

			

				
					
classloader类加载器_基于java类的加载方式详解

				
			

			

				

					08-29
				

			

		

		

			
				
扩展类加载器是一个Java类，它在运行时被Bootstrap ClassLoader加载，并且它同样会加载扩展API中的类。  3. Application ClassLoader（应用程序类加载器）：也被称为System ClassLoader（系统类加载器），它负责加载...

			
		

	



                


  
              

                


	

		

			

				
					
类加载器-ClassLoader

					
最新发布

				
			

			

				

					小海编码日记
				

				

					04-16
					
					254
					
				

			

		

		

			
				
前文说到其主要是用来进行.class文件的加载，创建Class对象，那么应该怎么自定义呢？自定义核心在于findClass方法的实现，在findClass方法中按照我们的期望进行类及资源的查找，查找完成后通过函数来定义Class字节流即可。// 所要加载的路径Path private String mPath;try {// 使用class文件流数据定义Class return defineClass(name , b , 0 , b . length);

			
		

	





	

		

			

				
					
Java URLClassLoader

				
			

			

				

					JonsenElizee
				

				

					01-11
					
					1575
					
				

			

		

		

			
				
Closing a URLClassLoaderBy Michael McMahon  Complex Java programs, such as application servers, sometimes create their own class loaders using the URLClassLoader type. With URLClassLoader, appli

			
		

	



		

			
		



	

		

			

				
					
URL ClassLoader 类加载器

				
			

			

				

					BugAngel的博客
				

				

					12-27
					
					818
					
				

			

		

		

			
				
URL ClassLoader 是 Java 用来加载远程类的类加载器。在 flink 中，启动时使用 -C 参数可以向集群中所有节点上的每个用户代码类加载器添加一个URL，这依靠的就是 URL ClassLoader 。ClassLoader 只能加载 classpath 下面的类，而 URL ClassLoader 可以加载任意路径下的类。它继承自 SecureClassLoader，SecureClassLoader 继承自 ClassLoader 。
URL ClassLoader 可以从下面三个方

			
		

	





	

		

			

				
					
Java自定义ClassLoader加载外部类

				
			

			

				

					Myd
				

				

					11-01
					
					1717
					
				

			

		

		

			
				
前几天在GitHub上下载了一个开源项目想要运行起来，启动这个项目会关联到数据库的一些表。因此想要运行起来还需要把数据库表建好。但是这个项目涉及到几十张表，并且作者没有给建表的SQL语句。（后续：吐血中，作者在项目给了sql语句。。。。。）想用这个项目那就只好自己建表了，但是几十张表自己建一时半会儿也弄不好。有这时间还不如重新找一个新项目于是果断放弃了这个项目，结果找了一圈发现这种类型的开源Java项目还真是少。于是，没办法还是回到这个项目。

			
		

	





	

		

			

				
					
web_classloader_test.zip_web classloader

				
			

			

				

					09-14
				

			

		

		

			
				
同一类加载器加载的类可以互相访问，而不同类加载器加载的类之间默认不可见，除非使用`ClassLoader.getSystemClassLoader()`等方法获取系统类加载器。  7. **JSP与Servlet的加载**：在Web应用中，JSP和Servlet的编译...

			
		

	





	

		

			

				
					
Java类加载器ClassLoader用法解析

				
			

			

				

					08-25
				

			

		

		

			
				
Java 类加载器 ClassLoader 用法解析  Java 中的类加载器（ClassLoader）是一种机制，负责将类从文件系统、JAR 文件或网络等来源加载到 Java 虚拟机中。类加载器的作用是将类的二进制数据加载到内存中，并为其创建一...

			
		

	





	

		

			

				
					
ClassLoader类加载器

				
			

			

				

					04-13
				

			

		

		

			
				
3. Application ClassLoader：也称为系统类加载器，负责加载用户类路径`-cp`或`-classpath`指定的所有类。  当一个类被加载时，如果它的父类加载器无法加载该类，那么会将任务委派给子类加载器。这就是著名的"委托...

			
		

	





	

		

			

				
					
Java中ClassLoader类加载学习总结

				
			

			

				

					08-28
				

			

		

		

			
				
ClassLoader类的loadClass方法是实现双亲委派模型的核心方法，该方法的主要逻辑是：首先检查类是否已被加载，如果没有就判断是否已被父加载器加载，如果还没有再调用自己的findClass方法尝试加载。  知识点三：...

			
		

	





	

		

			

				
					
URLClassLoader中指定目录和jar的问题

				
			

			

				

					04-14
				

			

		

		

			
				
NULL
博文链接：https://yklovejava-163-com.iteye.com/blog/1736631

			
		

	





	

		

			

				
					
2. URLClassLoader

				
			

			

				

					Mustang
				

				

					02-26
					
					217
					
				

			

		

		

			
				
1. URLClassLoader

URLClassLoader用于加载jar包、目录指定的类、资源。
2. 应用
public class Main2 {
    public static void main(String[] args) throws Exception {
        String path = "D:/";
        File file = new File(path);
        URL url = file.toURL();
        URLClassL

			
		

	





	

		

			

				
					
URLClassLoader的使用

				
			

			

				

					Leon_Jinhai_Sun的博客
				

				

					05-30
					
					2086
					
				

			

		

		

			
				
URLClassLoader

​ 在java.net包中，JDK提供了一个更加易用的类加载器URLClassLoader，它扩展了ClassLoader，能够从本地或者网络上指定的位置加载类。我们可以使用该类作为自定义的类加载器使用。

构造方法：

public URLClassLoader(URL[] urls)：指定要加载的类所在的URL地址，父类加载器默认为系统类加载器。

public URLClassLoader(URL[] urls, ClassLoader parent)：指定要加载的类所

			
		

	





	

		

			

				
					
URLClassLoader使用方法和实例

					
热门推荐

				
			

			

				

					梦之音的专栏
				

				

					04-25
					
					3万+
					
				

			

		

		

			
				
使用概要：

  File   file   =   new   File(jar文件全路径);   
  URL   url   =   file.toURL();   
  URLClassLoader   loader   =   new   URLClassLoader(new   URL[]   {   url   });   
  Class   tidyClazz   = 

			
		

	





	

		

			

				
					
java通过URLClassLoader类加载器加载外部jar

				
			

			

				

					feinifi的博客
				

				

					04-15
					
					7012
					
				

			

		

		

			
				
本文主要讲如何动态调用外部jar，以及调用外部jar过程中可能遇到的问题。我们需要注意，外部jar内部依赖的jar，虽然在jar中，但是因为路径中包含了!/，并不能被访问到，所以需要将内部jar读出来，并写入本地。

			
		

	





	

		

			

				
					
使用 URLClassLoader 加载和卸载类

				
			

			

				

					Engure
				

				

					01-06
					
					931
					
				

			

		

		

			
				
使用 URLClassLoader 加载或卸载类

			
		

	





	

		

			

				
					
URLClassLoader使用方法及事例程序

				
			

			

				

					
				

				

					01-08
					
					7374
					
				

			

		

		

			
				
使用概要：  File   file   =   new   File(jar文件全路径);     URL   url   =   file.toURL();     URLClassLoader   loader   =   new   URLClassLoader(new   URL[]   {   url   });     Class   tidyClazz   =   loader

			
		

	





	

		

			

				
					
Java ClassLoader 03 -- URLClassLoader 动态加载

				
			

			

				

					fengxianaa的博客
				

				

					04-27
					
					2733
					
				

			

		

		

			
				
Java ClassLoader 03 -- URLClassLoader 动态加载 自定义类加载器，打破双亲委派模式

			
		

	





	

		

			

				
					
Java类加载器深度解析：ClassLoader的工作原理与层级结构

				
			

			

				

					
				

			

		

		

			
				
"深入解析Java中的Class Loader类加载器，涵盖了类加载的过程、类加载器的层级及其作用。"  Java中的类加载器是JVM（Java虚拟机）的关键组成部分，它们负责将类文件从磁盘加载到JVM内存中并执行相应的生命周期操作。...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值